1 #! /usr/bin/env python

     2 """Test the arraymodule.

     3    Roger E. Masse

     4 """

     5 

     6 import unittest

     7 from test import test_support

     8 from weakref import proxy

     9 import array, cStringIO, math

    10 from cPickle import loads, dumps

    11 

    12 class ArraySubclass(array.array):

    13     pass

    14 

    15 class ArraySubclassWithKwargs(array.array):

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

    17         array.array.__init__(typecode)

    18 

    19 tests = [] # list to accumulate all tests

    20 typecodes = "cubBhHiIlLfd"

    21 

    22 class BadConstructorTest(unittest.TestCase):

    23 

    24     def test_constructor(self):

    25         self.assertRaises(TypeError, array.array)

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

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

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

    29 

    30 tests.append(BadConstructorTest)

    31 

    32 class BaseTest(unittest.TestCase):

    33     # Required class attributes (provided by subclasses

    34     # typecode: the typecode to test

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

    36     # smallerexample: the same length as example, but smaller

    37     # biggerexample: the same length as example, but bigger

    38     # outside: An entry that is not in example

    39     # minitemsize: the minimum guaranteed itemsize

    40 

    41     def assertEntryEqual(self, entry1, entry2):

    42         self.assertEqual(entry1, entry2)

    43 

    44     def badtypecode(self):

    45         # Return a typecode that is different from our own

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

    47 

    48     def test_constructor(self):

    49         a = array.array(self.typecode)

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

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

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

    53 

    54     def test_len(self):

    55         a = array.array(self.typecode)

    56         a.append(self.example[0])

    57         self.assertEqual(len(a), 1)

    58 

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

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

    61 

    62     def test_buffer_info(self):

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

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

    65         bi = a.buffer_info()

    66         self.assert_(isinstance(bi, tuple))

    67         self.assertEqual(len(bi), 2)

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

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

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

    71 

    72     def test_byteswap(self):

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

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

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

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

    77             b.byteswap()

    78             if a.itemsize==1:

    79                 self.assertEqual(a, b)

    80             else:

    81                 self.assertNotEqual(a, b)

    82             b.byteswap()

    83             self.assertEqual(a, b)

    84 

    85     def test_copy(self):

    86         import copy

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

    88         b = copy.copy(a)

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

    90         self.assertEqual(a, b)

    91 

    92     def test_deepcopy(self):

    93         import copy

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

    95         b = copy.deepcopy(a)

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

    97         self.assertEqual(a, b)

    98 

    99     def test_pickle(self):

   100         for protocol in (0, 1, 2):

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

   102             b = loads(dumps(a, protocol))

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

   104             self.assertEqual(a, b)

   105 

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

   107             a.x = 10

   108             b = loads(dumps(a, protocol))

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

   110             self.assertEqual(a, b)

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

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

   113 

   114     def test_pickle_for_empty_array(self):

   115         for protocol in (0, 1, 2):

   116             a = array.array(self.typecode)

   117             b = loads(dumps(a, protocol))

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

   119             self.assertEqual(a, b)

   120 

   121             a = ArraySubclass(self.typecode)

   122             a.x = 10

   123             b = loads(dumps(a, protocol))

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

   125             self.assertEqual(a, b)

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

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

   128 

   129     def test_insert(self):

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

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

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

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

   134         self.assertRaises(TypeError, a.insert)

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

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

   137 

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

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

   140         self.assertEqual(

   141             a,

   142             array.array(

   143                 self.typecode,

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

   145             )

   146         )

   147 

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

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

   150         self.assertEqual(

   151             a,

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

   153         )

   154 

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

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

   157         self.assertEqual(

   158             a,

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

   160         )

   161 

   162     def test_tofromfile(self):

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

   164         self.assertRaises(TypeError, a.tofile)

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

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

   167         try:

   168             a.tofile(f)

   169             f.close()

   170             b = array.array(self.typecode)

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

   172             self.assertRaises(TypeError, b.fromfile)

   173             self.assertRaises(

   174                 TypeError,

   175                 b.fromfile,

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

   177             )

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

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

   180             self.assertNotEqual(a, b)

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

   182             self.assertEqual(a, b)

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

   184             f.close()

   185         finally:

   186             if not f.closed:

   187                 f.close()

   188             test_support.unlink(test_support.TESTFN)

   189 

   190     def test_tofromlist(self):

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

   192         b = array.array(self.typecode)

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

   194         self.assertRaises(TypeError, b.fromlist)

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

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

   197         b.fromlist(a.tolist())

   198         self.assertEqual(a, b)

   199 

   200     def test_tofromstring(self):

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

   202         b = array.array(self.typecode)

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

   204         self.assertRaises(TypeError, b.fromstring)

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

   206         b.fromstring(a.tostring())

   207         self.assertEqual(a, b)

   208         if a.itemsize>1:

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

   210 

   211     def test_repr(self):

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

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

   214 

   215         a = array.array(self.typecode)

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

   217 

   218     def test_str(self):

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

   220         str(a)

   221 

   222     def test_cmp(self):

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

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

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

   226 

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

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

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

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

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

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

   233 

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

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

   236 

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

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

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

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

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

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

   243 

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

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

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

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

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

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

   250 

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

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

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

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

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

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

   257 

   258     def test_add(self):

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

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

   261         self.assertEqual(

   262             a,

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

   264         )

   265 

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

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

   268 

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

   270 

   271     def test_iadd(self):

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

   273         b = a

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

   275         self.assert_(a is b)

   276         self.assertEqual(

   277             a,

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

   279         )

   280 

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

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

   283 

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

   285 

   286     def test_mul(self):

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

   288         self.assertEqual(

   289             a,

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

   291         )

   292 

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

   294         self.assertEqual(

   295             a,

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

   297         )

   298 

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

   300         self.assertEqual(

   301             a,

   302             array.array(self.typecode)

   303         )

   304 

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

   306         self.assertEqual(

   307             a,

   308             array.array(self.typecode)

   309         )

   310 

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

   312 

   313     def test_imul(self):

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

   315         b = a

   316 

   317         a *= 5

   318         self.assert_(a is b)

   319         self.assertEqual(

   320             a,

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

   322         )

   323 

   324         a *= 0

   325         self.assert_(a is b)

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

   327 

   328         a *= 1000

   329         self.assert_(a is b)

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

   331 

   332         a *= -1

   333         self.assert_(a is b)

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

   335 

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

   337         a *= -1

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

   339 

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

   341 

   342     def test_getitem(self):

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

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

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

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

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

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

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

   350         self.assertRaises(TypeError, a.__getitem__)

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

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

   353 

   354     def test_setitem(self):

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

   356         a[0] = a[-1]

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

   358 

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

   360         a[0L] = a[-1]

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

   362 

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

   364         a[-1] = a[0]

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

   366 

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

   368         a[-1L] = a[0]

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

   370 

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

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

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

   374 

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

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

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

   378 

   379         self.assertRaises(TypeError, a.__setitem__)

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

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

   382         self.assertRaises(

   383             IndexError,

   384             a.__setitem__,

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

   386         )

   387         self.assertRaises(

   388             IndexError,

   389             a.__setitem__,

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

   391         )

   392 

   393     def test_delitem(self):

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

   395         del a[0]

   396         self.assertEqual(

   397             a,

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

   399         )

   400 

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

   402         del a[-1]

   403         self.assertEqual(

   404             a,

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

   406         )

   407 

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

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

   410         self.assertEqual(

   411             a,

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

   413         )

   414 

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

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

   417         self.assertEqual(

   418             a,

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

   420         )

   421 

   422         self.assertRaises(TypeError, a.__delitem__)

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

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

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

   426 

   427     def test_getslice(self):

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

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

   430 

   431         self.assertEqual(

   432             a[1:],

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

   434         )

   435 

   436         self.assertEqual(

   437             a[:1],

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

   439         )

   440 

   441         self.assertEqual(

   442             a[:-1],

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

   444         )

   445 

   446         self.assertEqual(

   447             a[-1:],

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

   449         )

   450 

   451         self.assertEqual(

   452             a[-1:-1],

   453             array.array(self.typecode)

   454         )

   455 

   456         self.assertEqual(

   457             a[2:1],

   458             array.array(self.typecode)

   459         )

   460 

   461         self.assertEqual(

   462             a[1000:],

   463             array.array(self.typecode)

   464         )

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

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

   467         self.assertEqual(

   468             a[:-1000],

   469             array.array(self.typecode)

   470         )

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

   472         self.assertEqual(

   473             a[2000:1000],

   474             array.array(self.typecode)

   475         )

   476 

   477     def test_setslice(self):

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

   479         a[:1] = a

   480         self.assertEqual(

   481             a,

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

   483         )

   484 

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

   486         a[:-1] = a

   487         self.assertEqual(

   488             a,

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

   490         )

   491 

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

   493         a[-1:] = a

   494         self.assertEqual(

   495             a,

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

   497         )

   498 

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

   500         a[1:] = a

   501         self.assertEqual(

   502             a,

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

   504         )

   505 

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

   507         a[1:-1] = a

   508         self.assertEqual(

   509             a,

   510             array.array(

   511                 self.typecode,

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

   513             )

   514         )

   515 

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

   517         a[1000:] = a

   518         self.assertEqual(

   519             a,

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

   521         )

   522 

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

   524         a[-1000:] = a

   525         self.assertEqual(

   526             a,

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

   528         )

   529 

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

   531         a[:1000] = a

   532         self.assertEqual(

   533             a,

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

   535         )

   536 

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

   538         a[:-1000] = a

   539         self.assertEqual(

   540             a,

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

   542         )

   543 

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

   545         a[1:0] = a

   546         self.assertEqual(

   547             a,

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

   549         )

   550 

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

   552         a[2000:1000] = a

   553         self.assertEqual(

   554             a,

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

   556         )

   557 

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

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

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

   561 

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

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

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

   565 

   566     def test_index(self):

   567         example = 2*self.example

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

   569         self.assertRaises(TypeError, a.index)

   570         for x in example:

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

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

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

   574 

   575     def test_count(self):

   576         example = 2*self.example

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

   578         self.assertRaises(TypeError, a.count)

   579         for x in example:

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

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

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

   583 

   584     def test_remove(self):

   585         for x in self.example:

   586             example = 2*self.example

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

   588             pos = example.index(x)

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

   590             a.remove(x)

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

   592 

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

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

   595 

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

   597 

   598     def test_pop(self):

   599         a = array.array(self.typecode)

   600         self.assertRaises(IndexError, a.pop)

   601 

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

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

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

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

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

   607 

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

   609         self.assertEqual(

   610             a,

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

   612         )

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

   614         self.assertEqual(

   615             a,

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

   617         )

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

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

   620         self.assertEqual(

   621             a,

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

   623         )

   624 

   625     def test_reverse(self):

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

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

   628         a.reverse()

   629         self.assertEqual(

   630             a,

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

   632         )

   633 

   634     def test_extend(self):

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

   636         self.assertRaises(TypeError, a.extend)

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

   638         self.assertEqual(

   639             a,

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

   641         )

   642 

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

   644         self.assertRaises(TypeError, a.extend, b)

   645 

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

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

   648         self.assertEqual(

   649             a,

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

   651         )

   652 

   653     def test_constructor_with_iterable_argument(self):

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

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

   656         self.assertEqual(a, b)

   657 

   658         # non-iterable argument

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

   660 

   661         # pass through errors raised in __iter__

   662         class A:

   663             def __iter__(self):

   664                 raise UnicodeError

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

   666 

   667         # pass through errors raised in next()

   668         def B():

   669             raise UnicodeError

   670             yield None

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

   672 

   673     def test_coveritertraverse(self):

   674         try:

   675             import gc

   676         except ImportError:

   677             return

   678         a = array.array(self.typecode)

   679         l = [iter(a)]

   680         l.append(l)

   681         gc.collect()

   682 

   683     def test_buffer(self):

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

   685         b = buffer(a)

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

   687 

   688     def test_weakref(self):

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

   690         p = proxy(s)

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

   692         s = None

   693         self.assertRaises(ReferenceError, len, p)

   694 

   695     def test_bug_782369(self):

   696         import sys

   697         if hasattr(sys, "getrefcount"):

   698             for i in range(10):

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

   700             rc = sys.getrefcount(10)

   701             for i in range(10):

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

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

   704 

   705     def test_subclass_with_kwargs(self):

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

   707         ArraySubclassWithKwargs('b', newarg=1)

   708 

   709 

   710 class StringTest(BaseTest):

   711 

   712     def test_setitem(self):

   713         super(StringTest, self).test_setitem()

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

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

   716 

   717 class CharacterTest(StringTest):

   718     typecode = 'c'

   719     example = '\x01azAZ\x00\xfe'

   720     smallerexample = '\x01azAY\x00\xfe'

   721     biggerexample = '\x01azAZ\x00\xff'

   722     outside = '\x33'

   723     minitemsize = 1

   724 

   725     def test_subbclassing(self):

   726         class EditableString(array.array):

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

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

   729 

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

   731                 array.array.__init__(self, 'c', s)

   732                 self.color = color

   733 

   734             def strip(self):

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

   736 

   737             def __repr__(self):

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

   739 

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

   741         s.strip()

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

   743 

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

   745         s.color = "red"

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

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

   748 

   749     def test_nounicode(self):

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

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

   752         self.assertRaises(ValueError, a.tounicode)

   753 

   754 tests.append(CharacterTest)

   755 

   756 if test_support.have_unicode:

   757     class UnicodeTest(StringTest):

   758         typecode = 'u'

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

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

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

   762         outside = unicode('\x33')

   763         minitemsize = 2

   764 

   765         def test_unicode(self):

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

   767 

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

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

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

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

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

   773             s = a.tounicode()

   774             self.assertEqual(

   775                 s,

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

   777             )

   778 

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

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

   781             self.assertEqual(

   782                 repr(a),

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

   784             )

   785 

   786             self.assertRaises(TypeError, a.fromunicode)

   787 

   788     tests.append(UnicodeTest)

   789 

   790 class NumberTest(BaseTest):

   791 

   792     def test_extslice(self):

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

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

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

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

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

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

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

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

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

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

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

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

   805 

   806     def test_delslice(self):

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

   808         del a[::2]

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

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

   811         del a[1::2]

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

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

   814         del a[1::-2]

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

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

   817         del a[::1000]

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

   819 

   820     def test_assignment(self):

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

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

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

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

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

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

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

   828         a[::-1] = a

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

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

   831         b = a[:]

   832         c = a[:]

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

   834         a[2:3] = ins

   835         b[slice(2,3)] = ins

   836         c[2:3:] = ins

   837 

   838     def test_iterationcontains(self):

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

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

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

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

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

   844 

   845     def check_overflow(self, lower, upper):

   846         # method to be used by subclasses

   847 

   848         # should not overflow assigning lower limit

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

   850         a[0] = lower

   851         # should overflow assigning less than lower limit

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

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

   854         # should not overflow assigning upper limit

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

   856         a[0] = upper

   857         # should overflow assigning more than upper limit

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

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

   860 

   861     def test_subclassing(self):

   862         typecode = self.typecode

   863         class ExaggeratingArray(array.array):

   864             __slots__ = ['offset']

   865 

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

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

   868 

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

   870                 self.offset = offset

   871 

   872             def __getitem__(self, i):

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

   874 

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

   876         self.assertEntryEqual(a[0], 7)

   877 

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

   879 

   880 class SignedNumberTest(NumberTest):

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

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

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

   884     outside = 23

   885 

   886     def test_overflow(self):

   887         a = array.array(self.typecode)

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

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

   890         self.check_overflow(lower, upper)

   891 

   892 class UnsignedNumberTest(NumberTest):

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

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

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

   896     outside = 0xaa

   897 

   898     def test_overflow(self):

   899         a = array.array(self.typecode)

   900         lower = 0

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

   902         self.check_overflow(lower, upper)

   903 

   904 

   905 class ByteTest(SignedNumberTest):

   906     typecode = 'b'

   907     minitemsize = 1

   908 tests.append(ByteTest)

   909 

   910 class UnsignedByteTest(UnsignedNumberTest):

   911     typecode = 'B'

   912     minitemsize = 1

   913 tests.append(UnsignedByteTest)

   914 

   915 class ShortTest(SignedNumberTest):

   916     typecode = 'h'

   917     minitemsize = 2

   918 tests.append(ShortTest)

   919 

   920 class UnsignedShortTest(UnsignedNumberTest):

   921     typecode = 'H'

   922     minitemsize = 2

   923 tests.append(UnsignedShortTest)

   924 

   925 class IntTest(SignedNumberTest):

   926     typecode = 'i'

   927     minitemsize = 2

   928 tests.append(IntTest)

   929 

   930 class UnsignedIntTest(UnsignedNumberTest):

   931     typecode = 'I'

   932     minitemsize = 2

   933 tests.append(UnsignedIntTest)

   934 

   935 class LongTest(SignedNumberTest):

   936     typecode = 'l'

   937     minitemsize = 4

   938 tests.append(LongTest)

   939 

   940 class UnsignedLongTest(UnsignedNumberTest):

   941     typecode = 'L'

   942     minitemsize = 4

   943 tests.append(UnsignedLongTest)

   944 

   945 class FPTest(NumberTest):

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

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

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

   949     outside = 23

   950 

   951     def assertEntryEqual(self, entry1, entry2):

   952         self.assertAlmostEqual(entry1, entry2)

   953 

   954     def test_byteswap(self):

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

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

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

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

   959             b.byteswap()

   960             if a.itemsize==1:

   961                 self.assertEqual(a, b)

   962             else:

   963                 # On alphas treating the byte swapped bit patters as

   964                 # floats/doubles results in floating point exceptions

   965                 # => compare the 8bit string values instead

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

   967             b.byteswap()

   968             self.assertEqual(a, b)

   969 

   970 class FloatTest(FPTest):

   971     typecode = 'f'

   972     minitemsize = 4

   973 tests.append(FloatTest)

   974 

   975 class DoubleTest(FPTest):

   976     typecode = 'd'

   977     minitemsize = 8

   978 tests.append(DoubleTest)

   979 

   980 def test_main(verbose=None):

   981     import sys

   982 

   983     test_support.run_unittest(*tests)

   984 

   985     # verify reference counting

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

   987         import gc

   988         counts = [None] * 5

   989         for i in xrange(len(counts)):

   990             test_support.run_unittest(*tests)

   991             gc.collect()

   992             counts[i] = sys.gettotalrefcount()

   993         print counts

   994 

   995 if __name__ == "__main__":

   996     test_main(verbose=True)