home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 July / maximum-cd-2011-07.iso / DiscContents / LibO_3.3.2_Win_x86_install_multi.exe / libreoffice1.cab / seq_tests.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  13.3 KB  |  393 lines
  1. """
  2. Tests common to tuple, list and UserList.UserList
  3. """
  4.  
  5. import unittest
  6. import sys
  7.  
  8. # Various iterables
  9. # This is used for checking the constructor (here and in test_deque.py)
  10. def iterfunc(seqn):
  11.     'Regular generator'
  12.     for i in seqn:
  13.         yield i
  14.  
  15. class Sequence:
  16.     'Sequence using __getitem__'
  17.     def __init__(self, seqn):
  18.         self.seqn = seqn
  19.     def __getitem__(self, i):
  20.         return self.seqn[i]
  21.  
  22. class IterFunc:
  23.     'Sequence using iterator protocol'
  24.     def __init__(self, seqn):
  25.         self.seqn = seqn
  26.         self.i = 0
  27.     def __iter__(self):
  28.         return self
  29.     def next(self):
  30.         if self.i >= len(self.seqn): raise StopIteration
  31.         v = self.seqn[self.i]
  32.         self.i += 1
  33.         return v
  34.  
  35. class IterGen:
  36.     'Sequence using iterator protocol defined with a generator'
  37.     def __init__(self, seqn):
  38.         self.seqn = seqn
  39.         self.i = 0
  40.     def __iter__(self):
  41.         for val in self.seqn:
  42.             yield val
  43.  
  44. class IterNextOnly:
  45.     'Missing __getitem__ and __iter__'
  46.     def __init__(self, seqn):
  47.         self.seqn = seqn
  48.         self.i = 0
  49.     def next(self):
  50.         if self.i >= len(self.seqn): raise StopIteration
  51.         v = self.seqn[self.i]
  52.         self.i += 1
  53.         return v
  54.  
  55. class IterNoNext:
  56.     'Iterator missing next()'
  57.     def __init__(self, seqn):
  58.         self.seqn = seqn
  59.         self.i = 0
  60.     def __iter__(self):
  61.         return self
  62.  
  63. class IterGenExc:
  64.     'Test propagation of exceptions'
  65.     def __init__(self, seqn):
  66.         self.seqn = seqn
  67.         self.i = 0
  68.     def __iter__(self):
  69.         return self
  70.     def next(self):
  71.         3 // 0
  72.  
  73. class IterFuncStop:
  74.     'Test immediate stop'
  75.     def __init__(self, seqn):
  76.         pass
  77.     def __iter__(self):
  78.         return self
  79.     def next(self):
  80.         raise StopIteration
  81.  
  82. from itertools import chain, imap
  83. def itermulti(seqn):
  84.     'Test multiple tiers of iterators'
  85.     return chain(imap(lambda x:x, iterfunc(IterGen(Sequence(seqn)))))
  86.  
  87. class CommonTest(unittest.TestCase):
  88.     # The type to be tested
  89.     type2test = None
  90.  
  91.     def test_constructors(self):
  92.         l0 = []
  93.         l1 = [0]
  94.         l2 = [0, 1]
  95.  
  96.         u = self.type2test()
  97.         u0 = self.type2test(l0)
  98.         u1 = self.type2test(l1)
  99.         u2 = self.type2test(l2)
  100.  
  101.         uu = self.type2test(u)
  102.         uu0 = self.type2test(u0)
  103.         uu1 = self.type2test(u1)
  104.         uu2 = self.type2test(u2)
  105.  
  106.         v = self.type2test(tuple(u))
  107.         class OtherSeq:
  108.             def __init__(self, initseq):
  109.                 self.__data = initseq
  110.             def __len__(self):
  111.                 return len(self.__data)
  112.             def __getitem__(self, i):
  113.                 return self.__data[i]
  114.         s = OtherSeq(u0)
  115.         v0 = self.type2test(s)
  116.         self.assertEqual(len(v0), len(s))
  117.  
  118.         s = "this is also a sequence"
  119.         vv = self.type2test(s)
  120.         self.assertEqual(len(vv), len(s))
  121.  
  122.         # Create from various iteratables
  123.         for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
  124.             for g in (Sequence, IterFunc, IterGen,
  125.                       itermulti, iterfunc):
  126.                 self.assertEqual(self.type2test(g(s)), self.type2test(s))
  127.             self.assertEqual(self.type2test(IterFuncStop(s)), self.type2test())
  128.             self.assertEqual(self.type2test(c for c in "123"), self.type2test("123"))
  129.             self.assertRaises(TypeError, self.type2test, IterNextOnly(s))
  130.             self.assertRaises(TypeError, self.type2test, IterNoNext(s))
  131.             self.assertRaises(ZeroDivisionError, self.type2test, IterGenExc(s))
  132.  
  133.     def test_truth(self):
  134.         self.assert_(not self.type2test())
  135.         self.assert_(self.type2test([42]))
  136.  
  137.     def test_getitem(self):
  138.         u = self.type2test([0, 1, 2, 3, 4])
  139.         for i in xrange(len(u)):
  140.             self.assertEqual(u[i], i)
  141.             self.assertEqual(u[long(i)], i)
  142.         for i in xrange(-len(u), -1):
  143.             self.assertEqual(u[i], len(u)+i)
  144.             self.assertEqual(u[long(i)], len(u)+i)
  145.         self.assertRaises(IndexError, u.__getitem__, -len(u)-1)
  146.         self.assertRaises(IndexError, u.__getitem__, len(u))
  147.         self.assertRaises(ValueError, u.__getitem__, slice(0,10,0))
  148.  
  149.         u = self.type2test()
  150.         self.assertRaises(IndexError, u.__getitem__, 0)
  151.         self.assertRaises(IndexError, u.__getitem__, -1)
  152.  
  153.         self.assertRaises(TypeError, u.__getitem__)
  154.  
  155.         a = self.type2test([10, 11])
  156.         self.assertEqual(a[0], 10)
  157.         self.assertEqual(a[1], 11)
  158.         self.assertEqual(a[-2], 10)
  159.         self.assertEqual(a[-1], 11)
  160.         self.assertRaises(IndexError, a.__getitem__, -3)
  161.         self.assertRaises(IndexError, a.__getitem__, 3)
  162.  
  163.     def test_getslice(self):
  164.         l = [0, 1, 2, 3, 4]
  165.         u = self.type2test(l)
  166.  
  167.         self.assertEqual(u[0:0], self.type2test())
  168.         self.assertEqual(u[1:2], self.type2test([1]))
  169.         self.assertEqual(u[-2:-1], self.type2test([3]))
  170.         self.assertEqual(u[-1000:1000], u)
  171.         self.assertEqual(u[1000:-1000], self.type2test([]))
  172.         self.assertEqual(u[:], u)
  173.         self.assertEqual(u[1:None], self.type2test([1, 2, 3, 4]))
  174.         self.assertEqual(u[None:3], self.type2test([0, 1, 2]))
  175.  
  176.         # Extended slices
  177.         self.assertEqual(u[::], u)
  178.         self.assertEqual(u[::2], self.type2test([0, 2, 4]))
  179.         self.assertEqual(u[1::2], self.type2test([1, 3]))
  180.         self.assertEqual(u[::-1], self.type2test([4, 3, 2, 1, 0]))
  181.         self.assertEqual(u[::-2], self.type2test([4, 2, 0]))
  182.         self.assertEqual(u[3::-2], self.type2test([3, 1]))
  183.         self.assertEqual(u[3:3:-2], self.type2test([]))
  184.         self.assertEqual(u[3:2:-2], self.type2test([3]))
  185.         self.assertEqual(u[3:1:-2], self.type2test([3]))
  186.         self.assertEqual(u[3:0:-2], self.type2test([3, 1]))
  187.         self.assertEqual(u[::-100], self.type2test([4]))
  188.         self.assertEqual(u[100:-100:], self.type2test([]))
  189.         self.assertEqual(u[-100:100:], u)
  190.         self.assertEqual(u[100:-100:-1], u[::-1])
  191.         self.assertEqual(u[-100:100:-1], self.type2test([]))
  192.         self.assertEqual(u[-100L:100L:2L], self.type2test([0, 2, 4]))
  193.  
  194.         # Test extreme cases with long ints
  195.         a = self.type2test([0,1,2,3,4])
  196.         self.assertEqual(a[ -pow(2,128L): 3 ], self.type2test([0,1,2]))
  197.         self.assertEqual(a[ 3: pow(2,145L) ], self.type2test([3,4]))
  198.  
  199.         self.assertRaises(TypeError, u.__getslice__)
  200.  
  201.     def test_contains(self):
  202.         u = self.type2test([0, 1, 2])
  203.         for i in u:
  204.             self.assert_(i in u)
  205.         for i in min(u)-1, max(u)+1:
  206.             self.assert_(i not in u)
  207.  
  208.         self.assertRaises(TypeError, u.__contains__)
  209.  
  210.     def test_contains_fake(self):
  211.         class AllEq:
  212.             # Sequences must use rich comparison against each item
  213.             # (unless "is" is true, or an earlier item answered)
  214.             # So instances of AllEq must be found in all non-empty sequences.
  215.             def __eq__(self, other):
  216.                 return True
  217.             __hash__ = None # Can't meet hash invariant requirements
  218.         self.assert_(AllEq() not in self.type2test([]))
  219.         self.assert_(AllEq() in self.type2test([1]))
  220.  
  221.     def test_contains_order(self):
  222.         # Sequences must test in-order.  If a rich comparison has side
  223.         # effects, these will be visible to tests against later members.
  224.         # In this test, the "side effect" is a short-circuiting raise.
  225.         class DoNotTestEq(Exception):
  226.             pass
  227.         class StopCompares:
  228.             def __eq__(self, other):
  229.                 raise DoNotTestEq
  230.  
  231.         checkfirst = self.type2test([1, StopCompares()])
  232.         self.assert_(1 in checkfirst)
  233.         checklast = self.type2test([StopCompares(), 1])
  234.         self.assertRaises(DoNotTestEq, checklast.__contains__, 1)
  235.  
  236.     def test_len(self):
  237.         self.assertEqual(len(self.type2test()), 0)
  238.         self.assertEqual(len(self.type2test([])), 0)
  239.         self.assertEqual(len(self.type2test([0])), 1)
  240.         self.assertEqual(len(self.type2test([0, 1, 2])), 3)
  241.  
  242.     def test_minmax(self):
  243.         u = self.type2test([0, 1, 2])
  244.         self.assertEqual(min(u), 0)
  245.         self.assertEqual(max(u), 2)
  246.  
  247.     def test_addmul(self):
  248.         u1 = self.type2test([0])
  249.         u2 = self.type2test([0, 1])
  250.         self.assertEqual(u1, u1 + self.type2test())
  251.         self.assertEqual(u1, self.type2test() + u1)
  252.         self.assertEqual(u1 + self.type2test([1]), u2)
  253.         self.assertEqual(self.type2test([-1]) + u1, self.type2test([-1, 0]))
  254.         self.assertEqual(self.type2test(), u2*0)
  255.         self.assertEqual(self.type2test(), 0*u2)
  256.         self.assertEqual(self.type2test(), u2*0L)
  257.         self.assertEqual(self.type2test(), 0L*u2)
  258.         self.assertEqual(u2, u2*1)
  259.         self.assertEqual(u2, 1*u2)
  260.         self.assertEqual(u2, u2*1L)
  261.         self.assertEqual(u2, 1L*u2)
  262.         self.assertEqual(u2+u2, u2*2)
  263.         self.assertEqual(u2+u2, 2*u2)
  264.         self.assertEqual(u2+u2, u2*2L)
  265.         self.assertEqual(u2+u2, 2L*u2)
  266.         self.assertEqual(u2+u2+u2, u2*3)
  267.         self.assertEqual(u2+u2+u2, 3*u2)
  268.  
  269.         class subclass(self.type2test):
  270.             pass
  271.         u3 = subclass([0, 1])
  272.         self.assertEqual(u3, u3*1)
  273.         self.assert_(u3 is not u3*1)
  274.  
  275.     def test_iadd(self):
  276.         u = self.type2test([0, 1])
  277.         u += self.type2test()
  278.         self.assertEqual(u, self.type2test([0, 1]))
  279.         u += self.type2test([2, 3])
  280.         self.assertEqual(u, self.type2test([0, 1, 2, 3]))
  281.         u += self.type2test([4, 5])
  282.         self.assertEqual(u, self.type2test([0, 1, 2, 3, 4, 5]))
  283.  
  284.         u = self.type2test("spam")
  285.         u += self.type2test("eggs")
  286.         self.assertEqual(u, self.type2test("spameggs"))
  287.  
  288.     def test_imul(self):
  289.         u = self.type2test([0, 1])
  290.         u *= 3
  291.         self.assertEqual(u, self.type2test([0, 1, 0, 1, 0, 1]))
  292.  
  293.     def test_getitemoverwriteiter(self):
  294.         # Verify that __getitem__ overrides are not recognized by __iter__
  295.         class T(self.type2test):
  296.             def __getitem__(self, key):
  297.                 return str(key) + '!!!'
  298.         self.assertEqual(iter(T((1,2))).next(), 1)
  299.  
  300.     def test_repeat(self):
  301.         for m in xrange(4):
  302.             s = tuple(range(m))
  303.             for n in xrange(-3, 5):
  304.                 self.assertEqual(self.type2test(s*n), self.type2test(s)*n)
  305.             self.assertEqual(self.type2test(s)*(-4), self.type2test([]))
  306.             self.assertEqual(id(s), id(s*1))
  307.  
  308.     def test_bigrepeat(self):
  309.         import sys
  310.         if sys.maxint <= 2147483647:
  311.             x = self.type2test([0])
  312.             x *= 2**16
  313.             self.assertRaises(MemoryError, x.__mul__, 2**16)
  314.             if hasattr(x, '__imul__'):
  315.                 self.assertRaises(MemoryError, x.__imul__, 2**16)
  316.  
  317.     def test_subscript(self):
  318.         a = self.type2test([10, 11])
  319.         self.assertEqual(a.__getitem__(0L), 10)
  320.         self.assertEqual(a.__getitem__(1L), 11)
  321.         self.assertEqual(a.__getitem__(-2L), 10)
  322.         self.assertEqual(a.__getitem__(-1L), 11)
  323.         self.assertRaises(IndexError, a.__getitem__, -3)
  324.         self.assertRaises(IndexError, a.__getitem__, 3)
  325.         self.assertEqual(a.__getitem__(slice(0,1)), self.type2test([10]))
  326.         self.assertEqual(a.__getitem__(slice(1,2)), self.type2test([11]))
  327.         self.assertEqual(a.__getitem__(slice(0,2)), self.type2test([10, 11]))
  328.         self.assertEqual(a.__getitem__(slice(0,3)), self.type2test([10, 11]))
  329.         self.assertEqual(a.__getitem__(slice(3,5)), self.type2test([]))
  330.         self.assertRaises(ValueError, a.__getitem__, slice(0, 10, 0))
  331.         self.assertRaises(TypeError, a.__getitem__, 'x')
  332.  
  333.     def test_count(self):
  334.         a = self.type2test([0, 1, 2])*3
  335.         self.assertEqual(a.count(0), 3)
  336.         self.assertEqual(a.count(1), 3)
  337.         self.assertEqual(a.count(3), 0)
  338.  
  339.         self.assertRaises(TypeError, a.count)
  340.  
  341.         class BadExc(Exception):
  342.             pass
  343.  
  344.         class BadCmp:
  345.             def __eq__(self, other):
  346.                 if other == 2:
  347.                     raise BadExc()
  348.                 return False
  349.  
  350.         self.assertRaises(BadExc, a.count, BadCmp())
  351.  
  352.     def test_index(self):
  353.         u = self.type2test([0, 1])
  354.         self.assertEqual(u.index(0), 0)
  355.         self.assertEqual(u.index(1), 1)
  356.         self.assertRaises(ValueError, u.index, 2)
  357.  
  358.         u = self.type2test([-2, -1, 0, 0, 1, 2])
  359.         self.assertEqual(u.count(0), 2)
  360.         self.assertEqual(u.index(0), 2)
  361.         self.assertEqual(u.index(0, 2), 2)
  362.         self.assertEqual(u.index(-2, -10), 0)
  363.         self.assertEqual(u.index(0, 3), 3)
  364.         self.assertEqual(u.index(0, 3, 4), 3)
  365.         self.assertRaises(ValueError, u.index, 2, 0, -10)
  366.  
  367.         self.assertRaises(TypeError, u.index)
  368.  
  369.         class BadExc(Exception):
  370.             pass
  371.  
  372.         class BadCmp:
  373.             def __eq__(self, other):
  374.                 if other == 2:
  375.                     raise BadExc()
  376.                 return False
  377.  
  378.         a = self.type2test([0, 1, 2, 3])
  379.         self.assertRaises(BadExc, a.index, BadCmp())
  380.  
  381.         a = self.type2test([-2, -1, 0, 0, 1, 2])
  382.         self.assertEqual(a.index(0), 2)
  383.         self.assertEqual(a.index(0, 2), 2)
  384.         self.assertEqual(a.index(0, -4), 2)
  385.         self.assertEqual(a.index(-2, -10), 0)
  386.         self.assertEqual(a.index(0, 3), 3)
  387.         self.assertEqual(a.index(0, -3), 3)
  388.         self.assertEqual(a.index(0, 3, 4), 3)
  389.         self.assertEqual(a.index(0, -3, -2), 3)
  390.         self.assertEqual(a.index(0, -4*sys.maxint, 4*sys.maxint), 2)
  391.         self.assertRaises(ValueError, a.index, 0, 4*sys.maxint,-4*sys.maxint)
  392.         self.assertRaises(ValueError, a.index, 2, 0, -10)
  393.