mirror of
https://github.com/python/cpython.git
synced 2024-11-29 21:05:33 +08:00
523 lines
16 KiB
Python
523 lines
16 KiB
Python
"""
|
|
Tests common to list and UserList.UserList
|
|
"""
|
|
|
|
import sys
|
|
import os
|
|
|
|
import unittest
|
|
from test import test_support, seq_tests
|
|
|
|
class CommonTest(seq_tests.CommonTest):
|
|
|
|
def test_init(self):
|
|
# Iterable arg is optional
|
|
self.assertEqual(self.type2test([]), self.type2test())
|
|
|
|
# Init clears previous values
|
|
a = self.type2test([1, 2, 3])
|
|
a.__init__()
|
|
self.assertEqual(a, self.type2test([]))
|
|
|
|
# Init overwrites previous values
|
|
a = self.type2test([1, 2, 3])
|
|
a.__init__([4, 5, 6])
|
|
self.assertEqual(a, self.type2test([4, 5, 6]))
|
|
|
|
# Mutables always return a new object
|
|
b = self.type2test(a)
|
|
self.assertNotEqual(id(a), id(b))
|
|
self.assertEqual(a, b)
|
|
|
|
def test_repr(self):
|
|
l0 = []
|
|
l2 = [0, 1, 2]
|
|
a0 = self.type2test(l0)
|
|
a2 = self.type2test(l2)
|
|
|
|
self.assertEqual(str(a0), str(l0))
|
|
self.assertEqual(repr(a0), repr(l0))
|
|
self.assertEqual(repr(a2), repr(l2))
|
|
self.assertEqual(str(a2), "[0, 1, 2]")
|
|
self.assertEqual(repr(a2), "[0, 1, 2]")
|
|
|
|
a2.append(a2)
|
|
a2.append(3)
|
|
self.assertEqual(str(a2), "[0, 1, 2, [...], 3]")
|
|
self.assertEqual(repr(a2), "[0, 1, 2, [...], 3]")
|
|
|
|
def test_print(self):
|
|
d = self.type2test(xrange(200))
|
|
d.append(d)
|
|
d.extend(xrange(200,400))
|
|
d.append(d)
|
|
d.append(400)
|
|
try:
|
|
fo = open(test_support.TESTFN, "wb")
|
|
fo.write(str(d))
|
|
fo.close()
|
|
fo = open(test_support.TESTFN, "rb")
|
|
self.assertEqual(fo.read(), repr(d))
|
|
finally:
|
|
fo.close()
|
|
os.remove(test_support.TESTFN)
|
|
|
|
def test_set_subscript(self):
|
|
a = self.type2test(range(20))
|
|
self.assertRaises(ValueError, a.__setitem__, slice(0, 10, 0), [1,2,3])
|
|
self.assertRaises(TypeError, a.__setitem__, slice(0, 10), 1)
|
|
self.assertRaises(ValueError, a.__setitem__, slice(0, 10, 2), [1,2])
|
|
self.assertRaises(TypeError, a.__getitem__, 'x', 1)
|
|
a[slice(2,10,3)] = [1,2,3]
|
|
self.assertEqual(a, self.type2test([0, 1, 1, 3, 4, 2, 6, 7, 3,
|
|
9, 10, 11, 12, 13, 14, 15,
|
|
16, 17, 18, 19]))
|
|
|
|
def test_reversed(self):
|
|
a = self.type2test(range(20))
|
|
r = reversed(a)
|
|
self.assertEqual(list(r), self.type2test(range(19, -1, -1)))
|
|
self.assertRaises(StopIteration, r.next)
|
|
self.assertEqual(list(reversed(self.type2test())),
|
|
self.type2test())
|
|
|
|
def test_setitem(self):
|
|
a = self.type2test([0, 1])
|
|
a[0] = 0
|
|
a[1] = 100
|
|
self.assertEqual(a, self.type2test([0, 100]))
|
|
a[-1] = 200
|
|
self.assertEqual(a, self.type2test([0, 200]))
|
|
a[-2] = 100
|
|
self.assertEqual(a, self.type2test([100, 200]))
|
|
self.assertRaises(IndexError, a.__setitem__, -3, 200)
|
|
self.assertRaises(IndexError, a.__setitem__, 2, 200)
|
|
|
|
a = self.type2test([])
|
|
self.assertRaises(IndexError, a.__setitem__, 0, 200)
|
|
self.assertRaises(IndexError, a.__setitem__, -1, 200)
|
|
self.assertRaises(TypeError, a.__setitem__)
|
|
|
|
a = self.type2test([0,1,2,3,4])
|
|
a[0] = 1
|
|
a[1] = 2
|
|
a[2] = 3
|
|
self.assertEqual(a, self.type2test([1,2,3,3,4]))
|
|
a[0] = 5
|
|
a[1] = 6
|
|
a[2] = 7
|
|
self.assertEqual(a, self.type2test([5,6,7,3,4]))
|
|
a[-2] = 88
|
|
a[-1] = 99
|
|
self.assertEqual(a, self.type2test([5,6,7,88,99]))
|
|
a[-2] = 8
|
|
a[-1] = 9
|
|
self.assertEqual(a, self.type2test([5,6,7,8,9]))
|
|
|
|
def test_delitem(self):
|
|
a = self.type2test([0, 1])
|
|
del a[1]
|
|
self.assertEqual(a, [0])
|
|
del a[0]
|
|
self.assertEqual(a, [])
|
|
|
|
a = self.type2test([0, 1])
|
|
del a[-2]
|
|
self.assertEqual(a, [1])
|
|
del a[-1]
|
|
self.assertEqual(a, [])
|
|
|
|
a = self.type2test([0, 1])
|
|
self.assertRaises(IndexError, a.__delitem__, -3)
|
|
self.assertRaises(IndexError, a.__delitem__, 2)
|
|
|
|
a = self.type2test([])
|
|
self.assertRaises(IndexError, a.__delitem__, 0)
|
|
|
|
self.assertRaises(TypeError, a.__delitem__)
|
|
|
|
def test_setslice(self):
|
|
l = [0, 1]
|
|
a = self.type2test(l)
|
|
|
|
for i in range(-3, 4):
|
|
a[:i] = l[:i]
|
|
self.assertEqual(a, l)
|
|
a2 = a[:]
|
|
a2[:i] = a[:i]
|
|
self.assertEqual(a2, a)
|
|
a[i:] = l[i:]
|
|
self.assertEqual(a, l)
|
|
a2 = a[:]
|
|
a2[i:] = a[i:]
|
|
self.assertEqual(a2, a)
|
|
for j in range(-3, 4):
|
|
a[i:j] = l[i:j]
|
|
self.assertEqual(a, l)
|
|
a2 = a[:]
|
|
a2[i:j] = a[i:j]
|
|
self.assertEqual(a2, a)
|
|
|
|
aa2 = a2[:]
|
|
aa2[:0] = [-2, -1]
|
|
self.assertEqual(aa2, [-2, -1, 0, 1])
|
|
aa2[0:] = []
|
|
self.assertEqual(aa2, [])
|
|
|
|
a = self.type2test([1, 2, 3, 4, 5])
|
|
a[:-1] = a
|
|
self.assertEqual(a, self.type2test([1, 2, 3, 4, 5, 5]))
|
|
a = self.type2test([1, 2, 3, 4, 5])
|
|
a[1:] = a
|
|
self.assertEqual(a, self.type2test([1, 1, 2, 3, 4, 5]))
|
|
a = self.type2test([1, 2, 3, 4, 5])
|
|
a[1:-1] = a
|
|
self.assertEqual(a, self.type2test([1, 1, 2, 3, 4, 5, 5]))
|
|
|
|
a = self.type2test([])
|
|
a[:] = tuple(range(10))
|
|
self.assertEqual(a, self.type2test(range(10)))
|
|
|
|
self.assertRaises(TypeError, a.__setslice__, 0, 1, 5)
|
|
|
|
self.assertRaises(TypeError, a.__setslice__)
|
|
|
|
def test_delslice(self):
|
|
a = self.type2test([0, 1])
|
|
del a[1:2]
|
|
del a[0:1]
|
|
self.assertEqual(a, self.type2test([]))
|
|
|
|
a = self.type2test([0, 1])
|
|
del a[1:2]
|
|
del a[0:1]
|
|
self.assertEqual(a, self.type2test([]))
|
|
|
|
a = self.type2test([0, 1])
|
|
del a[-2:-1]
|
|
self.assertEqual(a, self.type2test([1]))
|
|
|
|
a = self.type2test([0, 1])
|
|
del a[-2:-1]
|
|
self.assertEqual(a, self.type2test([1]))
|
|
|
|
a = self.type2test([0, 1])
|
|
del a[1:]
|
|
del a[:1]
|
|
self.assertEqual(a, self.type2test([]))
|
|
|
|
a = self.type2test([0, 1])
|
|
del a[1:]
|
|
del a[:1]
|
|
self.assertEqual(a, self.type2test([]))
|
|
|
|
a = self.type2test([0, 1])
|
|
del a[-1:]
|
|
self.assertEqual(a, self.type2test([0]))
|
|
|
|
a = self.type2test([0, 1])
|
|
del a[-1:]
|
|
self.assertEqual(a, self.type2test([0]))
|
|
|
|
a = self.type2test([0, 1])
|
|
del a[:]
|
|
self.assertEqual(a, self.type2test([]))
|
|
|
|
def test_append(self):
|
|
a = self.type2test([])
|
|
a.append(0)
|
|
a.append(1)
|
|
a.append(2)
|
|
self.assertEqual(a, self.type2test([0, 1, 2]))
|
|
|
|
self.assertRaises(TypeError, a.append)
|
|
|
|
def test_extend(self):
|
|
a1 = self.type2test([0])
|
|
a2 = self.type2test((0, 1))
|
|
a = a1[:]
|
|
a.extend(a2)
|
|
self.assertEqual(a, a1 + a2)
|
|
|
|
a.extend(self.type2test([]))
|
|
self.assertEqual(a, a1 + a2)
|
|
|
|
a.extend(a)
|
|
self.assertEqual(a, self.type2test([0, 0, 1, 0, 0, 1]))
|
|
|
|
a = self.type2test("spam")
|
|
a.extend("eggs")
|
|
self.assertEqual(a, list("spameggs"))
|
|
|
|
self.assertRaises(TypeError, a.extend, None)
|
|
|
|
self.assertRaises(TypeError, a.extend)
|
|
|
|
def test_insert(self):
|
|
a = self.type2test([0, 1, 2])
|
|
a.insert(0, -2)
|
|
a.insert(1, -1)
|
|
a.insert(2, 0)
|
|
self.assertEqual(a, [-2, -1, 0, 0, 1, 2])
|
|
|
|
b = a[:]
|
|
b.insert(-2, "foo")
|
|
b.insert(-200, "left")
|
|
b.insert(200, "right")
|
|
self.assertEqual(b, self.type2test(["left",-2,-1,0,0,"foo",1,2,"right"]))
|
|
|
|
self.assertRaises(TypeError, a.insert)
|
|
|
|
def test_pop(self):
|
|
a = self.type2test([-1, 0, 1])
|
|
a.pop()
|
|
self.assertEqual(a, [-1, 0])
|
|
a.pop(0)
|
|
self.assertEqual(a, [0])
|
|
self.assertRaises(IndexError, a.pop, 5)
|
|
a.pop(0)
|
|
self.assertEqual(a, [])
|
|
self.assertRaises(IndexError, a.pop)
|
|
self.assertRaises(TypeError, a.pop, 42, 42)
|
|
a = self.type2test([0, 10, 20, 30, 40])
|
|
|
|
def test_remove(self):
|
|
a = self.type2test([0, 0, 1])
|
|
a.remove(1)
|
|
self.assertEqual(a, [0, 0])
|
|
a.remove(0)
|
|
self.assertEqual(a, [0])
|
|
a.remove(0)
|
|
self.assertEqual(a, [])
|
|
|
|
self.assertRaises(ValueError, a.remove, 0)
|
|
|
|
self.assertRaises(TypeError, a.remove)
|
|
|
|
class BadExc(Exception):
|
|
pass
|
|
|
|
class BadCmp:
|
|
def __eq__(self, other):
|
|
if other == 2:
|
|
raise BadExc()
|
|
return False
|
|
|
|
a = self.type2test([0, 1, 2, 3])
|
|
self.assertRaises(BadExc, a.remove, BadCmp())
|
|
|
|
class BadCmp2:
|
|
def __eq__(self, other):
|
|
raise BadExc()
|
|
|
|
d = self.type2test('abcdefghcij')
|
|
d.remove('c')
|
|
self.assertEqual(d, self.type2test('abdefghcij'))
|
|
d.remove('c')
|
|
self.assertEqual(d, self.type2test('abdefghij'))
|
|
self.assertRaises(ValueError, d.remove, 'c')
|
|
self.assertEqual(d, self.type2test('abdefghij'))
|
|
|
|
# Handle comparison errors
|
|
d = self.type2test(['a', 'b', BadCmp2(), 'c'])
|
|
e = self.type2test(d)
|
|
self.assertRaises(BadExc, d.remove, 'c')
|
|
for x, y in zip(d, e):
|
|
# verify that original order and values are retained.
|
|
self.assert_(x is y)
|
|
|
|
def test_count(self):
|
|
a = self.type2test([0, 1, 2])*3
|
|
self.assertEqual(a.count(0), 3)
|
|
self.assertEqual(a.count(1), 3)
|
|
self.assertEqual(a.count(3), 0)
|
|
|
|
self.assertRaises(TypeError, a.count)
|
|
|
|
class BadExc(Exception):
|
|
pass
|
|
|
|
class BadCmp:
|
|
def __eq__(self, other):
|
|
if other == 2:
|
|
raise BadExc()
|
|
return False
|
|
|
|
self.assertRaises(BadExc, a.count, BadCmp())
|
|
|
|
def test_index(self):
|
|
u = self.type2test([0, 1])
|
|
self.assertEqual(u.index(0), 0)
|
|
self.assertEqual(u.index(1), 1)
|
|
self.assertRaises(ValueError, u.index, 2)
|
|
|
|
u = self.type2test([-2, -1, 0, 0, 1, 2])
|
|
self.assertEqual(u.count(0), 2)
|
|
self.assertEqual(u.index(0), 2)
|
|
self.assertEqual(u.index(0, 2), 2)
|
|
self.assertEqual(u.index(-2, -10), 0)
|
|
self.assertEqual(u.index(0, 3), 3)
|
|
self.assertEqual(u.index(0, 3, 4), 3)
|
|
self.assertRaises(ValueError, u.index, 2, 0, -10)
|
|
|
|
self.assertRaises(TypeError, u.index)
|
|
|
|
class BadExc(Exception):
|
|
pass
|
|
|
|
class BadCmp:
|
|
def __eq__(self, other):
|
|
if other == 2:
|
|
raise BadExc()
|
|
return False
|
|
|
|
a = self.type2test([0, 1, 2, 3])
|
|
self.assertRaises(BadExc, a.index, BadCmp())
|
|
|
|
a = self.type2test([-2, -1, 0, 0, 1, 2])
|
|
self.assertEqual(a.index(0), 2)
|
|
self.assertEqual(a.index(0, 2), 2)
|
|
self.assertEqual(a.index(0, -4), 2)
|
|
self.assertEqual(a.index(-2, -10), 0)
|
|
self.assertEqual(a.index(0, 3), 3)
|
|
self.assertEqual(a.index(0, -3), 3)
|
|
self.assertEqual(a.index(0, 3, 4), 3)
|
|
self.assertEqual(a.index(0, -3, -2), 3)
|
|
self.assertEqual(a.index(0, -4*sys.maxint, 4*sys.maxint), 2)
|
|
self.assertRaises(ValueError, a.index, 0, 4*sys.maxint,-4*sys.maxint)
|
|
self.assertRaises(ValueError, a.index, 2, 0, -10)
|
|
a.remove(0)
|
|
self.assertRaises(ValueError, a.index, 2, 0, 4)
|
|
self.assertEqual(a, self.type2test([-2, -1, 0, 1, 2]))
|
|
|
|
# Test modifying the list during index's iteration
|
|
class EvilCmp:
|
|
def __init__(self, victim):
|
|
self.victim = victim
|
|
def __eq__(self, other):
|
|
del self.victim[:]
|
|
return False
|
|
a = self.type2test()
|
|
a[:] = [EvilCmp(a) for _ in xrange(100)]
|
|
# This used to seg fault before patch #1005778
|
|
self.assertRaises(ValueError, a.index, None)
|
|
|
|
def test_reverse(self):
|
|
u = self.type2test([-2, -1, 0, 1, 2])
|
|
u2 = u[:]
|
|
u.reverse()
|
|
self.assertEqual(u, [2, 1, 0, -1, -2])
|
|
u.reverse()
|
|
self.assertEqual(u, u2)
|
|
|
|
self.assertRaises(TypeError, u.reverse, 42)
|
|
|
|
def test_sort(self):
|
|
u = self.type2test([1, 0])
|
|
u.sort()
|
|
self.assertEqual(u, [0, 1])
|
|
|
|
u = self.type2test([2,1,0,-1,-2])
|
|
u.sort()
|
|
self.assertEqual(u, self.type2test([-2,-1,0,1,2]))
|
|
|
|
self.assertRaises(TypeError, u.sort, 42, 42)
|
|
|
|
def revcmp(a, b):
|
|
return cmp(b, a)
|
|
u.sort(revcmp)
|
|
self.assertEqual(u, self.type2test([2,1,0,-1,-2]))
|
|
|
|
# The following dumps core in unpatched Python 1.5:
|
|
def myComparison(x,y):
|
|
return cmp(x%3, y%7)
|
|
z = self.type2test(range(12))
|
|
z.sort(myComparison)
|
|
|
|
self.assertRaises(TypeError, z.sort, 2)
|
|
|
|
def selfmodifyingComparison(x,y):
|
|
z.append(1)
|
|
return cmp(x, y)
|
|
self.assertRaises(ValueError, z.sort, selfmodifyingComparison)
|
|
|
|
self.assertRaises(TypeError, z.sort, lambda x, y: 's')
|
|
|
|
self.assertRaises(TypeError, z.sort, 42, 42, 42, 42)
|
|
|
|
def test_slice(self):
|
|
u = self.type2test("spam")
|
|
u[:2] = "h"
|
|
self.assertEqual(u, list("ham"))
|
|
|
|
def test_iadd(self):
|
|
super(CommonTest, self).test_iadd()
|
|
u = self.type2test([0, 1])
|
|
u2 = u
|
|
u += [2, 3]
|
|
self.assert_(u is u2)
|
|
|
|
u = self.type2test("spam")
|
|
u += "eggs"
|
|
self.assertEqual(u, self.type2test("spameggs"))
|
|
|
|
self.assertRaises(TypeError, u.__iadd__, None)
|
|
|
|
def test_imul(self):
|
|
u = self.type2test([0, 1])
|
|
u *= 3
|
|
self.assertEqual(u, self.type2test([0, 1, 0, 1, 0, 1]))
|
|
u *= 0
|
|
self.assertEqual(u, self.type2test([]))
|
|
s = self.type2test([])
|
|
oldid = id(s)
|
|
s *= 10
|
|
self.assertEqual(id(s), oldid)
|
|
|
|
def test_extendedslicing(self):
|
|
# subscript
|
|
a = self.type2test([0,1,2,3,4])
|
|
|
|
# deletion
|
|
del a[::2]
|
|
self.assertEqual(a, self.type2test([1,3]))
|
|
a = self.type2test(range(5))
|
|
del a[1::2]
|
|
self.assertEqual(a, self.type2test([0,2,4]))
|
|
a = self.type2test(range(5))
|
|
del a[1::-2]
|
|
self.assertEqual(a, self.type2test([0,2,3,4]))
|
|
a = self.type2test(range(10))
|
|
del a[::1000]
|
|
self.assertEqual(a, self.type2test([1, 2, 3, 4, 5, 6, 7, 8, 9]))
|
|
# assignment
|
|
a = self.type2test(range(10))
|
|
a[::2] = [-1]*5
|
|
self.assertEqual(a, self.type2test([-1, 1, -1, 3, -1, 5, -1, 7, -1, 9]))
|
|
a = self.type2test(range(10))
|
|
a[::-4] = [10]*3
|
|
self.assertEqual(a, self.type2test([0, 10, 2, 3, 4, 10, 6, 7, 8 ,10]))
|
|
a = self.type2test(range(4))
|
|
a[::-1] = a
|
|
self.assertEqual(a, self.type2test([3, 2, 1, 0]))
|
|
a = self.type2test(range(10))
|
|
b = a[:]
|
|
c = a[:]
|
|
a[2:3] = self.type2test(["two", "elements"])
|
|
b[slice(2,3)] = self.type2test(["two", "elements"])
|
|
c[2:3:] = self.type2test(["two", "elements"])
|
|
self.assertEqual(a, b)
|
|
self.assertEqual(a, c)
|
|
a = self.type2test(range(10))
|
|
a[::2] = tuple(range(5))
|
|
self.assertEqual(a, self.type2test([0, 1, 1, 3, 2, 5, 3, 7, 4, 9]))
|
|
|
|
def test_constructor_exception_handling(self):
|
|
# Bug #1242657
|
|
class F(object):
|
|
def __iter__(self):
|
|
yield 23
|
|
def __len__(self):
|
|
raise KeyboardInterrupt
|
|
self.assertRaises(KeyboardInterrupt, list, F())
|