Lib/test/test_enumerate.py

   1 import unittest
   2 from sets import Set
   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', 2) # too many arguments
 104
 105     def test_tuple_reuse(self):
 106         # Tests an implementation detail where tuple is reused
 107         # whenever nothing else holds a reference to it
 108         self.assertEqual(len(Set(map(id, list(enumerate(self.seq))))), len(self.seq))
 109         self.assertEqual(len(Set(map(id, enumerate(self.seq)))), min(1,len(self.seq)))
 110
 111 class MyEnum(enumerate):
 112     pass
 113
 114 class SubclassTestCase(EnumerateTestCase):
 115
 116     enum = MyEnum
 117
 118 class TestEmpty(EnumerateTestCase):
 119
 120     seq, res = '', []
 121
 122 class TestBig(EnumerateTestCase):
 123
 124     seq = range(10,20000,2)
 125     res = zip(range(20000), seq)
 126
 127
 128 def test_main(verbose=None):
 129     testclasses = (EnumerateTestCase, SubclassTestCase, TestEmpty, TestBig)
 130     test_support.run_unittest(*testclasses)
 131
 132     # verify reference counting
 133     import sys
 134     if verbose and hasattr(sys, "gettotalrefcount"):
 135         counts = [None] * 5
 136         for i in xrange(len(counts)):
 137             test_support.run_unittest(*testclasses)
 138             counts[i] = sys.gettotalrefcount()
 139         print counts
 140
 141 if __name__ == "__main__":
 142     test_main(verbose=True)