source: branches/pyyaml3000/tests/test_structure.py @ 57

Revision 57, 8.4 KB checked in by xi, 9 years ago (diff)

Fix a few bugs.

Line 
1
2import test_appliance
3
4from yaml import *
5
6class TestStructure(test_appliance.TestAppliance):
7
8    def _testStructure(self, test_name, data_filename, structure_filename):
9        node1 = None
10        node2 = eval(file(structure_filename, 'rb').read())
11        try:
12            parser = Parser(Scanner(Reader(file(data_filename, 'rb'))))
13            node1 = []
14            while not parser.check(StreamEndEvent):
15                node1.append(self._convert(parser))
16            parser.get()
17            if len(node1) == 1:
18                node1 = node1[0]
19            self.failUnlessEqual(node1, node2)
20        except:
21            print
22            print "DATA:"
23            print file(data_filename, 'rb').read()
24            print "NODE1:", node1
25            print "NODE2:", node2
26            raise
27
28    def _convert(self, parser):
29        if parser.check(ScalarEvent):
30            event = parser.get()
31            if event.tag or event.anchor or event.value:
32                return True
33            else:
34                return None
35        elif parser.check(SequenceEvent):
36            parser.get()
37            sequence = []
38            while not parser.check(CollectionEndEvent):
39                sequence.append(self._convert(parser))
40            parser.get()
41            return sequence
42        elif parser.check(MappingEvent):
43            parser.get()
44            mapping = []
45            while not parser.check(CollectionEndEvent):
46                key = self._convert(parser)
47                value = self._convert(parser)
48                mapping.append((key, value))
49            parser.get()
50            return mapping
51        elif parser.check(AliasEvent):
52            parser.get()
53            return '*'
54        else:
55            parser.get()
56            return '?'
57
58TestStructure.add_tests('testStructure', '.data', '.structure')
59
60class TestParser(test_appliance.TestAppliance):
61
62    def _testParser(self, test_name, data_filename, canonical_filename):
63        events1 = None
64        events2 = None
65        try:
66            parser = Parser(Scanner(Reader(file(data_filename, 'rb'))))
67            events1 = list(iter(parser))
68            canonical = test_appliance.CanonicalParser(file(canonical_filename, 'rb').read())
69            events2 = canonical.parse()
70            self._compare(events1, events2)
71        except:
72            print
73            print "DATA1:"
74            print file(data_filename, 'rb').read()
75            print "DATA2:"
76            print file(canonical_filename, 'rb').read()
77            print "EVENTS1:", events1
78            print "EVENTS2:", events2
79            raise
80
81    def _compare(self, events1, events2):
82        self.failUnlessEqual(len(events1), len(events2))
83        for event1, event2 in zip(events1, events2):
84            self.failUnlessEqual(event1.__class__, event2.__class__)
85            if isinstance(event1, AliasEvent):
86                #self.failUnlessEqual(event1.name, event2.name)
87                pass
88            elif isinstance(event1, ScalarEvent):
89                #self.failUnlessEqual(event1.anchor, event2.anchor)
90                #self.failUnlessEqual(event1.tag, event2.tag)
91                self.failUnlessEqual(event1.value, event2.value)
92            if isinstance(event1, CollectionEvent):
93                #self.failUnlessEqual(event1.anchor, event2.anchor)
94                #self.failUnlessEqual(event1.tag, event2.tag)
95                pass
96
97TestParser.add_tests('testParser', '.data', '.canonical')
98
99class TestResolver(test_appliance.TestAppliance):
100
101    def _testResolver(self, test_name, data_filename, canonical_filename):
102        nodes1 = None
103        nodes2 = None
104        try:
105            resolver1 = Resolver(Composer(Parser(Scanner(Reader(file(data_filename, 'rb'))))))
106            nodes1 = list(iter(resolver1))
107            canonical = test_appliance.CanonicalParser(file(canonical_filename, 'rb').read())
108            canonical.parse()
109            resolver2 = Resolver(Composer(canonical))
110            nodes2 = list(iter(resolver2))
111            self.failUnlessEqual(len(nodes1), len(nodes2))
112            for node1, node2 in zip(nodes1, nodes2):
113                self._compare(node1, node2)
114        except:
115            print
116            print "DATA1:"
117            print file(data_filename, 'rb').read()
118            print "DATA2:"
119            print file(canonical_filename, 'rb').read()
120            print "NODES1:", nodes1
121            print "NODES2:", nodes2
122            raise
123
124    def _compare(self, node1, node2):
125        self.failUnlessEqual(node1.__class__, node2.__class__)
126        if isinstance(node1, ScalarNode):
127            #self.failUnlessEqual(node1.tag, node2.tag)
128            self.failUnlessEqual(node1.value, node2.value)
129        elif isinstance(node1, SequenceNode):
130            self.failUnlessEqual(len(node1.value), len(node2.value))
131            for item1, item2 in zip(node1.value, node2.value):
132                self._compare(item1, item2)
133        elif isinstance(node1, MappingNode):
134            self.failUnlessEqual(len(node1.value), len(node2.value))
135            items1 = node1.value.items()
136            items1.sort(lambda (k1,v1), (k2,v2): cmp((k1.tag,k1.value,v1.tag,v1.value),
137                                                    (k2.tag,k2.value,v2.tag,v2.value)))
138            items2 = node2.value.items()
139            items2.sort(lambda (k1,v1), (k2,v2): cmp((k1.tag,k1.value,v1.tag,v1.value),
140                                                    (k2.tag,k2.value,v2.tag,v2.value)))
141            for (key1, value1), (key2, value2) in zip(items1, items2):
142                self._compare(key1, key2)
143                self._compare(value1, value2)
144
145TestResolver.add_tests('testResolver', '.data', '.canonical')
146
147class MyConstructor(Constructor):
148
149    def construct_sequence(self, node):
150        return tuple(Constructor.construct_sequence(self, node))
151
152    def construct_mapping(self, node):
153        pairs = self.construct_pairs(node)
154        pairs.sort()
155        return pairs
156
157MyConstructor.add_constructor(None, MyConstructor.construct_scalar)
158
159class TestConstructor(test_appliance.TestAppliance):
160
161    def _testConstructor(self, test_name, data_filename, canonical_filename):
162        natives1 = None
163        natives2 = None
164        try:
165            constructor1 = MyConstructor(Resolver(Composer(Parser(Scanner(Reader(file(data_filename, 'rb')))))))
166            natives1 = list(iter(constructor1))
167            canonical = test_appliance.CanonicalParser(file(canonical_filename, 'rb').read())
168            canonical.parse()
169            constructor2 = MyConstructor(Resolver(Composer(canonical)))
170            natives2 = list(iter(constructor2))
171            self.failUnlessEqual(natives1, natives2)
172        except:
173            print
174            print "DATA1:"
175            print file(data_filename, 'rb').read()
176            print "DATA2:"
177            print file(canonical_filename, 'rb').read()
178            print "NATIVES1:", natives1
179            print "NATIVES2:", natives2
180            raise
181
182TestConstructor.add_tests('testConstructor', '.data', '.canonical')
183
184class TestParserOnCanonical(test_appliance.TestAppliance):
185
186    def _testParserOnCanonical(self, test_name, canonical_filename):
187        events1 = None
188        events2 = None
189        try:
190            parser = Parser(Scanner(Reader(file(canonical_filename, 'rb'))))
191            events1 = list(iter(parser))
192            canonical = test_appliance.CanonicalParser(file(canonical_filename, 'rb').read())
193            events2 = canonical.parse()
194            self._compare(events1, events2)
195        except:
196            print
197            print "DATA:"
198            print file(canonical_filename, 'rb').read()
199            print "EVENTS1:", events1
200            print "EVENTS2:", events2
201            raise
202
203    def _compare(self, events1, events2):
204        self.failUnlessEqual(len(events1), len(events2))
205        for event1, event2 in zip(events1, events2):
206            self.failUnlessEqual(event1.__class__, event2.__class__)
207            if isinstance(event1, AliasEvent):
208                self.failUnlessEqual(event1.anchor, event2.anchor)
209            elif isinstance(event1, ScalarEvent):
210                self.failUnlessEqual(event1.anchor, event2.anchor)
211                self.failUnlessEqual(event1.tag, event2.tag)
212                self.failUnlessEqual(event1.value, event2.value)
213            if isinstance(event1, CollectionEvent):
214                self.failUnlessEqual(event1.anchor, event2.anchor)
215                self.failUnlessEqual(event1.tag, event2.tag)
216
217TestParserOnCanonical.add_tests('testParserOnCanonical', '.canonical')
218
Note: See TracBrowser for help on using the repository browser.