# This is the testrecu module. It contains code that tests the output and input of
# YAML with recursive structures. We concentrate on tuples, especially.

import yaml;

# We start with sequences.

print "We start with sequences."

RecSeq1 = [];
RecSeq1.append(RecSeq1);
print RecSeq1;
RecSeq1Dump = yaml.dump(RecSeq1);
print RecSeq1Dump;
RecSeq1Load = yaml.load(RecSeq1Dump);
print RecSeq1Load;



RecSeq2 = [];
RecSeq2.append(u"a");
RecSeq2.append(RecSeq2);
RecSeq2.append(u"b");
print RecSeq2;
RecSeq2Dump = yaml.dump(RecSeq2);
print RecSeq2Dump;
RecSeq2Load = yaml.load(RecSeq2Dump);
print RecSeq2Load;


RecSeq3 = [];
RecSeq3a = [];
RecSeq3.append(RecSeq3a);
RecSeq3a.append(RecSeq3);
print RecSeq3;
RecSeq3Dump = yaml.dump(RecSeq3);
print RecSeq3Dump;
RecSeq3Load = yaml.load(RecSeq3Dump);
print RecSeq3Load;


RecSeq4 = [];
RecSeq4a = [];
RecSeq4.append(RecSeq4a);
RecSeq4a.append(u"a");
RecSeq4a.append(RecSeq4);
RecSeq4a.append(u"b");
print RecSeq4;
RecSeq4Dump = yaml.dump(RecSeq4);
print RecSeq4Dump;
RecSeq4Load = yaml.load(RecSeq4Dump);
print RecSeq4Load;

print "End sequences."
print "We start with maps."

RecMap1 = {};
RecMap1["a"]= RecMap1;
print RecMap1;
RecMap1Dump = yaml.dump(RecMap1);
print RecMap1Dump;
RecMap1Load = yaml.load(RecMap1Dump);
print RecMap1Load;

RecMap2 = {};
RecMap2["a"] = u"d";
RecMap2["b"] = RecMap1;
RecMap2["c"] = u"e";
print RecMap2;
RecMap2Dump = yaml.dump(RecMap2);
print RecMap2Dump;
RecMap2Load = yaml.load(RecMap2Dump);
print RecMap2Load;

RecMap3 = {};
RecMap3a = {};
RecMap3["a"] = RecMap3a;
RecMap3a["b"] = RecMap3;
print RecMap3;
RecMap3Dump = yaml.dump(RecMap3);
print RecMap3Dump;
RecMap3Load = yaml.load(RecMap3Dump);
print RecMap3Load;

RecMap4 = {};
RecMap4a = {};
RecMap4["a"] = RecMap4a;
RecMap4a["b"] = u"c";
RecMap4a["d"] = RecMap4;
RecMap4a["e"] = u"f";
print RecMap4;
RecMap4Dump = yaml.dump(RecMap4);
print RecMap4Dump;
RecMap4Load = yaml.load(RecMap4Dump);
print RecMap4Load;
print "End maps."

# We try tuple code.

print "This is the tuple code.";

OurList = [];
OurTuple = tuple([OurList]);
OurList.append(OurTuple);
print OurTuple;
V = yaml.dump(OurTuple);
print V;
W = yaml.load(V);
print W;

print OurList;
V = yaml.dump(OurList);
print V;
W = yaml.load(V);
print W;


A = [];
B = ("a", A);
A.append(B);
print A;
V = yaml.dump(A);
print V;
W = yaml.load(V);
print W;
print B;
V = yaml.dump(B);
print V;
W = yaml.load(V);
print W;


A = [];
B = (A, "a");
A.append(B);
print A;
V = yaml.dump(A);
print V;
W = yaml.load(V);
print W;
print B;
V = yaml.dump(B);
print V;
W = yaml.load(V);
print W;

A = [];
B = (A, "a", "b",);
A.append(B);
print A;
V = yaml.dump(A);
print V;
W = yaml.load(V);
print W;
print B;
V = yaml.dump(B);
print V;
W = yaml.load(V);
print W;

A = [];
B = ("a", A, "b",);
A.append(B);
print A;
V = yaml.dump(A);
print V;
W = yaml.load(V);
print W;
print B;
V = yaml.dump(B);
print V;
W = yaml.load(V);
print W;

A = [];
B = ("a", "b", A,);
A.append(B);
print A;
V = yaml.dump(A);
print V;
W = yaml.load(V);
print W;
print B;
V = yaml.dump(B);
print V;
W = yaml.load(V);
print W;

A = [];
B = {};
C = ("a", A, "b", B, "d");
A.append(C);
B["c"] = C;
print A
V = yaml.dump(A);
print V;
W = yaml.load(V);
print W;
print B
V = yaml.dump(B);
print V;
W = yaml.load(V);
print W;
print C
V = yaml.dump(C);
print V;
W = yaml.load(V);
print W;

print "This is the end of the tuple code."
print "This is the recursive object test."

class TestRecurseClass:
    def __init__(self):
        self.a = "a";
        self.b = self;
        self.c = "b";
        
D = TestRecurseClass();
print D;
E = yaml.dump(D);
print E;
F = yaml.load(E);
print F;

print "This is the end of the recursive test code."
print "This is some test code for classes."

Q = "--- !!map { !!python/tuple [ 'a', ]: 'b',}"
R = yaml.load(Q);
print R;


Q = "--- &A !!set { foo: *A }"
R = yaml.load(Q);
print R;

print "This should work."

class C: 
    pass;

c = C()
s = set([c])
c.s = s
print c;
D = yaml.dump(c);
print D;
E = yaml.load(D);
print E;


print "This should not work."

Q = "--- &A !!set { *A }"
R = yaml.load(Q);
print R;