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