Lib/test/list_tests.py

   1 """
   2 Tests common to list and UserList.UserList
   3 """
   4
   5 import sys
   6 import os
   7
   8 from test import test_support, seq_tests
   9
  10 class CommonTest(seq_tests.CommonTest):
  11
  12     def test_init(self):
  13         # Iterable arg is optional
  14         self.assertEqual(self.type2test([]), self.type2test())
  15
  16         # Init clears previous values
  17         a = self.type2test([1, 2, 3])
  18         a.__init__()
  19         self.assertEqual(a, self.type2test([]))
  20
  21         # Init overwrites previous values
  22         a = self.type2test([1, 2, 3])
  23         a.__init__([4, 5, 6])
  24         self.assertEqual(a, self.type2test([4, 5, 6]))
  25
  26         # Mutables always return a new object
  27         b = self.type2test(a)
  28         self.assertNotEqual(id(a), id(b))
  29         self.assertEqual(a, b)
  30
  31     def test_repr(self):
  32         l0 = []
  33         l2 = [0, 1, 2]
  34         a0 = self.type2test(l0)
  35         a2 = self.type2test(l2)
  36
  37         self.assertEqual(str(a0), str(l0))
  38         self.assertEqual(repr(a0), repr(l0))
  39         self.assertEqual(`a2`, `l2`)
  40         self.assertEqual(str(a2), "[0, 1, 2]")
  41         self.assertEqual(repr(a2), "[0, 1, 2]")
  42
  43         a2.append(a2)
  44         a2.append(3)
  45         self.assertEqual(str(a2), "[0, 1, 2, [...], 3]")
  46         self.assertEqual(repr(a2), "[0, 1, 2, [...], 3]")
  47
  48         l0 = []
  49         for i in xrange(sys.getrecursionlimit() + 100):
  50             l0 = [l0]
  51         self.assertRaises(RuntimeError, repr, l0)
  52
  53     def test_print(self):
  54         d = self.type2test(xrange(200))
  55         d.append(d)
  56         d.extend(xrange(200,400))
  57         d.append(d)
  58         d.append(400)
  59         try:
  60             fo = open(test_support.TESTFN, "wb")
  61             print >> fo, d,
  62             fo.close()
  63             fo = open(test_support.TESTFN, "rb")
  64             self.assertEqual(fo.read(), repr(d))
  65         finally:
  66             fo.close()
  67             os.remove(test_support.TESTFN)
  68
  69     def test_set_subscript(self):
  70         a = self.type2test(range(20))
  71         self.assertRaises(ValueError, a.__setitem__, slice(0, 10, 0), [1,2,3])
  72         self.assertRaises(TypeError, a.__setitem__, slice(0, 10), 1)
  73         self.assertRaises(ValueError, a.__setitem__, slice(0, 10, 2), [1,2])
  74         self.assertRaises(TypeError, a.__getitem__, 'x', 1)
  75         a[slice(2,10,3)] = [1,2,3]
  76         self.assertEqual(a, self.type2test([0, 1, 1, 3, 4, 2, 6, 7, 3,
  77                                             9, 10, 11, 12, 13, 14, 15,
  78                                             16, 17, 18, 19]))
  79
  80     def test_reversed(self):
  81         a = self.type2test(range(20))
  82         r = reversed(a)
  83         self.assertEqual(list(r), self.type2test(range(19, -1, -1)))
  84         self.assertRaises(StopIteration, r.next)
  85         self.assertEqual(list(reversed(self.type2test())),
  86                          self.type2test())
  87         # Bug 3689: make sure list-reversed-iterator doesn't have __len__
  88         self.assertRaises(TypeError, len, reversed([1,2,3]))
  89
  90     def test_setitem(self):
  91         a = self.type2test([0, 1])
  92         a[0] = 0
  93         a[1] = 100
  94         self.assertEqual(a, self.type2test([0, 100]))
  95         a[-1] = 200
  96         self.assertEqual(a, self.type2test([0, 200]))
  97         a[-2] = 100
  98         self.assertEqual(a, self.type2test([100, 200]))
  99         self.assertRaises(IndexError, a.__setitem__, -3, 200)
 100         self.assertRaises(IndexError, a.__setitem__, 2, 200)
 101
 102         a = self.type2test([])
 103         self.assertRaises(IndexError, a.__setitem__, 0, 200)
 104         self.assertRaises(IndexError, a.__setitem__, -1, 200)
 105         self.assertRaises(TypeError, a.__setitem__)
 106
 107         a = self.type2test([0,1,2,3,4])
 108         a[0L] = 1
 109         a[1L] = 2
 110         a[2L] = 3
 111         self.assertEqual(a, self.type2test([1,2,3,3,4]))
 112         a[0] = 5
 113         a[1] = 6
 114         a[2] = 7
 115         self.assertEqual(a, self.type2test([5,6,7,3,4]))
 116         a[-2L] = 88
 117         a[-1L] = 99
 118         self.assertEqual(a, self.type2test([5,6,7,88,99]))
 119         a[-2] = 8
 120         a[-1] = 9
 121         self.assertEqual(a, self.type2test([5,6,7,8,9]))
 122
 123     def test_delitem(self):
 124         a = self.type2test([0, 1])
 125         del a[1]
 126         self.assertEqual(a, [0])
 127         del a[0]
 128         self.assertEqual(a, [])
 129
 130         a = self.type2test([0, 1])
 131         del a[-2]
 132         self.assertEqual(a, [1])
 133         del a[-1]
 134         self.assertEqual(a, [])
 135
 136         a = self.type2test([0, 1])
 137         self.assertRaises(IndexError, a.__delitem__, -3)
 138         self.assertRaises(IndexError, a.__delitem__, 2)
 139
 140         a = self.type2test([])
 141         self.assertRaises(IndexError, a.__delitem__, 0)
 142
 143         self.assertRaises(TypeError, a.__delitem__)
 144
 145     def test_setslice(self):
 146         l = [0, 1]
 147         a = self.type2test(l)
 148
 149         for i in range(-3, 4):
 150             a[:i] = l[:i]
 151             self.assertEqual(a, l)
 152             a2 = a[:]
 153             a2[:i] = a[:i]
 154             self.assertEqual(a2, a)
 155             a[i:] = l[i:]
 156             self.assertEqual(a, l)
 157             a2 = a[:]
 158             a2[i:] = a[i:]
 159             self.assertEqual(a2, a)
 160             for j in range(-3, 4):
 161                 a[i:j] = l[i:j]
 162                 self.assertEqual(a, l)
 163                 a2 = a[:]
 164                 a2[i:j] = a[i:j]
 165                 self.assertEqual(a2, a)
 166
 167         aa2 = a2[:]
 168         aa2[:0] = [-2, -1]
 169         self.assertEqual(aa2, [-2, -1, 0, 1])
 170         aa2[0:] = []
 171         self.assertEqual(aa2, [])
 172
 173         a = self.type2test([1, 2, 3, 4, 5])
 174         a[:-1] = a
 175         self.assertEqual(a, self.type2test([1, 2, 3, 4, 5, 5]))
 176         a = self.type2test([1, 2, 3, 4, 5])
 177         a[1:] = a
 178         self.assertEqual(a, self.type2test([1, 1, 2, 3, 4, 5]))
 179         a = self.type2test([1, 2, 3, 4, 5])
 180         a[1:-1] = a
 181         self.assertEqual(a, self.type2test([1, 1, 2, 3, 4, 5, 5]))
 182
 183         a = self.type2test([])
 184         a[:] = tuple(range(10))
 185         self.assertEqual(a, self.type2test(range(10)))
 186
 187         self.assertRaises(TypeError, a.__setslice__, 0, 1, 5)
 188         self.assertRaises(TypeError, a.__setitem__, slice(0, 1, 5))
 189
 190         self.assertRaises(TypeError, a.__setslice__)
 191         self.assertRaises(TypeError, a.__setitem__)
 192
 193     def test_delslice(self):
 194         a = self.type2test([0, 1])
 195         del a[1:2]
 196         del a[0:1]
 197         self.assertEqual(a, self.type2test([]))
 198
 199         a = self.type2test([0, 1])
 200         del a[1L:2L]
 201         del a[0L:1L]
 202         self.assertEqual(a, self.type2test([]))
 203
 204         a = self.type2test([0, 1])
 205         del a[-2:-1]
 206         self.assertEqual(a, self.type2test([1]))
 207
 208         a = self.type2test([0, 1])
 209         del a[-2L:-1L]
 210         self.assertEqual(a, self.type2test([1]))
 211
 212         a = self.type2test([0, 1])
 213         del a[1:]
 214         del a[:1]
 215         self.assertEqual(a, self.type2test([]))
 216
 217         a = self.type2test([0, 1])
 218         del a[1L:]
 219         del a[:1L]
 220         self.assertEqual(a, self.type2test([]))
 221
 222         a = self.type2test([0, 1])
 223         del a[-1:]
 224         self.assertEqual(a, self.type2test([0]))
 225
 226         a = self.type2test([0, 1])
 227         del a[-1L:]
 228         self.assertEqual(a, self.type2test([0]))
 229
 230         a = self.type2test([0, 1])
 231         del a[:]
 232         self.assertEqual(a, self.type2test([]))
 233
 234     def test_append(self):
 235         a = self.type2test([])
 236         a.append(0)
 237         a.append(1)
 238         a.append(2)
 239         self.assertEqual(a, self.type2test([0, 1, 2]))
 240
 241         self.assertRaises(TypeError, a.append)
 242
 243     def test_extend(self):
 244         a1 = self.type2test([0])
 245         a2 = self.type2test((0, 1))
 246         a = a1[:]
 247         a.extend(a2)
 248         self.assertEqual(a, a1 + a2)
 249
 250         a.extend(self.type2test([]))
 251         self.assertEqual(a, a1 + a2)
 252
 253         a.extend(a)
 254         self.assertEqual(a, self.type2test([0, 0, 1, 0, 0, 1]))
 255
 256         a = self.type2test("spam")
 257         a.extend("eggs")
 258         self.assertEqual(a, list("spameggs"))
 259
 260         self.assertRaises(TypeError, a.extend, None)
 261
 262         self.assertRaises(TypeError, a.extend)
 263
 264     def test_insert(self):
 265         a = self.type2test([0, 1, 2])
 266         a.insert(0, -2)
 267         a.insert(1, -1)
 268         a.insert(2, 0)
 269         self.assertEqual(a, [-2, -1, 0, 0, 1, 2])
 270
 271         b = a[:]
 272         b.insert(-2, "foo")
 273         b.insert(-200, "left")
 274         b.insert(200, "right")
 275         self.assertEqual(b, self.type2test(["left",-2,-1,0,0,"foo",1,2,"right"]))
 276
 277         self.assertRaises(TypeError, a.insert)
 278
 279     def test_pop(self):
 280         a = self.type2test([-1, 0, 1])
 281         a.pop()
 282         self.assertEqual(a, [-1, 0])
 283         a.pop(0)
 284         self.assertEqual(a, [0])
 285         self.assertRaises(IndexError, a.pop, 5)
 286         a.pop(0)
 287         self.assertEqual(a, [])
 288         self.assertRaises(IndexError, a.pop)
 289         self.assertRaises(TypeError, a.pop, 42, 42)
 290         a = self.type2test([0, 10, 20, 30, 40])
 291
 292     def test_remove(self):
 293         a = self.type2test([0, 0, 1])
 294         a.remove(1)
 295         self.assertEqual(a, [0, 0])
 296         a.remove(0)
 297         self.assertEqual(a, [0])
 298         a.remove(0)
 299         self.assertEqual(a, [])
 300
 301         self.assertRaises(ValueError, a.remove, 0)
 302
 303         self.assertRaises(TypeError, a.remove)
 304
 305         class BadExc(Exception):
 306             pass
 307
 308         class BadCmp:
 309             def __eq__(self, other):
 310                 if other == 2:
 311                     raise BadExc()
 312                 return False
 313
 314         a = self.type2test([0, 1, 2, 3])
 315         self.assertRaises(BadExc, a.remove, BadCmp())
 316
 317         class BadCmp2:
 318             def __eq__(self, other):
 319                 raise BadExc()
 320
 321         d = self.type2test('abcdefghcij')
 322         d.remove('c')
 323         self.assertEqual(d, self.type2test('abdefghcij'))
 324         d.remove('c')
 325         self.assertEqual(d, self.type2test('abdefghij'))
 326         self.assertRaises(ValueError, d.remove, 'c')
 327         self.assertEqual(d, self.type2test('abdefghij'))
 328
 329         # Handle comparison errors
 330         d = self.type2test(['a', 'b', BadCmp2(), 'c'])
 331         e = self.type2test(d)
 332         self.assertRaises(BadExc, d.remove, 'c')
 333         for x, y in zip(d, e):
 334             # verify that original order and values are retained.
 335             self.assert_(x is y)
 336
 337     def test_count(self):
 338         a = self.type2test([0, 1, 2])*3
 339         self.assertEqual(a.count(0), 3)
 340         self.assertEqual(a.count(1), 3)
 341         self.assertEqual(a.count(3), 0)
 342
 343         self.assertRaises(TypeError, a.count)
 344
 345         class BadExc(Exception):
 346             pass
 347
 348         class BadCmp:
 349             def __eq__(self, other):
 350                 if other == 2:
 351                     raise BadExc()
 352                 return False
 353
 354         self.assertRaises(BadExc, a.count, BadCmp())
 355
 356     def test_index(self):
 357         u = self.type2test([0, 1])
 358         self.assertEqual(u.index(0), 0)
 359         self.assertEqual(u.index(1), 1)
 360         self.assertRaises(ValueError, u.index, 2)
 361
 362         u = self.type2test([-2, -1, 0, 0, 1, 2])
 363         self.assertEqual(u.count(0), 2)
 364         self.assertEqual(u.index(0), 2)
 365         self.assertEqual(u.index(0, 2), 2)
 366         self.assertEqual(u.index(-2, -10), 0)
 367         self.assertEqual(u.index(0, 3), 3)
 368         self.assertEqual(u.index(0, 3, 4), 3)
 369         self.assertRaises(ValueError, u.index, 2, 0, -10)
 370
 371         self.assertRaises(TypeError, u.index)
 372
 373         class BadExc(Exception):
 374             pass
 375
 376         class BadCmp:
 377             def __eq__(self, other):
 378                 if other == 2:
 379                     raise BadExc()
 380                 return False
 381
 382         a = self.type2test([0, 1, 2, 3])
 383         self.assertRaises(BadExc, a.index, BadCmp())
 384
 385         a = self.type2test([-2, -1, 0, 0, 1, 2])
 386         self.assertEqual(a.index(0), 2)
 387         self.assertEqual(a.index(0, 2), 2)
 388         self.assertEqual(a.index(0, -4), 2)
 389         self.assertEqual(a.index(-2, -10), 0)
 390         self.assertEqual(a.index(0, 3), 3)
 391         self.assertEqual(a.index(0, -3), 3)
 392         self.assertEqual(a.index(0, 3, 4), 3)
 393         self.assertEqual(a.index(0, -3, -2), 3)
 394         self.assertEqual(a.index(0, -4*sys.maxint, 4*sys.maxint), 2)
 395         self.assertRaises(ValueError, a.index, 0, 4*sys.maxint,-4*sys.maxint)
 396         self.assertRaises(ValueError, a.index, 2, 0, -10)
 397         a.remove(0)
 398         self.assertRaises(ValueError, a.index, 2, 0, 4)
 399         self.assertEqual(a, self.type2test([-2, -1, 0, 1, 2]))
 400
 401         # Test modifying the list during index's iteration
 402         class EvilCmp:
 403             def __init__(self, victim):
 404                 self.victim = victim
 405             def __eq__(self, other):
 406                 del self.victim[:]
 407                 return False
 408         a = self.type2test()
 409         a[:] = [EvilCmp(a) for _ in xrange(100)]
 410         # This used to seg fault before patch #1005778
 411         self.assertRaises(ValueError, a.index, None)
 412
 413     def test_reverse(self):
 414         u = self.type2test([-2, -1, 0, 1, 2])
 415         u2 = u[:]
 416         u.reverse()
 417         self.assertEqual(u, [2, 1, 0, -1, -2])
 418         u.reverse()
 419         self.assertEqual(u, u2)
 420
 421         self.assertRaises(TypeError, u.reverse, 42)
 422
 423     def test_sort(self):
 424         u = self.type2test([1, 0])
 425         u.sort()
 426         self.assertEqual(u, [0, 1])
 427
 428         u = self.type2test([2,1,0,-1,-2])
 429         u.sort()
 430         self.assertEqual(u, self.type2test([-2,-1,0,1,2]))
 431
 432         self.assertRaises(TypeError, u.sort, 42, 42)
 433
 434         def revcmp(a, b):
 435             return cmp(b, a)
 436         u.sort(revcmp)
 437         self.assertEqual(u, self.type2test([2,1,0,-1,-2]))
 438
 439         # The following dumps core in unpatched Python 1.5:
 440         def myComparison(x,y):
 441             return cmp(x%3, y%7)
 442         z = self.type2test(range(12))
 443         z.sort(myComparison)
 444
 445         self.assertRaises(TypeError, z.sort, 2)
 446
 447         def selfmodifyingComparison(x,y):
 448             z.append(1)
 449             return cmp(x, y)
 450         self.assertRaises(ValueError, z.sort, selfmodifyingComparison)
 451
 452         self.assertRaises(TypeError, z.sort, lambda x, y: 's')
 453
 454         self.assertRaises(TypeError, z.sort, 42, 42, 42, 42)
 455
 456     def test_slice(self):
 457         u = self.type2test("spam")
 458         u[:2] = "h"
 459         self.assertEqual(u, list("ham"))
 460
 461     def test_iadd(self):
 462         super(CommonTest, self).test_iadd()
 463         u = self.type2test([0, 1])
 464         u2 = u
 465         u += [2, 3]
 466         self.assert_(u is u2)
 467
 468         u = self.type2test("spam")
 469         u += "eggs"
 470         self.assertEqual(u, self.type2test("spameggs"))
 471
 472         self.assertRaises(TypeError, u.__iadd__, None)
 473
 474     def test_imul(self):
 475         u = self.type2test([0, 1])
 476         u *= 3
 477         self.assertEqual(u, self.type2test([0, 1, 0, 1, 0, 1]))
 478         u *= 0
 479         self.assertEqual(u, self.type2test([]))
 480         s = self.type2test([])
 481         oldid = id(s)
 482         s *= 10
 483         self.assertEqual(id(s), oldid)
 484
 485     def test_extendedslicing(self):
 486         #  subscript
 487         a = self.type2test([0,1,2,3,4])
 488
 489         #  deletion
 490         del a[::2]
 491         self.assertEqual(a, self.type2test([1,3]))
 492         a = self.type2test(range(5))
 493         del a[1::2]
 494         self.assertEqual(a, self.type2test([0,2,4]))
 495         a = self.type2test(range(5))
 496         del a[1::-2]
 497         self.assertEqual(a, self.type2test([0,2,3,4]))
 498         a = self.type2test(range(10))
 499         del a[::1000]
 500         self.assertEqual(a, self.type2test([1, 2, 3, 4, 5, 6, 7, 8, 9]))
 501         #  assignment
 502         a = self.type2test(range(10))
 503         a[::2] = [-1]*5
 504         self.assertEqual(a, self.type2test([-1, 1, -1, 3, -1, 5, -1, 7, -1, 9]))
 505         a = self.type2test(range(10))
 506         a[::-4] = [10]*3
 507         self.assertEqual(a, self.type2test([0, 10, 2, 3, 4, 10, 6, 7, 8 ,10]))
 508         a = self.type2test(range(4))
 509         a[::-1] = a
 510         self.assertEqual(a, self.type2test([3, 2, 1, 0]))
 511         a = self.type2test(range(10))
 512         b = a[:]
 513         c = a[:]
 514         a[2:3] = self.type2test(["two", "elements"])
 515         b[slice(2,3)] = self.type2test(["two", "elements"])
 516         c[2:3:] = self.type2test(["two", "elements"])
 517         self.assertEqual(a, b)
 518         self.assertEqual(a, c)
 519         a = self.type2test(range(10))
 520         a[::2] = tuple(range(5))
 521         self.assertEqual(a, self.type2test([0, 1, 1, 3, 2, 5, 3, 7, 4, 9]))
 522
 523     def test_constructor_exception_handling(self):
 524         # Bug #1242657
 525         class F(object):
 526             def __iter__(self):
 527                 raise KeyboardInterrupt
 528         self.assertRaises(KeyboardInterrupt, list, F())