tests/test_structure.py

   1
   2 import test_appliance
   3
   4 from yaml import *
   5
   6 class 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
  58 TestStructure.add_tests('testStructure', '.data', '.structure')
  59
  60 class 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
  97 TestParser.add_tests('testParser', '.data', '.canonical')
  98
  99 class 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
 145 TestResolver.add_tests('testResolver', '.data', '.canonical')
 146
 147 class 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
 157 MyConstructor.add_constructor(None, MyConstructor.construct_scalar)
 158
 159 class 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
 182 TestConstructor.add_tests('testConstructor', '.data', '.canonical')
 183
 184 class 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
 217 TestParserOnCanonical.add_tests('testParserOnCanonical', '.canonical')
 218