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