mirror of
https://github.com/python/cpython.git
synced 2025-10-31 13:41:24 +00:00
1dde95dffa
test_tuple.py and test_list.py. Common tests for tuple, list and UserList are shared (in seq_tests.py and list_tests.py). Port tests to PyUnit. (From SF patch #736962)
171 lines
5.9 KiB
Python
171 lines
5.9 KiB
Python
"""
|
|
Tests common to tuple, list and UserList.UserList
|
|
"""
|
|
|
|
import unittest
|
|
from test import test_support
|
|
|
|
class CommonTest(unittest.TestCase):
|
|
# The type to be tested
|
|
type2test = None
|
|
|
|
def test_constructors(self):
|
|
l0 = []
|
|
l1 = [0]
|
|
l2 = [0, 1]
|
|
|
|
u = self.type2test()
|
|
u0 = self.type2test(l0)
|
|
u1 = self.type2test(l1)
|
|
u2 = self.type2test(l2)
|
|
|
|
uu = self.type2test(u)
|
|
uu0 = self.type2test(u0)
|
|
uu1 = self.type2test(u1)
|
|
uu2 = self.type2test(u2)
|
|
|
|
v = self.type2test(tuple(u))
|
|
class OtherSeq:
|
|
def __init__(self, initseq):
|
|
self.__data = initseq
|
|
def __len__(self):
|
|
return len(self.__data)
|
|
def __getitem__(self, i):
|
|
return self.__data[i]
|
|
s = OtherSeq(u0)
|
|
v0 = self.type2test(s)
|
|
self.assertEqual(len(v0), len(s))
|
|
|
|
s = "this is also a sequence"
|
|
vv = self.type2test(s)
|
|
self.assertEqual(len(vv), len(s))
|
|
|
|
def test_truth(self):
|
|
self.assert_(not self.type2test())
|
|
self.assert_(self.type2test([42]))
|
|
|
|
def test_getitem(self):
|
|
u = self.type2test([0, 1, 2, 3, 4])
|
|
for i in xrange(len(u)):
|
|
self.assertEqual(u[i], i)
|
|
for i in xrange(-len(u), -1):
|
|
self.assertEqual(u[i], len(u)+i)
|
|
self.assertRaises(IndexError, u.__getitem__, -len(u)-1)
|
|
self.assertRaises(IndexError, u.__getitem__, len(u))
|
|
|
|
u = self.type2test()
|
|
self.assertRaises(IndexError, u.__getitem__, 0)
|
|
self.assertRaises(IndexError, u.__getitem__, -1)
|
|
|
|
self.assertRaises(TypeError, u.__getitem__)
|
|
|
|
def test_getslice(self):
|
|
l = [0, 1, 2, 3, 4]
|
|
u = self.type2test(l)
|
|
|
|
self.assertEqual(u[0:0], self.type2test())
|
|
self.assertEqual(u[1:2], self.type2test([1]))
|
|
self.assertEqual(u[-2:-1], self.type2test([3]))
|
|
self.assertEqual(u[-1000:1000], u)
|
|
self.assertEqual(u[1000:-1000], self.type2test([]))
|
|
self.assertEqual(u[:], u)
|
|
self.assertEqual(u[1:None], self.type2test([1, 2, 3, 4]))
|
|
self.assertEqual(u[None:3], self.type2test([0, 1, 2]))
|
|
|
|
# Extended slices
|
|
self.assertEqual(u[::], u)
|
|
self.assertEqual(u[::2], self.type2test([0, 2, 4]))
|
|
self.assertEqual(u[1::2], self.type2test([1, 3]))
|
|
self.assertEqual(u[::-1], self.type2test([4, 3, 2, 1, 0]))
|
|
self.assertEqual(u[::-2], self.type2test([4, 2, 0]))
|
|
self.assertEqual(u[3::-2], self.type2test([3, 1]))
|
|
self.assertEqual(u[3:3:-2], self.type2test([]))
|
|
self.assertEqual(u[3:2:-2], self.type2test([3]))
|
|
self.assertEqual(u[3:1:-2], self.type2test([3]))
|
|
self.assertEqual(u[3:0:-2], self.type2test([3, 1]))
|
|
self.assertEqual(u[::-100], self.type2test([4]))
|
|
self.assertEqual(u[100:-100:], self.type2test([]))
|
|
self.assertEqual(u[-100:100:], u)
|
|
self.assertEqual(u[100:-100:-1], u[::-1])
|
|
self.assertEqual(u[-100:100:-1], self.type2test([]))
|
|
self.assertEqual(u[-100L:100L:2L], self.type2test([0, 2, 4]))
|
|
|
|
# Test extreme cases with long ints
|
|
a = self.type2test([0,1,2,3,4])
|
|
self.assertEqual(a[ -pow(2,128L): 3 ], self.type2test([0,1,2]))
|
|
self.assertEqual(a[ 3: pow(2,145L) ], self.type2test([3,4]))
|
|
|
|
self.assertRaises(TypeError, u.__getslice__)
|
|
|
|
def test_contains(self):
|
|
u = self.type2test([0, 1, 2])
|
|
for i in u:
|
|
self.assert_(i in u)
|
|
for i in min(u)-1, max(u)+1:
|
|
self.assert_(i not in u)
|
|
|
|
self.assertRaises(TypeError, u.__contains__)
|
|
|
|
def test_len(self):
|
|
self.assertEqual(len(self.type2test()), 0)
|
|
self.assertEqual(len(self.type2test([])), 0)
|
|
self.assertEqual(len(self.type2test([0])), 1)
|
|
self.assertEqual(len(self.type2test([0, 1, 2])), 3)
|
|
|
|
def test_minmax(self):
|
|
u = self.type2test([0, 1, 2])
|
|
self.assertEqual(min(u), 0)
|
|
self.assertEqual(max(u), 2)
|
|
|
|
def test_addmul(self):
|
|
u1 = self.type2test([0])
|
|
u2 = self.type2test([0, 1])
|
|
self.assertEqual(u1, u1 + self.type2test())
|
|
self.assertEqual(u1, self.type2test() + u1)
|
|
self.assertEqual(u1 + self.type2test([1]), u2)
|
|
self.assertEqual(self.type2test([-1]) + u1, self.type2test([-1, 0]))
|
|
self.assertEqual(self.type2test(), u2*0)
|
|
self.assertEqual(self.type2test(), 0*u2)
|
|
self.assertEqual(self.type2test(), u2*0L)
|
|
self.assertEqual(self.type2test(), 0L*u2)
|
|
self.assertEqual(u2, u2*1)
|
|
self.assertEqual(u2, 1*u2)
|
|
self.assertEqual(u2, u2*1L)
|
|
self.assertEqual(u2, 1L*u2)
|
|
self.assertEqual(u2+u2, u2*2)
|
|
self.assertEqual(u2+u2, 2*u2)
|
|
self.assertEqual(u2+u2, u2*2L)
|
|
self.assertEqual(u2+u2, 2L*u2)
|
|
self.assertEqual(u2+u2+u2, u2*3)
|
|
self.assertEqual(u2+u2+u2, 3*u2)
|
|
|
|
class subclass(self.type2test):
|
|
pass
|
|
u3 = subclass([0, 1])
|
|
self.assertEqual(u3, u3*1)
|
|
self.assert_(u3 is not u3*1)
|
|
|
|
def test_iadd(self):
|
|
u = self.type2test([0, 1])
|
|
u += self.type2test()
|
|
self.assertEqual(u, self.type2test([0, 1]))
|
|
u += self.type2test([2, 3])
|
|
self.assertEqual(u, self.type2test([0, 1, 2, 3]))
|
|
u += self.type2test([4, 5])
|
|
self.assertEqual(u, self.type2test([0, 1, 2, 3, 4, 5]))
|
|
|
|
u = self.type2test("spam")
|
|
u += self.type2test("eggs")
|
|
self.assertEqual(u, self.type2test("spameggs"))
|
|
|
|
def test_imul(self):
|
|
u = self.type2test([0, 1])
|
|
u *= 3
|
|
self.assertEqual(u, self.type2test([0, 1, 0, 1, 0, 1]))
|
|
|
|
def test_getitemoverwriteiter(self):
|
|
# Verify that __getitem__ overrides are not recognized by __iter__
|
|
class T(self.type2test):
|
|
def __getitem__(self, key):
|
|
return str(key) + '!!!'
|
|
self.assertEqual(iter(T((1,2))).next(), 1)
|