""" | |
Tests common to list and UserList.UserList | |
""" | |
import sys | |
import os | |
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]") | |
l0 = [] | |
for i in xrange(sys.getrecursionlimit() + 100): | |
l0 = [l0] | |
self.assertRaises(RuntimeError, repr, l0) | |
def test_print(self): | |
d = self.type2test(xrange(200)) | |
d.append(d) | |
d.extend(xrange(200,400)) | |
d.append(d) | |
d.append(400) | |
try: | |
with open(test_support.TESTFN, "wb") as fo: | |
print >> fo, d, | |
with open(test_support.TESTFN, "rb") as fo: | |
self.assertEqual(fo.read(), repr(d)) | |
finally: | |
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()) | |
# Bug 3689: make sure list-reversed-iterator doesn't have __len__ | |
self.assertRaises(TypeError, len, reversed([1,2,3])) | |
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[0L] = 1 | |
a[1L] = 2 | |
a[2L] = 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[-2L] = 88 | |
a[-1L] = 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.__setitem__, slice(0, 1, 5)) | |
self.assertRaises(TypeError, a.__setslice__) | |
self.assertRaises(TypeError, a.__setitem__) | |
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[1L:2L] | |
del a[0L:1L] | |
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[-2L:-1L] | |
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[1L:] | |
del a[:1L] | |
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[-1L:] | |
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.assertIs(x, 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): | |
with test_support.check_py3k_warnings( | |
("the cmp argument is not supported", DeprecationWarning)): | |
self._test_sort() | |
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.assertIs(u, 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])) | |
# test issue7788 | |
a = self.type2test(range(10)) | |
del a[9::1<<333] | |
def test_constructor_exception_handling(self): | |
# Bug #1242657 | |
class F(object): | |
def __iter__(self): | |
raise KeyboardInterrupt | |
self.assertRaises(KeyboardInterrupt, list, F()) |