Lib/test/test_enumerate.py

   1 import unittest
   2 import sys
   3
   4 from test import test_support
   5
   6 class G:
   7     'Sequence using __getitem__'
   8     def __init__(self, seqn):
   9         self.seqn = seqn
  10     def __getitem__(self, i):
  11         return self.seqn[i]
  12
  13 class I:
  14     'Sequence using iterator protocol'
  15     def __init__(self, seqn):
  16         self.seqn = seqn
  17         self.i = 0
  18     def __iter__(self):
  19         return self
  20     def next(self):
  21         if self.i >= len(self.seqn): raise StopIteration
  22         v = self.seqn[self.i]
  23         self.i += 1
  24         return v
  25
  26 class Ig:
  27     'Sequence using iterator protocol defined with a generator'
  28     def __init__(self, seqn):
  29         self.seqn = seqn
  30         self.i = 0
  31     def __iter__(self):
  32         for val in self.seqn:
  33             yield val
  34
  35 class X:
  36     'Missing __getitem__ and __iter__'
  37     def __init__(self, seqn):
  38         self.seqn = seqn
  39         self.i = 0
  40     def next(self):
  41         if self.i >= len(self.seqn): raise StopIteration
  42         v = self.seqn[self.i]
  43         self.i += 1
  44         return v
  45
  46 class E:
  47     'Test propagation of exceptions'
  48     def __init__(self, seqn):
  49         self.seqn = seqn
  50         self.i = 0
  51     def __iter__(self):
  52         return self
  53     def next(self):
  54         3 // 0
  55
  56 class N:
  57     'Iterator missing next()'
  58     def __init__(self, seqn):
  59         self.seqn = seqn
  60         self.i = 0
  61     def __iter__(self):
  62         return self
  63
  64 class EnumerateTestCase(unittest.TestCase):
  65
  66     enum = enumerate
  67     seq, res = 'abc', [(0,'a'), (1,'b'), (2,'c')]
  68
  69     def test_basicfunction(self):
  70         self.assertEqual(type(self.enum(self.seq)), self.enum)
  71         e = self.enum(self.seq)
  72         self.assertEqual(iter(e), e)
  73         self.assertEqual(list(self.enum(self.seq)), self.res)
  74         self.enum.__doc__
  75
  76     def test_getitemseqn(self):
  77         self.assertEqual(list(self.enum(G(self.seq))), self.res)
  78         e = self.enum(G(''))
  79         self.assertRaises(StopIteration, e.next)
  80
  81     def test_iteratorseqn(self):
  82         self.assertEqual(list(self.enum(I(self.seq))), self.res)
  83         e = self.enum(I(''))
  84         self.assertRaises(StopIteration, e.next)
  85
  86     def test_iteratorgenerator(self):
  87         self.assertEqual(list(self.enum(Ig(self.seq))), self.res)
  88         e = self.enum(Ig(''))
  89         self.assertRaises(StopIteration, e.next)
  90
  91     def test_noniterable(self):
  92         self.assertRaises(TypeError, self.enum, X(self.seq))
  93
  94     def test_illformediterable(self):
  95         self.assertRaises(TypeError, list, self.enum(N(self.seq)))
  96
  97     def test_exception_propagation(self):
  98         self.assertRaises(ZeroDivisionError, list, self.enum(E(self.seq)))
  99
 100     def test_argumentcheck(self):
 101         self.assertRaises(TypeError, self.enum) # no arguments
 102         self.assertRaises(TypeError, self.enum, 1) # wrong type (not iterable)
 103         self.assertRaises(TypeError, self.enum, 'abc', 'a') # wrong type
 104         self.assertRaises(TypeError, self.enum, 'abc', 2, 3) # too many arguments
 105
 106     def test_tuple_reuse(self):
 107         # Tests an implementation detail where tuple is reused
 108         # whenever nothing else holds a reference to it
 109         self.assertEqual(len(set(map(id, list(enumerate(self.seq))))), len(self.seq))
 110         self.assertEqual(len(set(map(id, enumerate(self.seq)))), min(1,len(self.seq)))
 111
 112 class MyEnum(enumerate):
 113     pass
 114
 115 class SubclassTestCase(EnumerateTestCase):
 116
 117     enum = MyEnum
 118
 119 class TestEmpty(EnumerateTestCase):
 120
 121     seq, res = '', []
 122
 123 class TestBig(EnumerateTestCase):
 124
 125     seq = range(10,20000,2)
 126     res = zip(range(20000), seq)
 127
 128 class TestReversed(unittest.TestCase):
 129
 130     def test_simple(self):
 131         class A:
 132             def __getitem__(self, i):
 133                 if i < 5:
 134                     return str(i)
 135                 raise StopIteration
 136             def __len__(self):
 137                 return 5
 138         for data in 'abc', range(5), tuple(enumerate('abc')), A(), xrange(1,17,5):
 139             self.assertEqual(list(data)[::-1], list(reversed(data)))
 140         self.assertRaises(TypeError, reversed, {})
 141         # don't allow keyword arguments
 142         self.assertRaises(TypeError, reversed, [], a=1)
 143
 144     def test_class_class(self):
 145         class A:
 146             def __reversed__(self):
 147                 return [2, 1]
 148         self.assertEqual(list(reversed(A())), [2, 1])
 149
 150     def test_xrange_optimization(self):
 151         x = xrange(1)
 152         self.assertEqual(type(reversed(x)), type(iter(x)))
 153
 154     def test_len(self):
 155         # This is an implementation detail, not an interface requirement
 156         from test.test_iterlen import len
 157         for s in ('hello', tuple('hello'), list('hello'), xrange(5)):
 158             self.assertEqual(len(reversed(s)), len(s))
 159             r = reversed(s)
 160             list(r)
 161             self.assertEqual(len(r), 0)
 162         class SeqWithWeirdLen:
 163             called = False
 164             def __len__(self):
 165                 if not self.called:
 166                     self.called = True
 167                     return 10
 168                 raise ZeroDivisionError
 169             def __getitem__(self, index):
 170                 return index
 171         r = reversed(SeqWithWeirdLen())
 172         self.assertRaises(ZeroDivisionError, len, r)
 173
 174
 175     def test_gc(self):
 176         class Seq:
 177             def __len__(self):
 178                 return 10
 179             def __getitem__(self, index):
 180                 return index
 181         s = Seq()
 182         r = reversed(s)
 183         s.r = r
 184
 185     def test_args(self):
 186         self.assertRaises(TypeError, reversed)
 187         self.assertRaises(TypeError, reversed, [], 'extra')
 188
 189     def test_bug1229429(self):
 190         # this bug was never in reversed, it was in
 191         # PyObject_CallMethod, and reversed_new calls that sometimes.
 192         if not hasattr(sys, "getrefcount"):
 193             return
 194         def f():
 195             pass
 196         r = f.__reversed__ = object()
 197         rc = sys.getrefcount(r)
 198         for i in range(10):
 199             try:
 200                 reversed(f)
 201             except TypeError:
 202                 pass
 203             else:
 204                 self.fail("non-callable __reversed__ didn't raise!")
 205         self.assertEqual(rc, sys.getrefcount(r))
 206
 207
 208 class TestStart(EnumerateTestCase):
 209
 210     enum = lambda i: enumerate(i, start=11)
 211     seq, res = 'abc', [(1, 'a'), (2, 'b'), (3, 'c')]
 212
 213
 214 class TestLongStart(EnumerateTestCase):
 215
 216     enum = lambda i: enumerate(i, start=sys.maxint+1)
 217     seq, res = 'abc', [(sys.maxint+1,'a'), (sys.maxint+2,'b'),
 218                        (sys.maxint+3,'c')]
 219
 220
 221 def test_main(verbose=None):
 222     testclasses = (EnumerateTestCase, SubclassTestCase, TestEmpty, TestBig,
 223                    TestReversed)
 224     test_support.run_unittest(*testclasses)
 225
 226     # verify reference counting
 227     import sys
 228     if verbose and hasattr(sys, "gettotalrefcount"):
 229         counts = [None] * 5
 230         for i in xrange(len(counts)):
 231             test_support.run_unittest(*testclasses)
 232             counts[i] = sys.gettotalrefcount()
 233         print counts
 234
 235 if __name__ == "__main__":
 236     test_main(verbose=True)