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