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