"""

Tests common to list and UserList.UserList

"""

import sys

import os

from test import test_support, seq_tests

class CommonTest(seq_tests.CommonTest):

    def test_init(self):

        # Iterable arg is optional

        self.assertEqual(self.type2test([]), self.type2test())

        # Init clears previous values

        a = self.type2test([1, 2, 3])

        a.__init__()

        self.assertEqual(a, self.type2test([]))

        # Init overwrites previous values

        a = self.type2test([1, 2, 3])

        a.__init__([4, 5, 6])

        self.assertEqual(a, self.type2test([4, 5, 6]))

        # Mutables always return a new object

        b = self.type2test(a)

        self.assertNotEqual(id(a), id(b))

        self.assertEqual(a, b)

    def test_repr(self):

        l0 = []

        l2 = [0, 1, 2]

        a0 = self.type2test(l0)

        a2 = self.type2test(l2)

        self.assertEqual(str(a0), str(l0))

        self.assertEqual(repr(a0), repr(l0))

        self.assertEqual(`a2`, `l2`)

        self.assertEqual(str(a2), "[0, 1, 2]")

        self.assertEqual(repr(a2), "[0, 1, 2]")

        a2.append(a2)

        a2.append(3)

        self.assertEqual(str(a2), "[0, 1, 2, [...], 3]")

        self.assertEqual(repr(a2), "[0, 1, 2, [...], 3]")

        l0 = []

        for i in xrange(sys.getrecursionlimit() + 100):

            l0 = [l0]

        self.assertRaises(RuntimeError, repr, l0)

    def test_print(self):

        d = self.type2test(xrange(200))

        d.append(d)

        d.extend(xrange(200,400))

        d.append(d)

        d.append(400)

        try:

            fo = open(test_support.TESTFN, "wb")

            print >> fo, d,

            fo.close()

            fo = open(test_support.TESTFN, "rb")

            self.assertEqual(fo.read(), repr(d))

        finally:

            fo.close()

            os.remove(test_support.TESTFN)

    def test_set_subscript(self):

        a = self.type2test(range(20))

        self.assertRaises(ValueError, a.__setitem__, slice(0, 10, 0), [1,2,3])

        self.assertRaises(TypeError, a.__setitem__, slice(0, 10), 1)

        self.assertRaises(ValueError, a.__setitem__, slice(0, 10, 2), [1,2])

        self.assertRaises(TypeError, a.__getitem__, 'x', 1)

        a[slice(2,10,3)] = [1,2,3]

        self.assertEqual(a, self.type2test([0, 1, 1, 3, 4, 2, 6, 7, 3,

                                            9, 10, 11, 12, 13, 14, 15,

                                            16, 17, 18, 19]))

    def test_reversed(self):

        a = self.type2test(range(20))

        r = reversed(a)

        self.assertEqual(list(r), self.type2test(range(19, -1, -1)))

        self.assertRaises(StopIteration, r.next)

        self.assertEqual(list(reversed(self.type2test())),

                         self.type2test())

    def test_setitem(self):

        a = self.type2test([0, 1])

        a[0] = 0

        a[1] = 100

        self.assertEqual(a, self.type2test([0, 100]))

        a[-1] = 200

        self.assertEqual(a, self.type2test([0, 200]))

        a[-2] = 100

        self.assertEqual(a, self.type2test([100, 200]))

        self.assertRaises(IndexError, a.__setitem__, -3, 200)

        self.assertRaises(IndexError, a.__setitem__, 2, 200)

        a = self.type2test([])

        self.assertRaises(IndexError, a.__setitem__, 0, 200)

        self.assertRaises(IndexError, a.__setitem__, -1, 200)

        self.assertRaises(TypeError, a.__setitem__)

        a = self.type2test([0,1,2,3,4])

        a[0L] = 1

        a[1L] = 2

        a[2L] = 3

        self.assertEqual(a, self.type2test([1,2,3,3,4]))

        a[0] = 5

        a[1] = 6

        a[2] = 7

        self.assertEqual(a, self.type2test([5,6,7,3,4]))

        a[-2L] = 88

        a[-1L] = 99

        self.assertEqual(a, self.type2test([5,6,7,88,99]))

        a[-2] = 8

        a[-1] = 9

        self.assertEqual(a, self.type2test([5,6,7,8,9]))

    def test_delitem(self):

        a = self.type2test([0, 1])

        del a[1]

        self.assertEqual(a, [0])

        del a[0]

        self.assertEqual(a, [])

        a = self.type2test([0, 1])

        del a[-2]

        self.assertEqual(a, [1])

        del a[-1]

        self.assertEqual(a, [])

        a = self.type2test([0, 1])

        self.assertRaises(IndexError, a.__delitem__, -3)

        self.assertRaises(IndexError, a.__delitem__, 2)

        a = self.type2test([])

        self.assertRaises(IndexError, a.__delitem__, 0)

        self.assertRaises(TypeError, a.__delitem__)

    def test_setslice(self):

        l = [0, 1]

        a = self.type2test(l)

        for i in range(-3, 4):

            a[:i] = l[:i]

            self.assertEqual(a, l)

            a2 = a[:]

            a2[:i] = a[:i]

            self.assertEqual(a2, a)

            a[i:] = l[i:]

            self.assertEqual(a, l)

            a2 = a[:]

            a2[i:] = a[i:]

            self.assertEqual(a2, a)

            for j in range(-3, 4):

                a[i:j] = l[i:j]

                self.assertEqual(a, l)

                a2 = a[:]

                a2[i:j] = a[i:j]

                self.assertEqual(a2, a)

        aa2 = a2[:]

        aa2[:0] = [-2, -1]

        self.assertEqual(aa2, [-2, -1, 0, 1])

        aa2[0:] = []

        self.assertEqual(aa2, [])

        a = self.type2test([1, 2, 3, 4, 5])

        a[:-1] = a

        self.assertEqual(a, self.type2test([1, 2, 3, 4, 5, 5]))

        a = self.type2test([1, 2, 3, 4, 5])

        a[1:] = a

        self.assertEqual(a, self.type2test([1, 1, 2, 3, 4, 5]))

        a = self.type2test([1, 2, 3, 4, 5])

        a[1:-1] = a

        self.assertEqual(a, self.type2test([1, 1, 2, 3, 4, 5, 5]))

        a = self.type2test([])

        a[:] = tuple(range(10))

        self.assertEqual(a, self.type2test(range(10)))

        self.assertRaises(TypeError, a.__setslice__, 0, 1, 5)

        self.assertRaises(TypeError, a.__setitem__, slice(0, 1, 5))

        self.assertRaises(TypeError, a.__setslice__)

        self.assertRaises(TypeError, a.__setitem__)

    def test_delslice(self):

        a = self.type2test([0, 1])

        del a[1:2]

        del a[0:1]

        self.assertEqual(a, self.type2test([]))

        a = self.type2test([0, 1])

        del a[1L:2L]

        del a[0L:1L]

        self.assertEqual(a, self.type2test([]))

        a = self.type2test([0, 1])

        del a[-2:-1]

        self.assertEqual(a, self.type2test([1]))

        a = self.type2test([0, 1])

        del a[-2L:-1L]

        self.assertEqual(a, self.type2test([1]))

        a = self.type2test([0, 1])

        del a[1:]

        del a[:1]

        self.assertEqual(a, self.type2test([]))

        a = self.type2test([0, 1])

        del a[1L:]

        del a[:1L]

        self.assertEqual(a, self.type2test([]))

        a = self.type2test([0, 1])

        del a[-1:]

        self.assertEqual(a, self.type2test([0]))

        a = self.type2test([0, 1])

        del a[-1L:]

        self.assertEqual(a, self.type2test([0]))

        a = self.type2test([0, 1])

        del a[:]

        self.assertEqual(a, self.type2test([]))

    def test_append(self):

        a = self.type2test([])

        a.append(0)

        a.append(1)

        a.append(2)

        self.assertEqual(a, self.type2test([0, 1, 2]))

        self.assertRaises(TypeError, a.append)

    def test_extend(self):

        a1 = self.type2test([0])

        a2 = self.type2test((0, 1))

        a = a1[:]

        a.extend(a2)

        self.assertEqual(a, a1 + a2)

        a.extend(self.type2test([]))

        self.assertEqual(a, a1 + a2)

        a.extend(a)

        self.assertEqual(a, self.type2test([0, 0, 1, 0, 0, 1]))

        a = self.type2test("spam")

        a.extend("eggs")

        self.assertEqual(a, list("spameggs"))

        self.assertRaises(TypeError, a.extend, None)

        self.assertRaises(TypeError, a.extend)

    def test_insert(self):

        a = self.type2test([0, 1, 2])

        a.insert(0, -2)

        a.insert(1, -1)

        a.insert(2, 0)

        self.assertEqual(a, [-2, -1, 0, 0, 1, 2])

        b = a[:]

        b.insert(-2, "foo")

        b.insert(-200, "left")

        b.insert(200, "right")

        self.assertEqual(b, self.type2test(["left",-2,-1,0,0,"foo",1,2,"right"]))

        self.assertRaises(TypeError, a.insert)

    def test_pop(self):

        a = self.type2test([-1, 0, 1])

        a.pop()

        self.assertEqual(a, [-1, 0])

        a.pop(0)

        self.assertEqual(a, [0])

        self.assertRaises(IndexError, a.pop, 5)

        a.pop(0)

        self.assertEqual(a, [])

        self.assertRaises(IndexError, a.pop)

        self.assertRaises(TypeError, a.pop, 42, 42)

        a = self.type2test([0, 10, 20, 30, 40])

    def test_remove(self):

        a = self.type2test([0, 0, 1])

        a.remove(1)

        self.assertEqual(a, [0, 0])

        a.remove(0)

        self.assertEqual(a, [0])

        a.remove(0)

        self.assertEqual(a, [])

        self.assertRaises(ValueError, a.remove, 0)

        self.assertRaises(TypeError, a.remove)

        class BadExc(Exception):

            pass

        class BadCmp:

            def __eq__(self, other):

                if other == 2:

                    raise BadExc()

                return False

        a = self.type2test([0, 1, 2, 3])

        self.assertRaises(BadExc, a.remove, BadCmp())

        class BadCmp2:

            def __eq__(self, other):

                raise BadExc()

        d = self.type2test('abcdefghcij')

        d.remove('c')

        self.assertEqual(d, self.type2test('abdefghcij'))

        d.remove('c')

        self.assertEqual(d, self.type2test('abdefghij'))

        self.assertRaises(ValueError, d.remove, 'c')

        self.assertEqual(d, self.type2test('abdefghij'))

        # Handle comparison errors

        d = self.type2test(['a', 'b', BadCmp2(), 'c'])

        e = self.type2test(d)

        self.assertRaises(BadExc, d.remove, 'c')

        for x, y in zip(d, e):

            # verify that original order and values are retained.

            self.assert_(x is y)

    def test_count(self):

        a = self.type2test([0, 1, 2])*3

        self.assertEqual(a.count(0), 3)

        self.assertEqual(a.count(1), 3)

        self.assertEqual(a.count(3), 0)

        self.assertRaises(TypeError, a.count)

        class BadExc(Exception):

            pass

        class BadCmp:

            def __eq__(self, other):

                if other == 2:

                    raise BadExc()

                return False

        self.assertRaises(BadExc, a.count, BadCmp())

    def test_index(self):

        u = self.type2test([0, 1])

        self.assertEqual(u.index(0), 0)

        self.assertEqual(u.index(1), 1)

        self.assertRaises(ValueError, u.index, 2)

        u = self.type2test([-2, -1, 0, 0, 1, 2])

        self.assertEqual(u.count(0), 2)

        self.assertEqual(u.index(0), 2)

        self.assertEqual(u.index(0, 2), 2)

        self.assertEqual(u.index(-2, -10), 0)

        self.assertEqual(u.index(0, 3), 3)

        self.assertEqual(u.index(0, 3, 4), 3)

        self.assertRaises(ValueError, u.index, 2, 0, -10)

        self.assertRaises(TypeError, u.index)

        class BadExc(Exception):

            pass

        class BadCmp:

            def __eq__(self, other):

                if other == 2:

                    raise BadExc()

                return False

        a = self.type2test([0, 1, 2, 3])

        self.assertRaises(BadExc, a.index, BadCmp())

        a = self.type2test([-2, -1, 0, 0, 1, 2])

        self.assertEqual(a.index(0), 2)

        self.assertEqual(a.index(0, 2), 2)

        self.assertEqual(a.index(0, -4), 2)

        self.assertEqual(a.index(-2, -10), 0)

        self.assertEqual(a.index(0, 3), 3)

        self.assertEqual(a.index(0, -3), 3)

        self.assertEqual(a.index(0, 3, 4), 3)

        self.assertEqual(a.index(0, -3, -2), 3)

        self.assertEqual(a.index(0, -4*sys.maxint, 4*sys.maxint), 2)

        self.assertRaises(ValueError, a.index, 0, 4*sys.maxint,-4*sys.maxint)

        self.assertRaises(ValueError, a.index, 2, 0, -10)

        a.remove(0)

        self.assertRaises(ValueError, a.index, 2, 0, 4)

        self.assertEqual(a, self.type2test([-2, -1, 0, 1, 2]))

        # Test modifying the list during index's iteration

        class EvilCmp:

            def __init__(self, victim):

                self.victim = victim

            def __eq__(self, other):

                del self.victim[:]

                return False

        a = self.type2test()

        a[:] = [EvilCmp(a) for _ in xrange(100)]

        # This used to seg fault before patch #1005778

        self.assertRaises(ValueError, a.index, None)

    def test_reverse(self):

        u = self.type2test([-2, -1, 0, 1, 2])

        u2 = u[:]

        u.reverse()

        self.assertEqual(u, [2, 1, 0, -1, -2])

        u.reverse()

        self.assertEqual(u, u2)

        self.assertRaises(TypeError, u.reverse, 42)

    def test_sort(self):

        u = self.type2test([1, 0])

        u.sort()

        self.assertEqual(u, [0, 1])

        u = self.type2test([2,1,0,-1,-2])

        u.sort()

        self.assertEqual(u, self.type2test([-2,-1,0,1,2]))

        self.assertRaises(TypeError, u.sort, 42, 42)

        def revcmp(a, b):

            return cmp(b, a)

        u.sort(revcmp)

        self.assertEqual(u, self.type2test([2,1,0,-1,-2]))

        # The following dumps core in unpatched Python 1.5:

        def myComparison(x,y):

            return cmp(x%3, y%7)

        z = self.type2test(range(12))

        z.sort(myComparison)

        self.assertRaises(TypeError, z.sort, 2)

        def selfmodifyingComparison(x,y):

            z.append(1)

            return cmp(x, y)

        self.assertRaises(ValueError, z.sort, selfmodifyingComparison)

        self.assertRaises(TypeError, z.sort, lambda x, y: 's')

        self.assertRaises(TypeError, z.sort, 42, 42, 42, 42)

    def test_slice(self):

        u = self.type2test("spam")

        u[:2] = "h"

        self.assertEqual(u, list("ham"))

    def test_iadd(self):

        super(CommonTest, self).test_iadd()

        u = self.type2test([0, 1])

        u2 = u

        u += [2, 3]

        self.assert_(u is u2)

        u = self.type2test("spam")

        u += "eggs"

        self.assertEqual(u, self.type2test("spameggs"))

        self.assertRaises(TypeError, u.__iadd__, None)

    def test_imul(self):

        u = self.type2test([0, 1])

        u *= 3

        self.assertEqual(u, self.type2test([0, 1, 0, 1, 0, 1]))

        u *= 0

        self.assertEqual(u, self.type2test([]))

        s = self.type2test([])

        oldid = id(s)

        s *= 10

        self.assertEqual(id(s), oldid)

    def test_extendedslicing(self):

        #  subscript

        a = self.type2test([0,1,2,3,4])

        #  deletion

        del a[::2]

        self.assertEqual(a, self.type2test([1,3]))

        a = self.type2test(range(5))

        del a[1::2]

        self.assertEqual(a, self.type2test([0,2,4]))

        a = self.type2test(range(5))

        del a[1::-2]

        self.assertEqual(a, self.type2test([0,2,3,4]))

        a = self.type2test(range(10))

        del a[::1000]

        self.assertEqual(a, self.type2test([1, 2, 3, 4, 5, 6, 7, 8, 9]))

        #  assignment

        a = self.type2test(range(10))

        a[::2] = [-1]*5

        self.assertEqual(a, self.type2test([-1, 1, -1, 3, -1, 5, -1, 7, -1, 9]))

        a = self.type2test(range(10))

        a[::-4] = [10]*3

        self.assertEqual(a, self.type2test([0, 10, 2, 3, 4, 10, 6, 7, 8 ,10]))

        a = self.type2test(range(4))

        a[::-1] = a

        self.assertEqual(a, self.type2test([3, 2, 1, 0]))

        a = self.type2test(range(10))

        b = a[:]

        c = a[:]

        a[2:3] = self.type2test(["two", "elements"])

        b[slice(2,3)] = self.type2test(["two", "elements"])

        c[2:3:] = self.type2test(["two", "elements"])

        self.assertEqual(a, b)

        self.assertEqual(a, c)

        a = self.type2test(range(10))

        a[::2] = tuple(range(5))

        self.assertEqual(a, self.type2test([0, 1, 1, 3, 2, 5, 3, 7, 4, 9]))

    def test_constructor_exception_handling(self):

        # Bug #1242657

        class F(object):

            def __iter__(self):

                raise KeyboardInterrupt

        self.assertRaises(KeyboardInterrupt, list, F())