def test_generator_second_shorted(self):
     self.checkRaises(
         generator(1, 2, 3), generator(1, 2),
         "Sequence not as expected:\n\n"
         "same:\n(1, 2)\n\n"
         "first:\n(3,)\n\n"
         "second:\n()")

 def test_generator_different(self):
     self.checkRaises(
         generator(1, 2, 3), generator(1, 2, 4),
         "Sequence not as expected:\n\n"
         "same:\n(1, 2)\n\n"
         "first:\n(3,)\n\n"
         "second:\n(4,)")

 def test_generator_totally_different(self):
     self.check_raises(
         generator(1, ), generator(2, ),
         "sequence not as expected:\n\n"
         "same:\n()\n\n"
         "first:\n(1,)\n\n"
         "second:\n(2,)"
         )

 def test_generator_first_shorter(self):
     self.check_raises(
         generator(1, 2), generator(1, 2, 3),
         "sequence not as expected:\n\n"
         "same:\n(1, 2)\n\n"
         "first:\n()\n\n"
         "second:\n(3,)"
         )

 def test_nested_labels(self):
     obj1 = singleton('obj1')
     obj2 = singleton('obj2')
     gen1 = generator(obj1, obj2)
     gen2 = generator(obj1, )
     # dict -> list -> tuple -> generator
     self.check_raises(
         dict(x=[1, ('a', 'b', gen1), 3], y=[3, 4]),
         dict(x=[1, ('a', 'b', gen2), 3], y=[3, 4]), (
             "dict not as expected:\n"
             "\n"
             "same:\n"
             "['y']\n"
             "\n"
             "values differ:\n"
             "'x': [1, ('a', 'b', {gen1}), 3] (expected) != "
             "[1, ('a', 'b', {gen2}), 3] (actual)\n"
             "\n"
             "While comparing ['x']: sequence not as expected:\n"
             "\n"
             "same:\n"
             "[1]\n"
             "\n"
             "expected:\n"
             "[('a', 'b', {gen1}), 3]\n"
             "\n"
             "actual:\n"
             "[('a', 'b', {gen2}), 3]\n"
             "\n"
             "While comparing ['x'][1]: sequence not as expected:\n"
             "\n"
             "same:\n"
             "('a', 'b')\n"
             "\n"
             "expected:\n"
             "({gen1},)\n"
             "\n"
             "actual:\n"
             "({gen2},)\n"
             "\n"
             "While comparing ['x'][1][2]: sequence not as expected:\n"
             "\n"
             "same:\n"
             "(<obj1>,)\n"
             "\n"
             "expected:\n"
             "(<obj2>,)\n"
             "\n"
             "actual:\n"
             "()"
             ).format(gen1=hexsub(repr(gen1)),
                      gen2=hexsub(repr(gen2))),
         x_label='expected',
         y_label='actual',
         )

 def test_deep_breadcrumbs(self):
     obj1 = singleton('obj1')
     obj2 = singleton('obj2')
     gen1 = generator(obj1, obj2)
     gen2 = generator(obj1, )
     # dict -> list -> tuple -> generator
     self.check_raises(
         dict(x=[1, ('a', 'b', gen1), 3], y=[3, 4]),
         dict(x=[1, ('a', 'b', gen2), 3], y=[3, 4]), (
             "dict not as expected:\n"
             "\n"
             "same:\n"
             "['y']\n"
             "\n"
             "values differ:\n"
             "'x': [1, ('a', 'b', {gen1}), 3] != [1, ('a', 'b', {gen2}), 3]"
             "\n\n"
             "While comparing ['x']: sequence not as expected:\n"
             "\n"
             "same:\n"
             "[1]\n"
             "\n"
             "first:\n"
             "[('a', 'b', {gen1}), 3]\n"
             "\n"
             "second:\n"
             "[('a', 'b', {gen2}), 3]\n"
             "\n"
             "While comparing ['x'][1]: sequence not as expected:\n"
             "\n"
             "same:\n"
             "('a', 'b')\n"
             "\n"
             "first:\n"
             "({gen1},)\n"
             "\n"
             "second:\n"
             "({gen2},)\n"
             "\n"
             "While comparing ['x'][1][2]: sequence not as expected:\n"
             "\n"
             "same:\n"
             "(<obj1>,)\n"
             "\n"
             "first:\n"
             "(<obj2>,)\n"
             "\n"
             "second:\n"
             "()"
             ).format(gen1=hexsub(repr(gen1)),
                      gen2=hexsub(repr(gen2)))
         )

 def test_nested_generator_different(self):
     self.check_raises(
         generator(1, 2, generator(3), 4),
         generator(1, 2, generator(3), 5),
         "sequence not as expected:\n"
         "\n"
         "same:\n"
         "(1, 2, <generator object generator at ...>)\n"
         "\n"
         "first:\n"
         "(4,)\n"
         "\n"
         "second:\n"
         "(5,)"
         )

    def test_simple(self):
        # we use our own parser to get a convertor and a constant in there
        class TheParser(Parser):
            
            class ARecord(Record):
                prefix = Discriminator('A')
                data = Field(2, int)
                const = Field(1, one_of(
                    x = Constant('X', 'an X'),
                    y = Constant('Y', 'a Y'),
                    ))
                    
            class BRecord(Record):
                prefix = Discriminator('B')
                d1 = Field(2)
                d2 = Field(2)

        compare(generator(
            TheParser.BRecord.type(prefix='B', d1='XX', d2='YY'),
            TheParser.ARecord.type(prefix='A',
                                   data=2,
                                   const=TheParser.ARecord.const.x
                                   ),
            TheParser.ARecord.type(prefix='A',
                                   data=13,
                                   const=TheParser.ARecord.const.y),
            ), TheParser(['BXXYY', 'A 2X', 'A13Y']))

 def test_short_lines_for_disc(self):
     compare(generator(
         C('fixed.UnknownRecordType',
           discriminator='',
           line='',
           args=())
         ), self.parser(['']))

 def test_generator_and_sequence(self):
     expected = compile(
         "\(1, 2, 3\) != <generator object (generator )?at ...>")
     self.checkRaises(
         (1, 2, 3),
         generator(1, 2, 3),
         regex=expected,
     )

 def test_file(self):
     with TempDirectory() as dir:
         path = dir.write('file', 'AXX\nBYY\n')
         with open(path) as source:
             compare(generator(
                 self.parser.ARecord.type('A', 'XX'),
                 self.parser.BRecord.type('B', 'YY'),
                 ), self.parser(source))

    def test_generator_with_buggy_generator(self):
        def bad_gen():
            yield 1
            # raising a TypeError here is important :-/
            raise TypeError('foo')

        with ShouldRaise(TypeError('foo')):
            compare(generator(1, 2, 3), bad_gen())

 def test_fixed_width(self):
     # make sure file wrapped with iterator works
     with TempDirectory() as dir:
         path = dir.write('file', 'AXXBYY')
         with open(path) as source:
             compare(generator(
                 self.parser.ARecord.type('A', 'XX'),
                 self.parser.BRecord.type('B', 'YY'),
                 ), self.parser(Chunker(source, 3)))

 def test_unknown_record_type_returns(self):
     # Return rather than raise exception.
     # This is optimised to be fast.
     compare(generator(
         C('fixed.UnknownRecordType',
           discriminator='C',
           line='CXX',
           args=())
         ), self.parser(['CXX']))

 def test_sequence_and_generator_strict(self):
     expected = compile(
         "\(1, 2, 3\) \(<(class|type) 'tuple'>\) != "
         "<generator object (generator )?at... "
         "\(<(class|type) 'generator'>\)"
         )
     self.checkRaises(
         (1,2,3), generator(1,2,3),
         regex=expected,
         strict=True,
         )

 def test_iterable_and_generator_strict(self):
     expected = compile(
         "x?range\(1, 4\) \(<(class|type) 'x?range'>\) != "
         "<generator object (generator )?at... "
         "\(<(class|type) 'generator'>\)"
         )
     self.check_raises(
         xrange(1, 4), generator(1, 2, 3),
         regex=expected,
         strict=True,
         )

 def test_sequence_and_generator_strict(self):
     expected = compile(
         "\(1, 2, 3\) \(<(class|type) 'tuple'>\) \(expected\) != "
         "<generator object (generator )?at... "
         "\(<(class|type) 'generator'>\) \(actual\)"
         )
     self.check_raises(
         (1, 2, 3), generator(1, 2, 3),
         regex=expected,
         strict=True,
         x_label='expected',
         y_label='actual',
         )

    def test_ignore_unknown_rows(self):
        class MyHandler(Handler):
            # the magic line:
            parse_unknown = False
            # stuff for testing:
            @handles(self.parser.ARecord)
            def handle_ARecord(self, rec):
                pass
            @handles(fixed.UnknownRecordType)
            def handle_unknown(self, source, line_no, rec):
                return source, line_no, rec

        handler = MyHandler()
        source = ['CYY']
        compare(generator(), handler.handled(source))

    def test_method_handles_multiple_types(self):

        class MyHandler(Handler):

            @handles(self.parser.ARecord)
            @handles(self.parser.BRecord)
            def handle_ARecord(self, source, line_no, rec):
                return (source, line_no, rec)

        handler = MyHandler()
        source = ['AXX', 'BYY']
        handler.handle(source)
        compare(generator(
            (source, 1, self.parser.ARecord.type('A', 'XX')),
            (source, 2, self.parser.BRecord.type('B', 'YY')),
            ), handler.handled(source))

    def test_exception_handling_implemented(self):
        class MyHandler(Handler):
            @handles(self.parser.ARecord)
            def handle_ARecord(self, rec):
                pass
            @handles(fixed.UnknownRecordType)
            def handle_unknown(self, source, line_no, rec):
                return source, line_no, rec

        handler = MyHandler()
        source = ['CYY']
        compare(generator(
            (source, 1, C('fixed.UnknownRecordType',
                          discriminator='C',
                          line='CYY',
                          args=())),
            ), handler.handled(source))