source: pyyaml/trunk/tests3/test_structure.py @ 328

Revision 328, 6.6 KB checked in by xi, 5 years ago (diff)

Added basic support for Python 3 (Thanks idadesub(at)users(dot)sourceforge(dot)net).

Line 
1
2import yaml, canonical
3import pprint
4
5def _convert_structure(loader):
6    if loader.check_event(yaml.ScalarEvent):
7        event = loader.get_event()
8        if event.tag or event.anchor or event.value:
9            return True
10        else:
11            return None
12    elif loader.check_event(yaml.SequenceStartEvent):
13        loader.get_event()
14        sequence = []
15        while not loader.check_event(yaml.SequenceEndEvent):
16            sequence.append(_convert_structure(loader))
17        loader.get_event()
18        return sequence
19    elif loader.check_event(yaml.MappingStartEvent):
20        loader.get_event()
21        mapping = []
22        while not loader.check_event(yaml.MappingEndEvent):
23            key = _convert_structure(loader)
24            value = _convert_structure(loader)
25            mapping.append((key, value))
26        loader.get_event()
27        return mapping
28    elif loader.check_event(yaml.AliasEvent):
29        loader.get_event()
30        return '*'
31    else:
32        loader.get_event()
33        return '?'
34
35def test_structure(data_filename, structure_filename, verbose=False):
36    nodes1 = []
37    nodes2 = eval(open(structure_filename, 'r').read())
38    try:
39        loader = yaml.Loader(open(data_filename, 'rb'))
40        while loader.check_event():
41            if loader.check_event(yaml.StreamStartEvent, yaml.StreamEndEvent,
42                                yaml.DocumentStartEvent, yaml.DocumentEndEvent):
43                loader.get_event()
44                continue
45            nodes1.append(_convert_structure(loader))
46        if len(nodes1) == 1:
47            nodes1 = nodes1[0]
48        assert nodes1 == nodes2, (nodes1, nodes2)
49    finally:
50        if verbose:
51            print("NODES1:")
52            pprint.pprint(nodes1)
53            print("NODES2:")
54            pprint.pprint(nodes2)
55
56test_structure.unittest = ['.data', '.structure']
57
58def _compare_events(events1, events2, full=False):
59    assert len(events1) == len(events2), (len(events1), len(events2))
60    for event1, event2 in zip(events1, events2):
61        assert event1.__class__ == event2.__class__, (event1, event2)
62        if isinstance(event1, yaml.AliasEvent) and full:
63            assert event1.anchor == event2.anchor, (event1, event2)
64        if isinstance(event1, (yaml.ScalarEvent, yaml.CollectionStartEvent)):
65            if (event1.tag not in [None, '!'] and event2.tag not in [None, '!']) or full:
66                assert event1.tag == event2.tag, (event1, event2)
67        if isinstance(event1, yaml.ScalarEvent):
68            assert event1.value == event2.value, (event1, event2)
69
70def test_parser(data_filename, canonical_filename, verbose=False):
71    events1 = None
72    events2 = None
73    try:
74        events1 = list(yaml.parse(open(data_filename, 'rb')))
75        events2 = list(yaml.canonical_parse(open(canonical_filename, 'rb')))
76        _compare_events(events1, events2)
77    finally:
78        if verbose:
79            print("EVENTS1:")
80            pprint.pprint(events1)
81            print("EVENTS2:")
82            pprint.pprint(events2)
83
84test_parser.unittest = ['.data', '.canonical']
85
86def test_parser_on_canonical(canonical_filename, verbose=False):
87    events1 = None
88    events2 = None
89    try:
90        events1 = list(yaml.parse(open(canonical_filename, 'rb')))
91        events2 = list(yaml.canonical_parse(open(canonical_filename, 'rb')))
92        _compare_events(events1, events2, full=True)
93    finally:
94        if verbose:
95            print("EVENTS1:")
96            pprint.pprint(events1)
97            print("EVENTS2:")
98            pprint.pprint(events2)
99
100test_parser_on_canonical.unittest = ['.canonical']
101
102def _compare_nodes(node1, node2):
103    assert node1.__class__ == node2.__class__, (node1, node2)
104    assert node1.tag == node2.tag, (node1, node2)
105    if isinstance(node1, yaml.ScalarNode):
106        assert node1.value == node2.value, (node1, node2)
107    else:
108        assert len(node1.value) == len(node2.value), (node1, node2)
109        for item1, item2 in zip(node1.value, node2.value):
110            if not isinstance(item1, tuple):
111                item1 = (item1,)
112                item2 = (item2,)
113            for subnode1, subnode2 in zip(item1, item2):
114                _compare_nodes(subnode1, subnode2)
115
116def test_composer(data_filename, canonical_filename, verbose=False):
117    nodes1 = None
118    nodes2 = None
119    try:
120        nodes1 = list(yaml.compose_all(open(data_filename, 'rb')))
121        nodes2 = list(yaml.canonical_compose_all(open(canonical_filename, 'rb')))
122        assert len(nodes1) == len(nodes2), (len(nodes1), len(nodes2))
123        for node1, node2 in zip(nodes1, nodes2):
124            _compare_nodes(node1, node2)
125    finally:
126        if verbose:
127            print("NODES1:")
128            pprint.pprint(nodes1)
129            print("NODES2:")
130            pprint.pprint(nodes2)
131
132test_composer.unittest = ['.data', '.canonical']
133
134def _make_loader():
135    global MyLoader
136
137    class MyLoader(yaml.Loader):
138        def construct_sequence(self, node):
139            return tuple(yaml.Loader.construct_sequence(self, node))
140        def construct_mapping(self, node):
141            pairs = self.construct_pairs(node)
142            pairs.sort()
143            return pairs
144        def construct_undefined(self, node):
145            return self.construct_scalar(node)
146
147    MyLoader.add_constructor('tag:yaml.org,2002:map', MyLoader.construct_mapping)
148    MyLoader.add_constructor(None, MyLoader.construct_undefined)
149
150def _make_canonical_loader():
151    global MyCanonicalLoader
152
153    class MyCanonicalLoader(yaml.CanonicalLoader):
154        def construct_sequence(self, node):
155            return tuple(yaml.CanonicalLoader.construct_sequence(self, node))
156        def construct_mapping(self, node):
157            pairs = self.construct_pairs(node)
158            pairs.sort()
159            return pairs
160        def construct_undefined(self, node):
161            return self.construct_scalar(node)
162
163    MyCanonicalLoader.add_constructor('tag:yaml.org,2002:map', MyCanonicalLoader.construct_mapping)
164    MyCanonicalLoader.add_constructor(None, MyCanonicalLoader.construct_undefined)
165
166def test_constructor(data_filename, canonical_filename, verbose=False):
167    _make_loader()
168    _make_canonical_loader()
169    native1 = None
170    native2 = None
171    try:
172        native1 = list(yaml.load_all(open(data_filename, 'rb'), Loader=MyLoader))
173        native2 = list(yaml.load_all(open(canonical_filename, 'rb'), Loader=MyCanonicalLoader))
174        assert native1 == native2, (native1, native2)
175    finally:
176        if verbose:
177            print("NATIVE1:")
178            pprint.pprint(native1)
179            print("NATIVE2:")
180            pprint.pprint(native2)
181
182test_constructor.unittest = ['.data', '.canonical']
183
184if __name__ == '__main__':
185    import test_appliance
186    test_appliance.run(globals())
187
Note: See TracBrowser for help on using the repository browser.