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_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_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_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_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_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_deep_breadcrumbs(self):
obj1 = singleton('obj1')
obj2 = singleton('obj2')
gen1 = generator(obj1, obj2)
gen2 = generator(obj1)
self.checkRaises(
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\nsame:\n['y']\n\nvalues differ:\n'x': [1, ('a', 'b', {gen1}), 3] != [1, ('a', 'b', {gen2}), 3]\n\nWhile comparing ['x']: sequence not as expected:\n\nsame:\n[1]\n\nfirst:\n[('a', 'b', {gen1}), 3]\n\nsecond:\n[('a', 'b', {gen2}), 3]\n\nWhile comparing ['x'][1]: sequence not as expected:\n\nsame:\n('a', 'b')\n\nfirst:\n({gen1},)\n\nsecond:\n({gen2},)\n\nWhile comparing ['x'][1][2]: sequence not as expected:\n\nsame:\n(<obj1>,)\n\nfirst:\n(<obj2>,)\n\nsecond:\n()"
.format(gen1=hexsub(repr(gen1)), gen2=hexsub(repr(gen2))))
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_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_nested_labels(self):
obj1 = singleton('obj1')
obj2 = singleton('obj2')
gen1 = generator(obj1, obj2)
gen2 = generator(obj1)
self.checkRaises(
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\nsame:\n['y']\n\nvalues differ:\n'x': [1, ('a', 'b', {gen1}), 3] (expected) != [1, ('a', 'b', {gen2}), 3] (actual)\n\nWhile comparing ['x']: sequence not as expected:\n\nsame:\n[1]\n\nexpected:\n[('a', 'b', {gen1}), 3]\n\nactual:\n[('a', 'b', {gen2}), 3]\n\nWhile comparing ['x'][1]: sequence not as expected:\n\nsame:\n('a', 'b')\n\nexpected:\n({gen1},)\n\nactual:\n({gen2},)\n\nWhile comparing ['x'][1][2]: sequence not as expected:\n\nsame:\n(<obj1>,)\n\nexpected:\n(<obj2>,)\n\nactual:\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_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.checkRaises(
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_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_generator_with_buggy_generator(self):
def bad_gen():
yield 1
raise TypeError('foo')
with ShouldRaise(TypeError('foo')):
compare(generator(1, 2, 3), bad_gen())
def test_register(self):
register_session('sqlite://')
# create the tables
session = get_session()
self.Base.metadata.create_all(session.bind)
# check registrations
compare(generator(
C('zope.component.registry.UtilityRegistration',
component=C('sqlalchemy.orm.scoping.ScopedSession'),
factory=None,
info=u'',
name=u'',
provided=ISession,
registry=self.components.registry
)),self.components.registry.registeredUtilities())
# this is what get_session goes:
session = getSiteManager().getUtility(ISession)
session.add(self.Model(id=1,name='foo'))
model = session.query(self.Model).one()
self.assertEqual(model.id,1)
self.assertEqual(model.name,'foo')
def test_register_with_name(self):
register_session('sqlite://','foo')
# check registrations
compare(generator(
C('zope.component.registry.UtilityRegistration',
component=C('sqlalchemy.orm.scoping.ScopedSession'),
factory=None,
info=u'',
name=u'foo',
provided=ISession,
registry=self.components.registry
)),self.components.registry.registeredUtilities())
registry = getSiteManager()
# check we don't register with no name:
with ShouldRaise(ComponentLookupError(ISession, u'')):
registry.getUtility(ISession)
# check we do with the right name
self.failUnless(isinstance(
registry.getUtility(ISession,'foo')(),
Session
))
def test_short_lines_for_disc(self):
compare(generator(
C('fixed.UnknownRecordType',
discriminator='',
line='',
args=())
), self.parser(['']))
def test_register_with_name(self):
register_session('sqlite://','foo')
# check registrations
compare(generator(
C('zope.component.registry.UtilityRegistration',
component=C('sqlalchemy.orm.scoping.ScopedSession'),
factory=None,
info=u'',
name=u'foo',
provided=ISession,
registry=self.components.registry
)),self.components.registry.registeredUtilities())
registry = getSiteManager()
# check we don't register with no name:
with ShouldRaise(ComponentLookupError(ISession, u'')):
registry.getUtility(ISession)
# check we do with the right name
self.failUnless(isinstance(
registry.getUtility(ISession,'foo')(),
Session
))
def test_register(self):
register_session('sqlite://')
# create the tables
session = get_session()
self.Base.metadata.create_all(session.bind)
# check registrations
compare(generator(
C('zope.component.registry.UtilityRegistration',
component=C('sqlalchemy.orm.scoping.ScopedSession'),
factory=None,
info=u'',
name=u'',
provided=ISession,
registry=self.components.registry
)),self.components.registry.registeredUtilities())
# this is what get_session goes:
session = getSiteManager().getUtility(ISession)
session.add(self.Model(id=1,name='foo'))
model = session.query(self.Model).one()
self.assertEqual(model.id,1)
self.assertEqual(model.name,'foo')
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_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_iterable_and_generator_strict(self):
expected = compile(
"x?range\\(1, 4\\) \\(<(class|type) 'x?range'>\\) != <generator object (generator )?at... \\(<(class|type) 'generator'>\\)"
)
self.checkRaises(xrange(1, 4),
generator(1, 2, 3),
regex=expected,
strict=True)
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_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_sequence_and_generator(self):
expected = compile(
"\(1, 2, 3\) != <generator object (generator )?at ...>")
self.checkRaises(
(1, 2, 3),
generator(1, 2, 3),
regex=expected,
)
def test_iterable_and_generator(self):
expected = compile(
"x?range\(1, 4\) != <generator object (generator )?at ...>")
self.checkRaises(
xrange(1, 4),
generator(1, 2, 3),
regex=expected,
)
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_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_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_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_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_sequence_and_generator_strict(self):
expected = compile(
"\\(1, 2, 3\\) \\(<(class|type) 'tuple'>\\) \\(expected\\) != <generator object (generator )?at... \\(<(class|type) 'generator'>\\) \\(actual\\)"
)
self.checkRaises((1, 2, 3),
generator(1, 2, 3),
regex=expected,
strict=True,
x_label='expected',
y_label='actual')
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'>\) != "
"<generator object (generator )?at... "
"\(<(class|type) 'generator'>\)"
)
self.checkRaises(
(1,2,3), 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_unequal_generator(self):
s = SequenceComparison(1, 3)
assert s != generator(1, 2)
compare(repr(s), expected=(
'\n'
'<SequenceComparison(ordered=True, partial=False)(failed)>\n'
'same:\n'
"[1]\n\n"
'expected:\n'
'[3]\n\n'
'actual:\n'
'[2]\n'
'</SequenceComparison(ordered=True, partial=False)>'
))
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_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_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_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))
def test_convertor_fail_yields(self):
# This will be slow; avoid having it happen!
class TheParser(Parser):
class ARecord(Record):
prefix = Discriminator('A')
data = Field(1, int)
compare(generator(
C('fixed.ConversionError',
args=(),
problems=dict(data=C(
'fixed.Problem',
raw='X',
convert=int,
exception=C(
ValueError,
args=("invalid literal for int() with base 10: 'X'", ),
))))
), TheParser(['AX']))
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))
def test_handled_iterator(self):
class MyHandler(Handler):
@handles(self.parser.ARecord)
def handle_ARecord(self, source, line_no, rec):
return ('A', source, line_no, rec)
@handles(self.parser.BRecord)
def handle_BRecord(self, source, line_no, rec):
return ('B', source, line_no, rec)
handler = MyHandler()
# in reality, the following list would likely be a file
# or a Chunker.
source = ['AXX', 'BYY']
handler.handle(source)
compare(
generator(
('A', source, 1, self.parser.ARecord.type('A', 'XX')),
('B', source, 2, self.parser.BRecord.type('B', 'YY')),
), handler.handled(source))
def test_convertor_fail_yields(self):
# This will be slow; avoid having it happen!
class TheParser(Parser):
class ARecord(Record):
prefix = Discriminator('A')
data = Field(1, int)
compare(
generator(
C('fixed.ConversionError',
args=(),
problems=dict(data=C(
'fixed.Problem',
raw='X',
convert=int,
exception=C(
ValueError,
args=(
"invalid literal for int() with base 10: 'X'", ),
))))), TheParser(['AX']))
def test_handled_iterator(self):
class MyHandler(Handler):
@handles(self.parser.ARecord)
def handle_ARecord(self, source, line_no, rec):
return ('A', source, line_no, rec)
@handles(self.parser.BRecord)
def handle_BRecord(self, source, line_no, rec):
return ('B', source, line_no, rec)
handler = MyHandler()
# in reality, the following list would likely be a file
# or a Chunker.
source = ['AXX', 'BYY']
handler.handle(source)
compare(generator(
('A', source, 1, self.parser.ARecord.type('A', 'XX')),
('B', source, 2, self.parser.BRecord.type('B', 'YY')),
), handler.handled(source))
def test_generator_with_non_generator(self):
self.check_raises(
generator(1, 2, 3), None,
'<generator object generator at ...> != None',
)
def test_generator_and_iterable(self):
compare(generator(1, 2, 3), xrange(1, 4))
def test_generator_with_non_generator(self):
self.check_raises(
generator(1, 2, 3), None,
'<generator object generator at ...> != None',
)
def test_generator_and_iterable(self):
compare(generator(1, 2, 3), xrange(1, 4))
def test_iterable_and_generator(self):
compare(xrange(1, 4), generator(1, 2, 3))
def test_generator_and_sequence(self):
compare(generator(1, 2, 3), (1, 2, 3))
def test_nested_generator_tuple_right(self):
compare(
generator(1, 2, generator(3), 4),
generator(1, 2, (3, ), 4),
)
def test_sequence_and_generator(self):
compare((1, 2, 3), generator(1, 2, 3))
