tests/test_structure.py

   1
   2 import test_appliance
   3
   4 from yaml.reader import Reader
   5 from yaml.scanner import Scanner
   6 from yaml.parser import *
   7 from yaml.composer import *
   8 from yaml.resolver import *
   9 from yaml.constructor import *
  10 from yaml.nodes import *
  11
  12 class 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
  64 TestStructure.add_tests('testStructure', '.data', '.structure')
  65
  66 class 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
 103 TestParser.add_tests('testParser', '.data', '.canonical')
 104
 105 class 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
 151 TestResolver.add_tests('testResolver', '.data', '.canonical')
 152
 153 class 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
 163 class 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
 186 TestConstructor.add_tests('testConstructor', '.data', '.canonical')
 187
 188 class 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
 221 TestParserOnCanonical.add_tests('testParserOnCanonical', '.canonical')
 222