#! /usr/bin/env python

"""Test the arraymodule.

   Roger E. Masse

"""

import unittest

from test import test_support

from weakref import proxy

import array, cStringIO

from cPickle import loads, dumps

class ArraySubclass(array.array):

    pass

class ArraySubclassWithKwargs(array.array):

    def __init__(self, typecode, newarg=None):

        array.array.__init__(typecode)

tests = [] # list to accumulate all tests

typecodes = "cubBhHiIlLfd"

class BadConstructorTest(unittest.TestCase):

    def test_constructor(self):

        self.assertRaises(TypeError, array.array)

        self.assertRaises(TypeError, array.array, spam=42)

        self.assertRaises(TypeError, array.array, 'xx')

        self.assertRaises(ValueError, array.array, 'x')

tests.append(BadConstructorTest)

class BaseTest(unittest.TestCase):

    # Required class attributes (provided by subclasses

    # typecode: the typecode to test

    # example: an initializer usable in the constructor for this type

    # smallerexample: the same length as example, but smaller

    # biggerexample: the same length as example, but bigger

    # outside: An entry that is not in example

    # minitemsize: the minimum guaranteed itemsize

    def assertEntryEqual(self, entry1, entry2):

        self.assertEqual(entry1, entry2)

    def badtypecode(self):

        # Return a typecode that is different from our own

        return typecodes[(typecodes.index(self.typecode)+1) % len(typecodes)]

    def test_constructor(self):

        a = array.array(self.typecode)

        self.assertEqual(a.typecode, self.typecode)

        self.assert_(a.itemsize>=self.minitemsize)

        self.assertRaises(TypeError, array.array, self.typecode, None)

    def test_len(self):

        a = array.array(self.typecode)

        a.append(self.example[0])

        self.assertEqual(len(a), 1)

        a = array.array(self.typecode, self.example)

        self.assertEqual(len(a), len(self.example))

    def test_buffer_info(self):

        a = array.array(self.typecode, self.example)

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

        bi = a.buffer_info()

        self.assert_(isinstance(bi, tuple))

        self.assertEqual(len(bi), 2)

        self.assert_(isinstance(bi[0], (int, long)))

        self.assert_(isinstance(bi[1], int))

        self.assertEqual(bi[1], len(a))

    def test_byteswap(self):

        a = array.array(self.typecode, self.example)

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

        if a.itemsize in (1, 2, 4, 8):

            b = array.array(self.typecode, self.example)

            b.byteswap()

            if a.itemsize==1:

                self.assertEqual(a, b)

            else:

                self.assertNotEqual(a, b)

            b.byteswap()

            self.assertEqual(a, b)

    def test_copy(self):

        import copy

        a = array.array(self.typecode, self.example)

        b = copy.copy(a)

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

        self.assertEqual(a, b)

    def test_deepcopy(self):

        import copy

        a = array.array(self.typecode, self.example)

        b = copy.deepcopy(a)

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

        self.assertEqual(a, b)

    def test_pickle(self):

        for protocol in (0, 1, 2):

            a = array.array(self.typecode, self.example)

            b = loads(dumps(a, protocol))

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

            self.assertEqual(a, b)

            a = ArraySubclass(self.typecode, self.example)

            a.x = 10

            b = loads(dumps(a, protocol))

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

            self.assertEqual(a, b)

            self.assertEqual(a.x, b.x)

            self.assertEqual(type(a), type(b))

    def test_pickle_for_empty_array(self):

        for protocol in (0, 1, 2):

            a = array.array(self.typecode)

            b = loads(dumps(a, protocol))

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

            self.assertEqual(a, b)

            a = ArraySubclass(self.typecode)

            a.x = 10

            b = loads(dumps(a, protocol))

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

            self.assertEqual(a, b)

            self.assertEqual(a.x, b.x)

            self.assertEqual(type(a), type(b))

    def test_insert(self):

        a = array.array(self.typecode, self.example)

        a.insert(0, self.example[0])

        self.assertEqual(len(a), 1+len(self.example))

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

        self.assertRaises(TypeError, a.insert)

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

        self.assertRaises(TypeError, a.insert, 0, None)

        a = array.array(self.typecode, self.example)

        a.insert(-1, self.example[0])

        self.assertEqual(

            a,

            array.array(

                self.typecode,

                self.example[:-1] + self.example[:1] + self.example[-1:]

            )

        )

        a = array.array(self.typecode, self.example)

        a.insert(-1000, self.example[0])

        self.assertEqual(

            a,

            array.array(self.typecode, self.example[:1] + self.example)

        )

        a = array.array(self.typecode, self.example)

        a.insert(1000, self.example[0])

        self.assertEqual(

            a,

            array.array(self.typecode, self.example + self.example[:1])

        )

    def test_tofromfile(self):

        a = array.array(self.typecode, 2*self.example)

        self.assertRaises(TypeError, a.tofile)

        self.assertRaises(TypeError, a.tofile, cStringIO.StringIO())

        test_support.unlink(test_support.TESTFN)

        f = open(test_support.TESTFN, 'wb')

        try:

            a.tofile(f)

            f.close()

            b = array.array(self.typecode)

            f = open(test_support.TESTFN, 'rb')

            self.assertRaises(TypeError, b.fromfile)

            self.assertRaises(

                TypeError,

                b.fromfile,

                cStringIO.StringIO(), len(self.example)

            )

            b.fromfile(f, len(self.example))

            self.assertEqual(b, array.array(self.typecode, self.example))

            self.assertNotEqual(a, b)

            b.fromfile(f, len(self.example))

            self.assertEqual(a, b)

            self.assertRaises(EOFError, b.fromfile, f, 1)

            f.close()

        finally:

            if not f.closed:

                f.close()

            test_support.unlink(test_support.TESTFN)

    def test_tofromlist(self):

        a = array.array(self.typecode, 2*self.example)

        b = array.array(self.typecode)

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

        self.assertRaises(TypeError, b.fromlist)

        self.assertRaises(TypeError, b.fromlist, 42)

        self.assertRaises(TypeError, b.fromlist, [None])

        b.fromlist(a.tolist())

        self.assertEqual(a, b)

    def test_tofromstring(self):

        a = array.array(self.typecode, 2*self.example)

        b = array.array(self.typecode)

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

        self.assertRaises(TypeError, b.fromstring)

        self.assertRaises(TypeError, b.fromstring, 42)

        b.fromstring(a.tostring())

        self.assertEqual(a, b)

        if a.itemsize>1:

            self.assertRaises(ValueError, b.fromstring, "x")

    def test_repr(self):

        a = array.array(self.typecode, 2*self.example)

        self.assertEqual(a, eval(repr(a), {"array": array.array}))

        a = array.array(self.typecode)

        self.assertEqual(repr(a), "array('%s')" % self.typecode)

    def test_str(self):

        a = array.array(self.typecode, 2*self.example)

        str(a)

    def test_cmp(self):

        a = array.array(self.typecode, self.example)

        self.assert_((a == 42) is False)

        self.assert_((a != 42) is True)

        self.assert_((a == a) is True)

        self.assert_((a != a) is False)

        self.assert_((a < a) is False)

        self.assert_((a <= a) is True)

        self.assert_((a > a) is False)

        self.assert_((a >= a) is True)

        al = array.array(self.typecode, self.smallerexample)

        ab = array.array(self.typecode, self.biggerexample)

        self.assert_((a == 2*a) is False)

        self.assert_((a != 2*a) is True)

        self.assert_((a < 2*a) is True)

        self.assert_((a <= 2*a) is True)

        self.assert_((a > 2*a) is False)

        self.assert_((a >= 2*a) is False)

        self.assert_((a == al) is False)

        self.assert_((a != al) is True)

        self.assert_((a < al) is False)

        self.assert_((a <= al) is False)

        self.assert_((a > al) is True)

        self.assert_((a >= al) is True)

        self.assert_((a == ab) is False)

        self.assert_((a != ab) is True)

        self.assert_((a < ab) is True)

        self.assert_((a <= ab) is True)

        self.assert_((a > ab) is False)

        self.assert_((a >= ab) is False)

    def test_add(self):

        a = array.array(self.typecode, self.example) \

            + array.array(self.typecode, self.example[::-1])

        self.assertEqual(

            a,

            array.array(self.typecode, self.example + self.example[::-1])

        )

        b = array.array(self.badtypecode())

        self.assertRaises(TypeError, a.__add__, b)

        self.assertRaises(TypeError, a.__add__, "bad")

    def test_iadd(self):

        a = array.array(self.typecode, self.example[::-1])

        b = a

        a += array.array(self.typecode, 2*self.example)

        self.assert_(a is b)

        self.assertEqual(

            a,

            array.array(self.typecode, self.example[::-1]+2*self.example)

        )

        b = array.array(self.badtypecode())

        self.assertRaises(TypeError, a.__add__, b)

        self.assertRaises(TypeError, a.__iadd__, "bad")

    def test_mul(self):

        a = 5*array.array(self.typecode, self.example)

        self.assertEqual(

            a,

            array.array(self.typecode, 5*self.example)

        )

        a = array.array(self.typecode, self.example)*5

        self.assertEqual(

            a,

            array.array(self.typecode, self.example*5)

        )

        a = 0*array.array(self.typecode, self.example)

        self.assertEqual(

            a,

            array.array(self.typecode)

        )

        a = (-1)*array.array(self.typecode, self.example)

        self.assertEqual(

            a,

            array.array(self.typecode)

        )

        self.assertRaises(TypeError, a.__mul__, "bad")

    def test_imul(self):

        a = array.array(self.typecode, self.example)

        b = a

        a *= 5

        self.assert_(a is b)

        self.assertEqual(

            a,

            array.array(self.typecode, 5*self.example)

        )

        a *= 0

        self.assert_(a is b)

        self.assertEqual(a, array.array(self.typecode))

        a *= 1000

        self.assert_(a is b)

        self.assertEqual(a, array.array(self.typecode))

        a *= -1

        self.assert_(a is b)

        self.assertEqual(a, array.array(self.typecode))

        a = array.array(self.typecode, self.example)

        a *= -1

        self.assertEqual(a, array.array(self.typecode))

        self.assertRaises(TypeError, a.__imul__, "bad")

    def test_getitem(self):

        a = array.array(self.typecode, self.example)

        self.assertEntryEqual(a[0], self.example[0])

        self.assertEntryEqual(a[0L], self.example[0])

        self.assertEntryEqual(a[-1], self.example[-1])

        self.assertEntryEqual(a[-1L], self.example[-1])

        self.assertEntryEqual(a[len(self.example)-1], self.example[-1])

        self.assertEntryEqual(a[-len(self.example)], self.example[0])

        self.assertRaises(TypeError, a.__getitem__)

        self.assertRaises(IndexError, a.__getitem__, len(self.example))

        self.assertRaises(IndexError, a.__getitem__, -len(self.example)-1)

    def test_setitem(self):

        a = array.array(self.typecode, self.example)

        a[0] = a[-1]

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

        a = array.array(self.typecode, self.example)

        a[0L] = a[-1]

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

        a = array.array(self.typecode, self.example)

        a[-1] = a[0]

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

        a = array.array(self.typecode, self.example)

        a[-1L] = a[0]

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

        a = array.array(self.typecode, self.example)

        a[len(self.example)-1] = a[0]

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

        a = array.array(self.typecode, self.example)

        a[-len(self.example)] = a[-1]

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

        self.assertRaises(TypeError, a.__setitem__)

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

        self.assertRaises(TypeError, a.__setitem__, 0, None)

        self.assertRaises(

            IndexError,

            a.__setitem__,

            len(self.example), self.example[0]

        )

        self.assertRaises(

            IndexError,

            a.__setitem__,

            -len(self.example)-1, self.example[0]

        )

    def test_delitem(self):

        a = array.array(self.typecode, self.example)

        del a[0]

        self.assertEqual(

            a,

            array.array(self.typecode, self.example[1:])

        )

        a = array.array(self.typecode, self.example)

        del a[-1]

        self.assertEqual(

            a,

            array.array(self.typecode, self.example[:-1])

        )

        a = array.array(self.typecode, self.example)

        del a[len(self.example)-1]

        self.assertEqual(

            a,

            array.array(self.typecode, self.example[:-1])

        )

        a = array.array(self.typecode, self.example)

        del a[-len(self.example)]

        self.assertEqual(

            a,

            array.array(self.typecode, self.example[1:])

        )

        self.assertRaises(TypeError, a.__delitem__)

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

        self.assertRaises(IndexError, a.__delitem__, len(self.example))

        self.assertRaises(IndexError, a.__delitem__, -len(self.example)-1)

    def test_getslice(self):

        a = array.array(self.typecode, self.example)

        self.assertEqual(a[:], a)

        self.assertEqual(

            a[1:],

            array.array(self.typecode, self.example[1:])

        )

        self.assertEqual(

            a[:1],

            array.array(self.typecode, self.example[:1])

        )

        self.assertEqual(

            a[:-1],

            array.array(self.typecode, self.example[:-1])

        )

        self.assertEqual(

            a[-1:],

            array.array(self.typecode, self.example[-1:])

        )

        self.assertEqual(

            a[-1:-1],

            array.array(self.typecode)

        )

        self.assertEqual(

            a[2:1],

            array.array(self.typecode)

        )

        self.assertEqual(

            a[1000:],

            array.array(self.typecode)

        )

        self.assertEqual(a[-1000:], a)

        self.assertEqual(a[:1000], a)

        self.assertEqual(

            a[:-1000],

            array.array(self.typecode)

        )

        self.assertEqual(a[-1000:1000], a)

        self.assertEqual(

            a[2000:1000],

            array.array(self.typecode)

        )

    def test_extended_getslice(self):

        # Test extended slicing by comparing with list slicing

        # (Assumes list conversion works correctly, too)

        a = array.array(self.typecode, self.example)

        indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100)

        for start in indices:

            for stop in indices:

                # Everything except the initial 0 (invalid step)

                for step in indices[1:]:

                    self.assertEqual(list(a[start:stop:step]),

                                     list(a)[start:stop:step])

    def test_setslice(self):

        a = array.array(self.typecode, self.example)

        a[:1] = a

        self.assertEqual(

            a,

            array.array(self.typecode, self.example + self.example[1:])

        )

        a = array.array(self.typecode, self.example)

        a[:-1] = a

        self.assertEqual(

            a,

            array.array(self.typecode, self.example + self.example[-1:])

        )

        a = array.array(self.typecode, self.example)

        a[-1:] = a

        self.assertEqual(

            a,

            array.array(self.typecode, self.example[:-1] + self.example)

        )

        a = array.array(self.typecode, self.example)

        a[1:] = a

        self.assertEqual(

            a,

            array.array(self.typecode, self.example[:1] + self.example)

        )

        a = array.array(self.typecode, self.example)

        a[1:-1] = a

        self.assertEqual(

            a,

            array.array(

                self.typecode,

                self.example[:1] + self.example + self.example[-1:]

            )

        )