from test
import test_support
'Sequence using __getitem__'
def __init__(self
, seqn
):
def __getitem__(self
, i
):
'Sequence using iterator protocol'
def __init__(self
, seqn
):
if self
.i
>= len(self
.seqn
): raise StopIteration
'Sequence using iterator protocol defined with a generator'
def __init__(self
, seqn
):
'Missing __getitem__ and __iter__'
def __init__(self
, seqn
):
if self
.i
>= len(self
.seqn
): raise StopIteration
'Test propagation of exceptions'
def __init__(self
, seqn
):
'Iterator missing next()'
def __init__(self
, seqn
):
class EnumerateTestCase(unittest
.TestCase
):
seq
, res
= 'abc', [(0,'a'), (1,'b'), (2,'c')]
def test_basicfunction(self
):
self
.assertEqual(type(self
.enum(self
.seq
)), self
.enum
)
self
.assertEqual(iter(e
), e
)
self
.assertEqual(list(self
.enum(self
.seq
)), self
.res
)
def test_getitemseqn(self
):
self
.assertEqual(list(self
.enum(G(self
.seq
))), self
.res
)
self
.assertRaises(StopIteration, e
.next
)
def test_iteratorseqn(self
):
self
.assertEqual(list(self
.enum(I(self
.seq
))), self
.res
)
self
.assertRaises(StopIteration, e
.next
)
def test_iteratorgenerator(self
):
self
.assertEqual(list(self
.enum(Ig(self
.seq
))), self
.res
)
self
.assertRaises(StopIteration, e
.next
)
def test_noniterable(self
):
self
.assertRaises(TypeError, self
.enum
, X(self
.seq
))
def test_illformediterable(self
):
self
.assertRaises(TypeError, list, self
.enum(N(self
.seq
)))
def test_exception_propagation(self
):
self
.assertRaises(ZeroDivisionError, list, self
.enum(E(self
.seq
)))
def test_argumentcheck(self
):
self
.assertRaises(TypeError, self
.enum
) # no arguments
self
.assertRaises(TypeError, self
.enum
, 1) # wrong type (not iterable)
self
.assertRaises(TypeError, self
.enum
, 'abc', 2) # too many arguments
def test_tuple_reuse(self
):
# Tests an implementation detail where tuple is reused
# whenever nothing else holds a reference to it
self
.assertEqual(len(set(map(id, list(enumerate(self
.seq
))))), len(self
.seq
))
self
.assertEqual(len(set(map(id, enumerate(self
.seq
)))), min(1,len(self
.seq
)))
class SubclassTestCase(EnumerateTestCase
):
class TestEmpty(EnumerateTestCase
):
class TestBig(EnumerateTestCase
):
res
= zip(range(20000), seq
)
class TestReversed(unittest
.TestCase
):
def __getitem__(self
, i
):
for data
in 'abc', range(5), tuple(enumerate('abc')), A(), xrange(1,17,5):
self
.assertEqual(list(data
)[::-1], list(reversed(data
)))
self
.assertRaises(TypeError, reversed, {})
def test_xrange_optimization(self
):
self
.assertEqual(type(reversed(x
)), type(iter(x
)))
# This is an implementation detail, not an interface requirement
for s
in ('hello', tuple('hello'), list('hello'), xrange(5)):
self
.assertEqual(len(reversed(s
)), len(s
))
self
.assertEqual(len(r
), 0)
def __getitem__(self
, index
):
r
= reversed(SeqWithWeirdLen())
self
.assertRaises(ZeroDivisionError, len, r
)
def __getitem__(self
, index
):
self
.assertRaises(TypeError, reversed)
self
.assertRaises(TypeError, reversed, [], 'extra')
def test_main(verbose
=None):
testclasses
= (EnumerateTestCase
, SubclassTestCase
, TestEmpty
, TestBig
,
test_support
.run_unittest(*testclasses
)
# verify reference counting
if verbose
and hasattr(sys
, "gettotalrefcount"):
for i
in xrange(len(counts
)):
test_support
.run_unittest(*testclasses
)
counts
[i
] = sys
.gettotalrefcount()
if __name__
== "__main__":