Debian Codegraph @

Lib/test/list_tests.py

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