#! /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, HIGHEST_PROTOCOL



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 range(HIGHEST_PROTOCOL + 1):

            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 range(HIGHEST_PROTOCOL + 1):

            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:]

            )

        )



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

        a[1000:] = a

        self.assertEqual(

            a,

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

        )



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

        a[-1000:] = a

        self.assertEqual(

            a,

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

        )



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

        a[:1000] = a

        self.assertEqual(

            a,

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

        )



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

        a[:-1000] = a

        self.assertEqual(

            a,

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

        )



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

        a[1:0] = a

        self.assertEqual(

            a,

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

        )



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

        a[2000:1000] = a

        self.assertEqual(

            a,

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

        )



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

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

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

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



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

        self.assertRaises(TypeError, a.__setslice__, 0, 0, b)

        self.assertRaises(TypeError, a.__setitem__, slice(0, 0), b)

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



    def test_extended_set_del_slice(self):

        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:]:

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

                    L = list(a)

                    # Make sure we have a slice of exactly the right length,

                    # but with (hopefully) different data.

                    data = L[start:stop:step]

                    data.reverse()

                    L[start:stop:step] = data

                    a[start:stop:step] = array.array(self.typecode, data)

                    self.assertEquals(a, array.array(self.typecode, L))



                    del L[start:stop:step]

                    del a[start:stop:step]

                    self.assertEquals(a, array.array(self.typecode, L))



    def test_index(self):

        example = 2*self.example

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

        self.assertRaises(TypeError, a.index)

        for x in example:

            self.assertEqual(a.index(x), example.index(x))

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

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



    def test_count(self):

        example = 2*self.example

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

        self.assertRaises(TypeError, a.count)

        for x in example:

            self.assertEqual(a.count(x), example.count(x))

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

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



    def test_remove(self):

        for x in self.example:

            example = 2*self.example

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

            pos = example.index(x)

            example2 = example[:pos] + example[pos+1:]

            a.remove(x)

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



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

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



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



    def test_pop(self):

        a = array.array(self.typecode)

        self.assertRaises(IndexError, a.pop)



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

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

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

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

        self.assertRaises(IndexError, a.pop, -len(a)-1)



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

        self.assertEqual(

            a,

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

        )

        self.assertEntryEqual(a.pop(1), self.example[2])

        self.assertEqual(

            a,

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

        )

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

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

        self.assertEqual(

            a,

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

        )



    def test_reverse(self):

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

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

        a.reverse()

        self.assertEqual(

            a,

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

        )



    def test_extend(self):

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

        self.assertRaises(TypeError, a.extend)

        a.extend(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.extend, b)



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

        a.extend(self.example[::-1])

        self.assertEqual(

            a,

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

        )



    def test_constructor_with_iterable_argument(self):

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

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

        self.assertEqual(a, b)



        # non-iterable argument

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



        # pass through errors raised in __iter__

        class A:

            def __iter__(self):

                raise UnicodeError

        self.assertRaises(UnicodeError, array.array, self.typecode, A())



        # pass through errors raised in next()

        def B():

            raise UnicodeError

            yield None

        self.assertRaises(UnicodeError, array.array, self.typecode, B())



    def test_coveritertraverse(self):

        try:

            import gc

        except ImportError:

            return

        a = array.array(self.typecode)

        l = [iter(a)]

        l.append(l)

        gc.collect()



    def test_buffer(self):

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

        b = buffer(a)

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



    def test_weakref(self):

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

        p = proxy(s)

        self.assertEqual(p.tostring(), s.tostring())

        s = None

        self.assertRaises(ReferenceError, len, p)



    def test_bug_782369(self):

        import sys

        if hasattr(sys, "getrefcount"):

            for i in range(10):

                b = array.array('B', range(64))

            rc = sys.getrefcount(10)

            for i in range(10):

                b = array.array('B', range(64))

            self.assertEqual(rc, sys.getrefcount(10))



    def test_subclass_with_kwargs(self):

        # SF bug #1486663 -- this used to erroneously raise a TypeError

        ArraySubclassWithKwargs('b', newarg=1)





class StringTest(BaseTest):



    def test_setitem(self):

        super(StringTest, self).test_setitem()

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

        self.assertRaises(TypeError, a.__setitem__, 0, self.example[:2])



class CharacterTest(StringTest):

    typecode = 'c'

    example = '\x01azAZ\x00\xfe'

    smallerexample = '\x01azAY\x00\xfe'

    biggerexample = '\x01azAZ\x00\xff'

    outside = '\x33'

    minitemsize = 1



    def test_subbclassing(self):

        class EditableString(array.array):

            def __new__(cls, s, *args, **kwargs):

                return array.array.__new__(cls, 'c', s)



            def __init__(self, s, color='blue'):

                self.color = color



            def strip(self):

                self[:] = array.array('c', self.tostring().strip())



            def __repr__(self):

                return 'EditableString(%r)' % self.tostring()



        s = EditableString("\ttest\r\n")

        s.strip()

        self.assertEqual(s.tostring(), "test")



        self.assertEqual(s.color, "blue")

        s.color = "red"

        self.assertEqual(s.color, "red")

        self.assertEqual(s.__dict__.keys(), ["color"])



    def test_nounicode(self):

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

        self.assertRaises(ValueError, a.fromunicode, unicode(''))

        self.assertRaises(ValueError, a.tounicode)



tests.append(CharacterTest)



if test_support.have_unicode:

    class UnicodeTest(StringTest):

        typecode = 'u'

        example = unicode(r'\x01\u263a\x00\ufeff', 'unicode-escape')

        smallerexample = unicode(r'\x01\u263a\x00\ufefe', 'unicode-escape')

        biggerexample = unicode(r'\x01\u263a\x01\ufeff', 'unicode-escape')

        outside = unicode('\x33')

        minitemsize = 2



        def test_unicode(self):

            self.assertRaises(TypeError, array.array, 'b', unicode('foo', 'ascii'))



            a = array.array('u', unicode(r'\xa0\xc2\u1234', 'unicode-escape'))

            a.fromunicode(unicode(' ', 'ascii'))

            a.fromunicode(unicode('', 'ascii'))

            a.fromunicode(unicode('', 'ascii'))

            a.fromunicode(unicode(r'\x11abc\xff\u1234', 'unicode-escape'))

            s = a.tounicode()

            self.assertEqual(

                s,

                unicode(r'\xa0\xc2\u1234 \x11abc\xff\u1234', 'unicode-escape')

            )



            s = unicode(r'\x00="\'a\\b\x80\xff\u0000\u0001\u1234', 'unicode-escape')

            a = array.array('u', s)

            self.assertEqual(

                repr(a),

                r"""array('u', u'\x00="\'a\\b\x80\xff\x00\x01\u1234')"""

            )



            self.assertRaises(TypeError, a.fromunicode)



    tests.append(UnicodeTest)



class NumberTest(BaseTest):



    def test_extslice(self):

        a = array.array(self.typecode, range(5))

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

        self.assertEqual(a[::2], array.array(self.typecode, [0,2,4]))

        self.assertEqual(a[1::2], array.array(self.typecode, [1,3]))

        self.assertEqual(a[::-1], array.array(self.typecode, [4,3,2,1,0]))

        self.assertEqual(a[::-2], array.array(self.typecode, [4,2,0]))

        self.assertEqual(a[3::-2], array.array(self.typecode, [3,1]))

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

        self.assertEqual(a[100:-100:-1], a[::-1])

        self.assertEqual(a[-100L:100L:2L], array.array(self.typecode, [0,2,4]))

        self.assertEqual(a[1000:2000:2], array.array(self.typecode, []))

        self.assertEqual(a[-1000:-2000:-2], array.array(self.typecode, []))



    def test_delslice(self):

        a = array.array(self.typecode, range(5))

        del a[::2]

        self.assertEqual(a, array.array(self.typecode, [1,3]))

        a = array.array(self.typecode, range(5))

        del a[1::2]

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

        a = array.array(self.typecode, range(5))

        del a[1::-2]

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

        a = array.array(self.typecode, range(10))

        del a[::1000]

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



    def test_assignment(self):

        a = array.array(self.typecode, range(10))

        a[::2] = array.array(self.typecode, [42]*5)

        self.assertEqual(a, array.array(self.typecode, [42, 1, 42, 3, 42, 5, 42, 7, 42, 9]))

        a = array.array(self.typecode, range(10))

        a[::-4] = array.array(self.typecode, [10]*3)

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

        a = array.array(self.typecode, range(4))

        a[::-1] = a

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

        a = array.array(self.typecode, range(10))

        b = a[:]

        c = a[:]

        ins = array.array(self.typecode, range(2))

        a[2:3] = ins

        b[slice(2,3)] = ins

        c[2:3:] = ins



    def test_iterationcontains(self):

        a = array.array(self.typecode, range(10))

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

        b = array.array(self.typecode, [20])

        self.assertEqual(a[-1] in a, True)

        self.assertEqual(b[0] not in a, True)



    def check_overflow(self, lower, upper):

        # method to be used by subclasses



        # should not overflow assigning lower limit

        a = array.array(self.typecode, [lower])

        a[0] = lower

        # should overflow assigning less than lower limit

        self.assertRaises(OverflowError, array.array, self.typecode, [lower-1])

        self.assertRaises(OverflowError, a.__setitem__, 0, lower-1)

        # should not overflow assigning upper limit

        a = array.array(self.typecode, [upper])

        a[0] = upper

        # should overflow assigning more than upper limit

        self.assertRaises(OverflowError, array.array, self.typecode, [upper+1])

        self.assertRaises(OverflowError, a.__setitem__, 0, upper+1)



    def test_subclassing(self):

        typecode = self.typecode

        class ExaggeratingArray(array.array):

            __slots__ = ['offset']



            def __new__(cls, typecode, data, offset):

                return array.array.__new__(cls, typecode, data)



            def __init__(self, typecode, data, offset):

                self.offset = offset



            def __getitem__(self, i):

                return array.array.__getitem__(self, i) + self.offset



        a = ExaggeratingArray(self.typecode, [3, 6, 7, 11], 4)

        self.assertEntryEqual(a[0], 7)



        self.assertRaises(AttributeError, setattr, a, "color", "blue")



class SignedNumberTest(NumberTest):

    example = [-1, 0, 1, 42, 0x7f]

    smallerexample = [-1, 0, 1, 42, 0x7e]

    biggerexample = [-1, 0, 1, 43, 0x7f]

    outside = 23



    def test_overflow(self):

        a = array.array(self.typecode)

        lower = -1 * long(pow(2, a.itemsize * 8 - 1))

        upper = long(pow(2, a.itemsize * 8 - 1)) - 1L

        self.check_overflow(lower, upper)



class UnsignedNumberTest(NumberTest):

    example = [0, 1, 17, 23, 42, 0xff]

    smallerexample = [0, 1, 17, 23, 42, 0xfe]

    biggerexample = [0, 1, 17, 23, 43, 0xff]

    outside = 0xaa



    def test_overflow(self):

        a = array.array(self.typecode)

        lower = 0

        upper = long(pow(2, a.itemsize * 8)) - 1L

        self.check_overflow(lower, upper)





class ByteTest(SignedNumberTest):

    typecode = 'b'

    minitemsize = 1

tests.append(ByteTest)



class UnsignedByteTest(UnsignedNumberTest):

    typecode = 'B'

    minitemsize = 1

tests.append(UnsignedByteTest)



class ShortTest(SignedNumberTest):

    typecode = 'h'

    minitemsize = 2

tests.append(ShortTest)



class UnsignedShortTest(UnsignedNumberTest):

    typecode = 'H'

    minitemsize = 2

tests.append(UnsignedShortTest)



class IntTest(SignedNumberTest):

    typecode = 'i'

    minitemsize = 2

tests.append(IntTest)



class UnsignedIntTest(UnsignedNumberTest):

    typecode = 'I'

    minitemsize = 2

tests.append(UnsignedIntTest)



class LongTest(SignedNumberTest):

    typecode = 'l'

    minitemsize = 4

tests.append(LongTest)



class UnsignedLongTest(UnsignedNumberTest):

    typecode = 'L'

    minitemsize = 4

tests.append(UnsignedLongTest)



class FPTest(NumberTest):

    example = [-42.0, 0, 42, 1e5, -1e10]

    smallerexample = [-42.0, 0, 42, 1e5, -2e10]

    biggerexample = [-42.0, 0, 42, 1e5, 1e10]

    outside = 23



    def assertEntryEqual(self, entry1, entry2):

        self.assertAlmostEqual(entry1, entry2)



    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:

                # On alphas treating the byte swapped bit patters as

                # floats/doubles results in floating point exceptions

                # => compare the 8bit string values instead

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

            b.byteswap()

            self.assertEqual(a, b)



class FloatTest(FPTest):

    typecode = 'f'

    minitemsize = 4

tests.append(FloatTest)



class DoubleTest(FPTest):

    typecode = 'd'

    minitemsize = 8



    def test_alloc_overflow(self):

        from sys import maxsize

        a = array.array('d', [-1]*65536)

        try:

            a *= maxsize//65536 + 1

        except MemoryError:

            pass

        else:

            self.fail("Array of size > maxsize created - MemoryError expected")

        b = array.array('d', [ 2.71828183, 3.14159265, -1])

        try:

            b * (maxsize//3 + 1)

        except MemoryError:

            pass

        else:

            self.fail("Array of size > maxsize created - MemoryError expected")



tests.append(DoubleTest)



def test_main(verbose=None):

    import sys



    test_support.run_unittest(*tests)



    # verify reference counting

    if verbose and hasattr(sys, "gettotalrefcount"):

        import gc

        counts = [None] * 5

        for i in xrange(len(counts)):

            test_support.run_unittest(*tests)

            gc.collect()

            counts[i] = sys.gettotalrefcount()

        print counts



if __name__ == "__main__":

    test_main(verbose=True)

