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

Revision 55, 8.5 KB checked in by xi, 8 years ago (diff)

Working on Constructor.

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