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

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

Working on Constructor.

RevLine 
[44]1
2import test_appliance
3
[46]4from yaml.reader import Reader
5from yaml.scanner import Scanner
[44]6from yaml.parser import *
[54]7from yaml.composer import *
8from yaml.resolver import *
[55]9from yaml.constructor import *
[54]10from yaml.nodes import *
[44]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:
[46]18            parser = Parser(Scanner(Reader(file(data_filename, 'rb'))))
[51]19            node1 = []
20            while not parser.check(StreamEndEvent):
21                node1.append(self._convert(parser))
22            parser.get()
[44]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
[51]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()
[44]43            sequence = []
[51]44            while not parser.check(CollectionEndEvent):
45                sequence.append(self._convert(parser))
46            parser.get()
[44]47            return sequence
[51]48        elif parser.check(MappingEvent):
49            parser.get()
[44]50            mapping = []
[51]51            while not parser.check(CollectionEndEvent):
52                key = self._convert(parser)
53                value = self._convert(parser)
54                mapping.append((key, value))
55            parser.get()
[44]56            return mapping
[51]57        elif parser.check(AliasEvent):
58            parser.get()
[44]59            return '*'
60        else:
[51]61            parser.get()
62            return '?'
[44]63
64TestStructure.add_tests('testStructure', '.data', '.structure')
65
66class TestParser(test_appliance.TestAppliance):
67
68    def _testParser(self, test_name, data_filename, canonical_filename):
[51]69        events1 = None
70        events2 = None
[44]71        try:
[46]72            parser = Parser(Scanner(Reader(file(data_filename, 'rb'))))
[51]73            events1 = list(iter(parser))
74            canonical = test_appliance.CanonicalParser(file(canonical_filename, 'rb').read())
75            events2 = canonical.parse()
76            self._compare(events1, events2)
[44]77        except:
78            print
79            print "DATA1:"
80            print file(data_filename, 'rb').read()
81            print "DATA2:"
82            print file(canonical_filename, 'rb').read()
[51]83            print "EVENTS1:", events1
84            print "EVENTS2:", events2
[44]85            raise
86
[51]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
[44]102
103TestParser.add_tests('testParser', '.data', '.canonical')
104
[54]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))
[55]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):
[54]148                self._compare(key1, key2)
149                self._compare(value1, value2)
150
151TestResolver.add_tests('testResolver', '.data', '.canonical')
152
[55]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
[48]188class TestParserOnCanonical(test_appliance.TestAppliance):
189
190    def _testParserOnCanonical(self, test_name, canonical_filename):
[51]191        events1 = None
192        events2 = None
[48]193        try:
194            parser = Parser(Scanner(Reader(file(canonical_filename, 'rb'))))
[51]195            events1 = list(iter(parser))
196            canonical = test_appliance.CanonicalParser(file(canonical_filename, 'rb').read())
197            events2 = canonical.parse()
198            self._compare(events1, events2)
[48]199        except:
200            print
201            print "DATA:"
202            print file(canonical_filename, 'rb').read()
[51]203            print "EVENTS1:", events1
204            print "EVENTS2:", events2
[48]205            raise
206
[51]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):
[53]212                self.failUnlessEqual(event1.anchor, event2.anchor)
[51]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)
[48]220
221TestParserOnCanonical.add_tests('testParserOnCanonical', '.canonical')
222
Note: See TracBrowser for help on using the repository browser.