home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 14 / hacker14.iso / programacao / pythonwin / python.exe / TEST_ENUMERATE.PY < prev    next >
Encoding:
Python Source  |  2003-05-29  |  4.0 KB  |  143 lines
  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)
  143.