Changeset 136 for pyyaml/trunk/tests

Timestamp:

04/15/06 19:54:52 (6 years ago)

Author:

xi

Message:

Major refactoring.

Location:

pyyaml/trunk/tests

Files:

• data/construct-custom.code (modified) (1 diff)
• data/construct-custom.data (modified) (1 diff)
• data/spec-08-07.canonical (modified) (1 diff)
• data/tags.events (modified) (1 diff)
• test_appliance.py (modified) (6 diffs)
• test_canonical.py (modified) (2 diffs)
• test_constructor.py (modified) (4 diffs)
• test_detector.py (modified) (3 diffs)
• test_emitter.py (modified) (6 diffs)
• test_errors.py (modified) (2 diffs)
• test_representer.py (modified) (4 diffs)
• test_structure.py (modified) (8 diffs)
• test_tokens.py (modified) (3 diffs)

pyyaml/trunk/tests/data/construct-custom.code

@@ -7 +7 @@
     MyTestClass3(x=1, y=2, z=3),
     MyTestClass3(x=1, y=2, z=3),
+    YAMLObject1(my_parameter='foo', my_another_parameter=[1,2,3])
 ]

pyyaml/trunk/tests/data/construct-custom.data

@@ -22 +22 @@
   'y': 2
   z: 3
+- !foo
+  my-parameter: foo
+  my-another-parameter: [1,2,3]

pyyaml/trunk/tests/data/spec-08-07.canonical

@@ -4 +4 @@
   !<tag:yaml.org,2002:str> "12",
   !<tag:yaml.org,2002:int> "12",
-  !<tag:yaml.org,2002:str> "12",
+#  !<tag:yaml.org,2002:str> "12",
+  !<tag:yaml.org,2002:int> "12",
 ]

pyyaml/trunk/tests/data/tags.events

@@ -3 +3 @@
 - !SequenceStart
 - !Scalar { value: 'data' }
-- !Scalar { tag: '!', value: 'data' }
+#- !Scalar { tag: '!', value: 'data' }
 - !Scalar { tag: 'tag:yaml.org,2002:str', value: 'data' }
 - !Scalar { tag: '!myfunnytag', value: 'data' }

pyyaml/trunk/tests/test_appliance.py

@@ -2 +2 @@
 import unittest, os
 
-from yaml.tokens import *
-from yaml.events import *
+from yaml import *
 
 class TestAppliance(unittest.TestCase):
@@ -44 +43 @@
         self.data = unicode(data, 'utf-8')+u'\0'
         self.index = 0
+        self.scan()
+
+    def check_token(self, *choices):
+        if self.tokens:
+            if not choices:
+                return True
+            for choice in choices:
+                if isinstance(self.tokens[0], choice):
+                    return True
+        return False
+
+    def peek_token(self):
+        if self.tokens:
+            return self.tokens[0]
+
+    def get_token(self, choice=None):
+        token = self.tokens.pop(0)
+        if choice and not isinstance(token, choice):
+            raise Error("unexpected token "+repr(token))
+        return token
+
+    def get_token_value(self):
+        token = self.get_token()
+        return token.value
 
     def scan(self):
-        #print self.data[self.index:]
-        tokens = []
-        tokens.append(StreamStartToken(None, None))
+        self.tokens = []
+        self.tokens.append(StreamStartToken(None, None))
         while True:
             self.find_token()
             ch = self.data[self.index]
             if ch == u'\0':
-                tokens.append(StreamEndToken(None, None))
+                self.tokens.append(StreamEndToken(None, None))
                 break
             elif ch == u'%':
-                tokens.append(self.scan_directive())
+                self.tokens.append(self.scan_directive())
             elif ch == u'-' and self.data[self.index:self.index+3] == u'---':
                 self.index += 3
-                tokens.append(DocumentStartToken(None, None))
+                self.tokens.append(DocumentStartToken(None, None))
             elif ch == u'[':
                 self.index += 1
-                tokens.append(FlowSequenceStartToken(None, None))
+                self.tokens.append(FlowSequenceStartToken(None, None))
             elif ch == u'{':
                 self.index += 1
-                tokens.append(FlowMappingStartToken(None, None))
+                self.tokens.append(FlowMappingStartToken(None, None))
             elif ch == u']':
                 self.index += 1
-                tokens.append(FlowSequenceEndToken(None, None))
+                self.tokens.append(FlowSequenceEndToken(None, None))
             elif ch == u'}':
                 self.index += 1
-                tokens.append(FlowMappingEndToken(None, None))
+                self.tokens.append(FlowMappingEndToken(None, None))
             elif ch == u'?':
                 self.index += 1
-                tokens.append(KeyToken(None, None))
+                self.tokens.append(KeyToken(None, None))
             elif ch == u':':
                 self.index += 1
-                tokens.append(ValueToken(None, None))
+                self.tokens.append(ValueToken(None, None))
             elif ch == u',':
                 self.index += 1
-                tokens.append(FlowEntryToken(None, None))
+                self.tokens.append(FlowEntryToken(None, None))
             elif ch == u'*' or ch == u'&':
-                tokens.append(self.scan_alias())
+                self.tokens.append(self.scan_alias())
             elif ch == u'!':
-                tokens.append(self.scan_tag())
+                self.tokens.append(self.scan_tag())
             elif ch == u'"':
-                tokens.append(self.scan_scalar())
+                self.tokens.append(self.scan_scalar())
             else:
                 raise Error("invalid token")
-        return tokens
 
     DIRECTIVE = u'%YAML 1.1'
@@ -204 +225 @@
 class CanonicalParser:
 
-    def __init__(self, data):
-        self.scanner = CanonicalScanner(data)
+    def __init__(self):
         self.events = []
+        self.parse()
 
     # stream: STREAM-START document* STREAM-END
     def parse_stream(self):
-        self.consume_token(StreamStartToken)
+        self.get_token(StreamStartToken)
         self.events.append(StreamStartEvent(None, None))
-        while not self.test_token(StreamEndToken):
-            if self.test_token(DirectiveToken, DocumentStartToken):
+        while not self.check_token(StreamEndToken):
+            if self.check_token(DirectiveToken, DocumentStartToken):
                 self.parse_document()
             else:
                 raise Error("document is expected, got "+repr(self.tokens[self.index]))
-        self.consume_token(StreamEndToken)
+        self.get_token(StreamEndToken)
         self.events.append(StreamEndEvent(None, None))
 
@@ -223 +244 @@
     def parse_document(self):
         node = None
-        if self.test_token(DirectiveToken):
-            self.consume_token(DirectiveToken)
-        self.consume_token(DocumentStartToken)
+        if self.check_token(DirectiveToken):
+            self.get_token(DirectiveToken)
+        self.get_token(DocumentStartToken)
         self.events.append(DocumentStartEvent(None, None))
         self.parse_node()
@@ -232 +253 @@
     # node: ALIAS | ANCHOR? TAG? (SCALAR|sequence|mapping)
     def parse_node(self):
-        if self.test_token(AliasToken):
-            self.events.append(AliasEvent(self.get_value(), None, None))
+        if self.check_token(AliasToken):
+            self.events.append(AliasEvent(self.get_token_value(), None, None))
         else:
             anchor = None
-            if self.test_token(AnchorToken):
-                anchor = self.get_value()
+            if self.check_token(AnchorToken):
+                anchor = self.get_token_value()
             tag = None
-            if self.test_token(TagToken):
-                tag = self.get_value()
-            if self.test_token(ScalarToken):
-                self.events.append(ScalarEvent(anchor, tag, self.get_value(), None, None))
-            elif self.test_token(FlowSequenceStartToken):
+            if self.check_token(TagToken):
+                tag = self.get_token_value()
+            if self.check_token(ScalarToken):
+                self.events.append(ScalarEvent(anchor, tag, False, self.get_token_value(), None, None))
+            elif self.check_token(FlowSequenceStartToken):
                 self.events.append(SequenceStartEvent(anchor, tag, None, None))
                 self.parse_sequence()
-            elif self.test_token(FlowMappingStartToken):
+            elif self.check_token(FlowMappingStartToken):
                 self.events.append(MappingStartEvent(anchor, tag, None, None))
                 self.parse_mapping()
@@ -254 +275 @@
     # sequence: SEQUENCE-START (node (ENTRY node)*)? ENTRY? SEQUENCE-END
     def parse_sequence(self):
-        self.consume_token(FlowSequenceStartToken)
-        if not self.test_token(FlowSequenceEndToken):
+        self.get_token(FlowSequenceStartToken)
+        if not self.check_token(FlowSequenceEndToken):
             self.parse_node()
-            while not self.test_token(FlowSequenceEndToken):
-                self.consume_token(FlowEntryToken)
-                if not self.test_token(FlowSequenceEndToken):
+            while not self.check_token(FlowSequenceEndToken):
+                self.get_token(FlowEntryToken)
+                if not self.check_token(FlowSequenceEndToken):
                     self.parse_node()
-        self.consume_token(FlowSequenceEndToken)
+        self.get_token(FlowSequenceEndToken)
         self.events.append(SequenceEndEvent(None, None))
 
     # mapping: MAPPING-START (map_entry (ENTRY map_entry)*)? ENTRY? MAPPING-END
     def parse_mapping(self):
-        self.consume_token(FlowMappingStartToken)
-        if not self.test_token(FlowMappingEndToken):
+        self.get_token(FlowMappingStartToken)
+        if not self.check_token(FlowMappingEndToken):
             self.parse_map_entry()
-            while not self.test_token(FlowMappingEndToken):
-                self.consume_token(FlowEntryToken)
-                if not self.test_token(FlowMappingEndToken):
+            while not self.check_token(FlowMappingEndToken):
+                self.get_token(FlowEntryToken)
+                if not self.check_token(FlowMappingEndToken):
                     self.parse_map_entry()
-        self.consume_token(FlowMappingEndToken)
+        self.get_token(FlowMappingEndToken)
         self.events.append(MappingEndEvent(None, None))
 
     # map_entry: KEY node VALUE node
     def parse_map_entry(self):
-        self.consume_token(KeyToken)
+        self.get_token(KeyToken)
         self.parse_node()
-        self.consume_token(ValueToken)
+        self.get_token(ValueToken)
         self.parse_node()
 
-    def test_token(self, *choices):
-        for choice in choices:
-            if isinstance(self.tokens[self.index], choice):
+    def parse(self):
+        self.parse_stream()
+
+    def get_event(self):
+        return self.events.pop(0)
+
+    def check_event(self, *choices):
+        if self.events:
+            if not choices:
                 return True
+            for choice in choices:
+                if isinstance(self.events[0], choice):
+                    return True
         return False
 
-    def consume_token(self, cls):
-        if not isinstance(self.tokens[self.index], cls):
-            raise Error("unexpected token "+repr(self.tokens[self.index]))
-        self.index += 1
-
-    def get_value(self):
-        value = self.tokens[self.index].value
-        self.index += 1
-        return value
-
-    def parse(self):
-        self.tokens = self.scanner.scan()
-        self.index = 0
-        self.parse_stream()
-        return self.events
-
-    def get(self):
-        return self.events.pop(0)
-
-    def check(self, *choices):
-        for choice in choices:
-            if isinstance(self.events[0], choice):
-                return True
-        return False
-
-    def peek(self):
+    def peek_event(self):
         return self.events[0]
 
+class CanonicalLoader(CanonicalScanner, CanonicalParser, Composer, Constructor, Detector):
+
+    def __init__(self, stream):
+        if hasattr(stream, 'read'):
+            stream = stream.read()
+        CanonicalScanner.__init__(self, stream)
+        CanonicalParser.__init__(self)
+        Composer.__init__(self)
+        Constructor.__init__(self)
+        Detector.__init__(self)
+
+def canonical_scan(stream):
+    return scan(stream, Loader=CanonicalLoader)
+
+def canonical_parse(stream):
+    return parse(stream, Loader=CanonicalLoader)
+
+def canonical_compose(stream):
+    return compose(stream, Loader=CanonicalLoader)
+
+def canonical_compose_all(stream):
+    return compose_all(stream, Loader=CanonicalLoader)
+
+def canonical_load(stream):
+    return load(stream, Loader=CanonicalLoader)
+
+def canonical_load_all(stream):
+    return load_all(stream, Loader=CanonicalLoader)
+

pyyaml/trunk/tests/test_canonical.py

@@ -6 +6 @@
     def _testCanonicalScanner(self, test_name, canonical_filename):
         data = file(canonical_filename, 'rb').read()
-        scanner = test_appliance.CanonicalScanner(data)
-        tokens = scanner.scan()
+        tokens = list(test_appliance.canonical_scan(data))
         #for token in tokens:
         #    print token
@@ -13 +12 @@
     def _testCanonicalParser(self, test_name, canonical_filename):
         data = file(canonical_filename, 'rb').read()
-        parser = test_appliance.CanonicalParser(data)
-        events = parser.parse()
+        event = list(test_appliance.canonical_parse(data))
         #for event in events:
         #    print event

pyyaml/trunk/tests/test_constructor.py

@@ -12 +12 @@
 from yaml import *
 
-class MyConstructor(Constructor):
+class MyLoader(Loader):
     pass
 
@@ -29 +29 @@
     return MyTestClass1(**mapping)
 
-MyConstructor.add_constructor("!tag1", construct1)
+MyLoader.add_constructor("!tag1", construct1)
 
 class MyTestClass2(MyTestClass1, YAMLObject):
 
-    yaml_constructor = MyConstructor
+    yaml_loader = MyLoader
     yaml_tag = "!tag2"
 
@@ -54 +54 @@
     from_yaml = classmethod(from_yaml)
 
+class YAMLObject1(YAMLObject):
+    yaml_loader = MyLoader
+    yaml_tag = '!foo'
+
+    def __init__(self, my_parameter=None, my_another_parameter=None):
+        self.my_parameter = my_parameter
+        self.my_another_parameter = my_another_parameter
+
+    def __eq__(self, other):
+        if isinstance(other, YAMLObject1):
+            return self.__class__, self.__dict__ == other.__class__, other.__dict__
+        else:
+            return False
+
 class TestTypes(test_appliance.TestAppliance):
 
     def _testTypes(self, test_name, data_filename, code_filename):
-        natives1 = None
-        natives2 = None
+        data1 = None
+        data2 = None
         try:
-            constructor1 = MyConstructor(Resolver(Composer(Parser(Scanner(Reader(file(data_filename, 'rb')))))))
-            natives1 = list(iter(constructor1))
-            if len(natives1) == 1:
-                natives1 = natives1[0]
-            natives2 = eval(file(code_filename, 'rb').read())
+            data1 = list(load_all(file(data_filename, 'rb'), Loader=MyLoader))
+            if len(data1) == 1:
+                data1 = data1[0]
+            data2 = eval(file(code_filename, 'rb').read())
             try:
-                self.failUnlessEqual(natives1, natives2)
+                self.failUnlessEqual(data1, data2)
             except AssertionError:
-                if isinstance(natives1, dict):
-                    natives1 = natives1.items()
-                    natives1.sort()
-                    natives1 = repr(natives1)
-                    natives2 = natives2.items()
-                    natives2.sort()
-                    natives2 = repr(natives2)
-                if natives1 != natives2:
+                if isinstance(data1, dict):
+                    data1 = data1.items()
+                    data1.sort()
+                    data1 = repr(data1)
+                    data2 = data2.items()
+                    data2.sort()
+                    data2 = repr(data2)
+                if data1 != data2:
                     raise
         except:
@@ -83 +96 @@
             print "CODE:"
             print file(code_filename, 'rb').read()
-            print "NATIVES1:", natives1
-            print "NATIVES2:", natives2
+            print "NATIVES1:", data1
+            print "NATIVES2:", data2
             raise
 

pyyaml/trunk/tests/test_detector.py

@@ -2 +2 @@
 import test_appliance
 
-from yaml.reader import Reader
-from yaml.scanner import Scanner
-from yaml.parser import *
-from yaml.composer import *
-from yaml.resolver import *
-from yaml.nodes import *
+from yaml import *
 
 class TestDetector(test_appliance.TestAppliance):
@@ -16 +11 @@
         try:
             correct_tag = file(detect_filename, 'rb').read().strip()
-            resolver = Resolver(Composer(Parser(Scanner(Reader(file(data_filename, 'rb'))))))
-            node = list(iter(resolver))[0]
+            node = compose(file(data_filename, 'rb'))
             self.failUnless(isinstance(node, SequenceNode))
             for scalar in node.value:
@@ -34 +28 @@
 TestDetector.add_tests('testDetector', '.data', '.detect')
 
-

pyyaml/trunk/tests/test_emitter.py

@@ -17 +17 @@
 
     def _testEmitter(self, test_name, filename, canonical=None):
-        events = list(iter(Parser(Scanner(Reader(file(filename, 'rb'))))))
-        if canonical is not None:
-            events[0].canonical = canonical
-        #self._dump(filename, events)
-        writer = StringIO.StringIO()
-        emitter = Emitter(writer)
-        for event in events:
-            emitter.emit(event)
-        data = writer.getvalue()
+        events = list(parse(file(filename, 'rb')))
+        #self._dump(filename, events, canonical)
+        stream = StringIO.StringIO()
+        emit(events, stream, canonical=canonical)
+        data = stream.getvalue()
         new_events = list(parse(data))
         for event, new_event in zip(events, new_events):
@@ -39 +35 @@
                 self.failUnlessEqual(event.value, new_event.value)
 
-    def _dump(self, filename, events):
-        writer = sys.stdout
-        emitter = Emitter(writer)
+    def _dump(self, filename, events, canonical):
         print "="*30
         print "ORIGINAL DOCUMENT:"
@@ -47 +41 @@
         print '-'*30
         print "EMITTED DOCUMENT:"
-        for event in events:
-            emitter.emit(event)
+        emit(events, sys.stdout, canonical=canonical)
         
 TestEmitter.add_tests('testEmitterOnData', '.canonical', '.data')
-#TestEmitter.add_tests('testEmitterOnCanonicalNormally', '.canonical')
-#TestEmitter.add_tests('testEmitterOnCanonicalCanonically', '.canonical')
+TestEmitter.add_tests('testEmitterOnCanonicalNormally', '.canonical')
+TestEmitter.add_tests('testEmitterOnCanonicalCanonically', '.canonical')
 
-class EventsConstructor(Constructor):
+class EventsLoader(Loader):
 
     def construct_event(self, node):
@@ -67 +60 @@
             mapping.setdefault('tag', None)
         if class_name == 'ScalarEvent':
+            mapping.setdefault('implicit', False)
             mapping.setdefault('value', '')
         value = getattr(yaml, class_name)(**mapping)
         return value
 
-EventsConstructor.add_constructor(None, EventsConstructor.construct_event)
+EventsLoader.add_constructor(None, EventsLoader.construct_event)
 
 class TestEmitterEvents(test_appliance.TestAppliance):
 
     def _testEmitterEvents(self, test_name, events_filename):
-        events = list(load(file(events_filename, 'rb'), Constructor=EventsConstructor))
+        events = list(load(file(events_filename, 'rb'), Loader=EventsLoader))
         #self._dump(events_filename, events)
-        writer = StringIO.StringIO()
-        emitter = Emitter(writer)
-        for event in events:
-            emitter.emit(event)
-        data = writer.getvalue()
+        stream = StringIO.StringIO()
+        emit(events, stream)
+        data = stream.getvalue()
         new_events = list(parse(data))
         self.failUnlessEqual(len(events), len(new_events))
@@ -97 +89 @@
 
     def _dump(self, events_filename, events):
-        writer = sys.stdout
-        emitter = Emitter(writer)
         print "="*30
         print "EVENTS:"
@@ -104 +94 @@
         print '-'*30
         print "OUTPUT:"
-        for event in events:
-            emitter.emit(event)
+        emit(events, sys.stdout)
         
 TestEmitterEvents.add_tests('testEmitterEvents', '.events')

pyyaml/trunk/tests/test_errors.py

@@ -16 +16 @@
     def _load(self, filename):
         try:
-            reader = Reader(file(filename, 'rb'))
-            scanner = Scanner(reader)
-            parser = Parser(scanner)
-            composer = Composer(parser)
-            resolver = Resolver(composer)
-            constructor = Constructor(resolver)
-            return list(constructor)
+            return list(load_all(file(filename, 'rb')))
         except YAMLError, exc:
         #except ScannerError, exc:
@@ -34 +28 @@
     def _load_string(self, filename):
         try:
-            reader = Reader(file(filename, 'rb').read())
-            scanner = Scanner(reader)
-            parser = Parser(scanner)
-            composer = Composer(parser)
-            resolver = Resolver(composer)
-            constructor = Constructor(resolver)
-            return list(constructor)
+            return list(load_all(file(filename, 'rb').read()))
         except YAMLError, exc:
         #except ScannerError, exc:

pyyaml/trunk/tests/test_representer.py

@@ -13 +13 @@
 from yaml import *
 
-class MyConstructor(Constructor):
+class MyLoader(Loader):
     pass
-class MyRepresenter(Representer):
+class MyDumper(Dumper):
     pass
 
@@ -39 +39 @@
 class MyTestClass2(MyTestClass1, YAMLObject):
 
-    yaml_constructor = MyConstructor
+    yaml_loader = MyLoader
+    yaml_dumper = MyDumper
     yaml_tag = "!tag2"
 
@@ -68 +69 @@
     to_yaml = classmethod(to_yaml)
 
-MyConstructor.add_constructor("!tag1", construct1)
-MyRepresenter.add_representer(MyTestClass1, represent1)
+MyLoader.add_constructor("!tag1", construct1)
+MyDumper.add_representer(MyTestClass1, represent1)
+
+class YAMLObject1(YAMLObject):
+    yaml_loader = MyLoader
+    yaml_dumper = MyDumper
+    yaml_tag = '!foo'
+    yaml_flow_style = True
+
+    def __init__(self, my_parameter=None, my_another_parameter=None):
+        self.my_parameter = my_parameter
+        self.my_another_parameter = my_another_parameter
+
+    def __eq__(self, other):
+        if isinstance(other, YAMLObject1):
+            return self.__class__, self.__dict__ == other.__class__, other.__dict__
+        else:
+            return False
 
 class TestTypeRepresenter(test_appliance.TestAppliance):
 
     def _testTypes(self, test_name, data_filename, code_filename):
-        natives1 = eval(file(code_filename, 'rb').read())
-        natives2 = None
+        data1 = eval(file(code_filename, 'rb').read())
+        data2 = None
         output = None
         try:
-            output = dump(natives1, Representer=MyRepresenter)
-            natives2 = load(output, Constructor=MyConstructor)
+            output = dump(data1, Dumper=MyDumper)
+            data2 = load(output, Loader=MyLoader)
             try:
-                self.failUnlessEqual(natives1, natives2)
+                self.failUnlessEqual(data1, data2)
             except AssertionError:
-                if isinstance(natives1, dict):
-                    natives1 = natives1.items()
-                    natives1.sort()
-                    natives1 = repr(natives1)
-                    natives2 = natives2.items()
-                    natives2.sort()
-                    natives2 = repr(natives2)
-                if natives1 != natives2:
+                if isinstance(data1, dict):
+                    data1 = data1.items()
+                    data1.sort()
+                    data1 = repr(data1)
+                    data2 = data2.items()
+                    data2.sort()
+                    data2 = repr(data2)
+                if data1 != data2:
                     raise
         except:
@@ -96 +113 @@
             print "OUTPUT:"
             print output
-            print "NATIVES1:", natives1
-            print "NATIVES2:", natives2
+            print "NATIVES1:", data1
+            print "NATIVES2:", data2
             raise
 

pyyaml/trunk/tests/test_structure.py

@@ -10 +10 @@
         node2 = eval(file(structure_filename, 'rb').read())
         try:
-            parser = Parser(Scanner(Reader(file(data_filename, 'rb'))))
+            loader = Loader(file(data_filename, 'rb'))
             node1 = []
-            while not parser.check(StreamEndEvent):
-                if not parser.check(StreamStartEvent, DocumentStartEvent, DocumentEndEvent):
-                    node1.append(self._convert(parser))
+            while not loader.check_event(StreamEndEvent):
+                if not loader.check_event(StreamStartEvent, DocumentStartEvent, DocumentEndEvent):
+                    node1.append(self._convert(loader))
                 else:
-                    parser.get()
-            parser.get()
+                    loader.get_event()
+            loader.get_event()
             if len(node1) == 1:
                 node1 = node1[0]
@@ -29 +29 @@
             raise
 
-    def _convert(self, parser):
-        if parser.check(ScalarEvent):
-            event = parser.get()
+    def _convert(self, loader):
+        if loader.check_event(ScalarEvent):
+            event = loader.get_event()
             if event.tag or event.anchor or event.value:
                 return True
             else:
                 return None
-        elif parser.check(SequenceStartEvent):
-            parser.get()
+        elif loader.check_event(SequenceStartEvent):
+            loader.get_event()
             sequence = []
-            while not parser.check(SequenceEndEvent):
-                sequence.append(self._convert(parser))
-            parser.get()
+            while not loader.check_event(SequenceEndEvent):
+                sequence.append(self._convert(loader))
+            loader.get_event()
             return sequence
-        elif parser.check(MappingStartEvent):
-            parser.get()
+        elif loader.check_event(MappingStartEvent):
+            loader.get_event()
             mapping = []
-            while not parser.check(MappingEndEvent):
-                key = self._convert(parser)
-                value = self._convert(parser)
+            while not loader.check_event(MappingEndEvent):
+                key = self._convert(loader)
+                value = self._convert(loader)
                 mapping.append((key, value))
-            parser.get()
+            loader.get_event()
             return mapping
-        elif parser.check(AliasEvent):
-            parser.get()
+        elif loader.check_event(AliasEvent):
+            loader.get_event()
             return '*'
         else:
-            parser.get()
+            loader.get_event()
             return '?'
 
@@ -67 +67 @@
         events2 = None
         try:
-            parser = Parser(Scanner(Reader(file(data_filename, 'rb'))))
-            events1 = list(iter(parser))
-            canonical = test_appliance.CanonicalParser(file(canonical_filename, 'rb').read())
-            events2 = canonical.parse()
+            events1 = list(parse(file(data_filename, 'rb')))
+            events2 = list(test_appliance.canonical_parse(file(canonical_filename, 'rb')))
             self._compare(events1, events2)
         except:
@@ -106 +104 @@
         nodes2 = None
         try:
-            resolver1 = Resolver(Composer(Parser(Scanner(Reader(file(data_filename, 'rb'))))))
-            nodes1 = list(iter(resolver1))
-            canonical = test_appliance.CanonicalParser(file(canonical_filename, 'rb').read())
-            canonical.parse()
-            resolver2 = Resolver(Composer(canonical))
-            nodes2 = list(iter(resolver2))
+            nodes1 = list(compose_all(file(data_filename, 'rb')))
+            nodes2 = list(test_appliance.canonical_compose_all(file(canonical_filename, 'rb')))
             self.failUnlessEqual(len(nodes1), len(nodes2))
             for node1, node2 in zip(nodes1, nodes2):
@@ -148 +142 @@
 TestResolver.add_tests('testResolver', '.data', '.canonical')
 
-class MyConstructor(Constructor):
+class MyConstructor:
 
     def construct_sequence(self, node):
@@ -158 +152 @@
         return pairs
 
-MyConstructor.add_constructor(None, MyConstructor.construct_scalar)
+    def construct_undefined(self, node):
+        return self.construct_scalar(node)
+
+class MyLoader(MyConstructor, Loader):
+    pass
+MyLoader.add_constructor(None, MyLoader.construct_undefined)
+
+class MyCanonicalLoader(MyConstructor, test_appliance.CanonicalLoader):
+    pass
+MyCanonicalLoader.add_constructor(None, MyCanonicalLoader.construct_undefined)
 
 class TestConstructor(test_appliance.TestAppliance):
 
     def _testConstructor(self, test_name, data_filename, canonical_filename):
-        natives1 = None
-        natives2 = None
-        try:
-            constructor1 = MyConstructor(Resolver(Composer(Parser(Scanner(Reader(file(data_filename, 'rb')))))))
-            natives1 = list(iter(constructor1))
-            canonical = test_appliance.CanonicalParser(file(canonical_filename, 'rb').read())
-            canonical.parse()
-            constructor2 = MyConstructor(Resolver(Composer(canonical)))
-            natives2 = list(iter(constructor2))
-            self.failUnlessEqual(natives1, natives2)
+        data1 = None
+        data2 = None
+        try:
+            data1 = list(load_all(file(data_filename, 'rb'), Loader=MyLoader))
+            data2 = list(load_all(file(canonical_filename, 'rb'), Loader=MyCanonicalLoader))
+            self.failUnlessEqual(data1, data2)
         except:
             print
@@ -179 +178 @@
             print "DATA2:"
             print file(canonical_filename, 'rb').read()
-            print "NATIVES1:", natives1
-            print "NATIVES2:", natives2
+            print "NATIVES1:", data1
+            print "NATIVES2:", data2
             raise
 
@@ -191 +190 @@
         events2 = None
         try:
-            parser = Parser(Scanner(Reader(file(canonical_filename, 'rb'))))
-            events1 = list(iter(parser))
-            canonical = test_appliance.CanonicalParser(file(canonical_filename, 'rb').read())
-            events2 = canonical.parse()
+            events1 = list(parse(file(canonical_filename, 'rb')))
+            events2 = list(test_appliance.canonical_parse(file(canonical_filename, 'rb')))
             self._compare(events1, events2)
         except:

pyyaml/trunk/tests/test_tokens.py

@@ -2 +2 @@
 import test_appliance
 
-from yaml.reader import *
-from yaml.tokens import *
-from yaml.scanner import *
+from yaml import *
 
 class TestTokens(test_appliance.TestAppliance):
@@ -52 +50 @@
         tokens2 = file(tokens_filename, 'rb').read().split()
         try:
-            scanner = Scanner(Reader(file(data_filename, 'rb')))
             tokens1 = []
-            for token in scanner:
+            for token in scan(file(data_filename, 'rb')):
                 if not isinstance(token, (StreamStartToken, StreamEndToken)):
                     tokens1.append(token)
@@ -75 +72 @@
             tokens = None
             try:
-                scanner = Scanner(Reader(file(filename, 'rb')))
                 tokens = []
-                for token in scanner:
+                for token in scan(file(filename, 'rb')):
                     if not isinstance(token, (StreamStartToken, StreamEndToken)):
                         tokens.append(token.__class__.__name__)