Lib/test/test_array.py

   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
  10 from cPickle import loads, dumps, HIGHEST_PROTOCOL
  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.assertTrue(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.assertIsInstance(bi, tuple)
  67         self.assertEqual(len(bi), 2)
  68         self.assertIsInstance(bi[0], (int, long))
  69         self.assertIsInstance(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 range(HIGHEST_PROTOCOL + 1):
 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 range(HIGHEST_PROTOCOL + 1):
 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         test_support.unlink(test_support.TESTFN)
 167         f = open(test_support.TESTFN, 'wb')
 168         try:
 169             a.tofile(f)
 170             f.close()
 171             b = array.array(self.typecode)
 172             f = open(test_support.TESTFN, 'rb')
 173             self.assertRaises(TypeError, b.fromfile)
 174             self.assertRaises(
 175                 TypeError,
 176                 b.fromfile,
 177                 cStringIO.StringIO(), len(self.example)
 178             )
 179             b.fromfile(f, len(self.example))
 180             self.assertEqual(b, array.array(self.typecode, self.example))
 181             self.assertNotEqual(a, b)
 182             b.fromfile(f, len(self.example))
 183             self.assertEqual(a, b)
 184             self.assertRaises(EOFError, b.fromfile, f, 1)
 185             f.close()
 186         finally:
 187             if not f.closed:
 188                 f.close()
 189             test_support.unlink(test_support.TESTFN)
 190
 191     def test_filewrite(self):
 192         a = array.array(self.typecode, 2*self.example)
 193         f = open(test_support.TESTFN, 'wb')
 194         try:
 195             f.write(a)
 196             f.close()
 197             b = array.array(self.typecode)
 198             f = open(test_support.TESTFN, 'rb')
 199             b.fromfile(f, len(self.example))
 200             self.assertEqual(b, array.array(self.typecode, self.example))
 201             self.assertNotEqual(a, b)
 202             b.fromfile(f, len(self.example))
 203             self.assertEqual(a, b)
 204             f.close()
 205         finally:
 206             if not f.closed:
 207                 f.close()
 208             test_support.unlink(test_support.TESTFN)
 209
 210     def test_tofromlist(self):
 211         a = array.array(self.typecode, 2*self.example)
 212         b = array.array(self.typecode)
 213         self.assertRaises(TypeError, a.tolist, 42)
 214         self.assertRaises(TypeError, b.fromlist)
 215         self.assertRaises(TypeError, b.fromlist, 42)
 216         self.assertRaises(TypeError, b.fromlist, [None])
 217         b.fromlist(a.tolist())
 218         self.assertEqual(a, b)
 219
 220     def test_tofromstring(self):
 221         a = array.array(self.typecode, 2*self.example)
 222         b = array.array(self.typecode)
 223         self.assertRaises(TypeError, a.tostring, 42)
 224         self.assertRaises(TypeError, b.fromstring)
 225         self.assertRaises(TypeError, b.fromstring, 42)
 226         b.fromstring(a.tostring())
 227         self.assertEqual(a, b)
 228         if a.itemsize>1:
 229             self.assertRaises(ValueError, b.fromstring, "x")
 230
 231     def test_repr(self):
 232         a = array.array(self.typecode, 2*self.example)
 233         self.assertEqual(a, eval(repr(a), {"array": array.array}))
 234
 235         a = array.array(self.typecode)
 236         self.assertEqual(repr(a), "array('%s')" % self.typecode)
 237
 238     def test_str(self):
 239         a = array.array(self.typecode, 2*self.example)
 240         str(a)
 241
 242     def test_cmp(self):
 243         a = array.array(self.typecode, self.example)
 244         self.assertTrue((a == 42) is False)
 245         self.assertTrue((a != 42) is True)
 246
 247         self.assertTrue((a == a) is True)
 248         self.assertTrue((a != a) is False)
 249         self.assertTrue((a < a) is False)
 250         self.assertTrue((a <= a) is True)
 251         self.assertTrue((a > a) is False)
 252         self.assertTrue((a >= a) is True)
 253
 254         al = array.array(self.typecode, self.smallerexample)
 255         ab = array.array(self.typecode, self.biggerexample)
 256
 257         self.assertTrue((a == 2*a) is False)
 258         self.assertTrue((a != 2*a) is True)
 259         self.assertTrue((a < 2*a) is True)
 260         self.assertTrue((a <= 2*a) is True)
 261         self.assertTrue((a > 2*a) is False)
 262         self.assertTrue((a >= 2*a) is False)
 263
 264         self.assertTrue((a == al) is False)
 265         self.assertTrue((a != al) is True)
 266         self.assertTrue((a < al) is False)
 267         self.assertTrue((a <= al) is False)
 268         self.assertTrue((a > al) is True)
 269         self.assertTrue((a >= al) is True)
 270
 271         self.assertTrue((a == ab) is False)
 272         self.assertTrue((a != ab) is True)
 273         self.assertTrue((a < ab) is True)
 274         self.assertTrue((a <= ab) is True)
 275         self.assertTrue((a > ab) is False)
 276         self.assertTrue((a >= ab) is False)
 277
 278     def test_add(self):
 279         a = array.array(self.typecode, self.example) \
 280             + array.array(self.typecode, self.example[::-1])
 281         self.assertEqual(
 282             a,
 283             array.array(self.typecode, self.example + self.example[::-1])
 284         )
 285
 286         b = array.array(self.badtypecode())
 287         self.assertRaises(TypeError, a.__add__, b)
 288
 289         self.assertRaises(TypeError, a.__add__, "bad")
 290
 291     def test_iadd(self):
 292         a = array.array(self.typecode, self.example[::-1])
 293         b = a
 294         a += array.array(self.typecode, 2*self.example)
 295         self.assertTrue(a is b)
 296         self.assertEqual(
 297             a,
 298             array.array(self.typecode, self.example[::-1]+2*self.example)
 299         )
 300         a = array.array(self.typecode, self.example)
 301         a += a
 302         self.assertEqual(
 303             a,
 304             array.array(self.typecode, self.example + self.example)
 305         )
 306
 307         b = array.array(self.badtypecode())
 308         self.assertRaises(TypeError, a.__add__, b)
 309
 310         self.assertRaises(TypeError, a.__iadd__, "bad")
 311
 312     def test_mul(self):
 313         a = 5*array.array(self.typecode, self.example)
 314         self.assertEqual(
 315             a,
 316             array.array(self.typecode, 5*self.example)
 317         )
 318
 319         a = array.array(self.typecode, self.example)*5
 320         self.assertEqual(
 321             a,
 322             array.array(self.typecode, self.example*5)
 323         )
 324
 325         a = 0*array.array(self.typecode, self.example)
 326         self.assertEqual(
 327             a,
 328             array.array(self.typecode)
 329         )
 330
 331         a = (-1)*array.array(self.typecode, self.example)
 332         self.assertEqual(
 333             a,
 334             array.array(self.typecode)
 335         )
 336
 337         self.assertRaises(TypeError, a.__mul__, "bad")
 338
 339     def test_imul(self):
 340         a = array.array(self.typecode, self.example)
 341         b = a
 342
 343         a *= 5
 344         self.assertTrue(a is b)
 345         self.assertEqual(
 346             a,
 347             array.array(self.typecode, 5*self.example)
 348         )
 349
 350         a *= 0
 351         self.assertTrue(a is b)
 352         self.assertEqual(a, array.array(self.typecode))
 353
 354         a *= 1000
 355         self.assertTrue(a is b)
 356         self.assertEqual(a, array.array(self.typecode))
 357
 358         a *= -1
 359         self.assertTrue(a is b)
 360         self.assertEqual(a, array.array(self.typecode))
 361
 362         a = array.array(self.typecode, self.example)
 363         a *= -1
 364         self.assertEqual(a, array.array(self.typecode))
 365
 366         self.assertRaises(TypeError, a.__imul__, "bad")
 367
 368     def test_getitem(self):
 369         a = array.array(self.typecode, self.example)
 370         self.assertEntryEqual(a[0], self.example[0])
 371         self.assertEntryEqual(a[0L], self.example[0])
 372         self.assertEntryEqual(a[-1], self.example[-1])
 373         self.assertEntryEqual(a[-1L], self.example[-1])
 374         self.assertEntryEqual(a[len(self.example)-1], self.example[-1])
 375         self.assertEntryEqual(a[-len(self.example)], self.example[0])
 376         self.assertRaises(TypeError, a.__getitem__)
 377         self.assertRaises(IndexError, a.__getitem__, len(self.example))
 378         self.assertRaises(IndexError, a.__getitem__, -len(self.example)-1)
 379
 380     def test_setitem(self):
 381         a = array.array(self.typecode, self.example)
 382         a[0] = a[-1]
 383         self.assertEntryEqual(a[0], a[-1])
 384
 385         a = array.array(self.typecode, self.example)
 386         a[0L] = a[-1]
 387         self.assertEntryEqual(a[0], a[-1])
 388
 389         a = array.array(self.typecode, self.example)
 390         a[-1] = a[0]
 391         self.assertEntryEqual(a[0], a[-1])
 392
 393         a = array.array(self.typecode, self.example)
 394         a[-1L] = a[0]
 395         self.assertEntryEqual(a[0], a[-1])
 396
 397         a = array.array(self.typecode, self.example)
 398         a[len(self.example)-1] = a[0]
 399         self.assertEntryEqual(a[0], a[-1])
 400
 401         a = array.array(self.typecode, self.example)
 402         a[-len(self.example)] = a[-1]
 403         self.assertEntryEqual(a[0], a[-1])
 404
 405         self.assertRaises(TypeError, a.__setitem__)
 406         self.assertRaises(TypeError, a.__setitem__, None)
 407         self.assertRaises(TypeError, a.__setitem__, 0, None)
 408         self.assertRaises(
 409             IndexError,
 410             a.__setitem__,
 411             len(self.example), self.example[0]
 412         )
 413         self.assertRaises(
 414             IndexError,
 415             a.__setitem__,
 416             -len(self.example)-1, self.example[0]
 417         )
 418
 419     def test_delitem(self):
 420         a = array.array(self.typecode, self.example)
 421         del a[0]
 422         self.assertEqual(
 423             a,
 424             array.array(self.typecode, self.example[1:])
 425         )
 426
 427         a = array.array(self.typecode, self.example)
 428         del a[-1]
 429         self.assertEqual(
 430             a,
 431             array.array(self.typecode, self.example[:-1])
 432         )
 433
 434         a = array.array(self.typecode, self.example)
 435         del a[len(self.example)-1]
 436         self.assertEqual(
 437             a,
 438             array.array(self.typecode, self.example[:-1])
 439         )
 440
 441         a = array.array(self.typecode, self.example)
 442         del a[-len(self.example)]
 443         self.assertEqual(
 444             a,
 445             array.array(self.typecode, self.example[1:])
 446         )
 447
 448         self.assertRaises(TypeError, a.__delitem__)
 449         self.assertRaises(TypeError, a.__delitem__, None)
 450         self.assertRaises(IndexError, a.__delitem__, len(self.example))
 451         self.assertRaises(IndexError, a.__delitem__, -len(self.example)-1)
 452
 453     def test_getslice(self):
 454         a = array.array(self.typecode, self.example)
 455         self.assertEqual(a[:], a)
 456
 457         self.assertEqual(
 458             a[1:],
 459             array.array(self.typecode, self.example[1:])
 460         )
 461
 462         self.assertEqual(
 463             a[:1],
 464             array.array(self.typecode, self.example[:1])
 465         )
 466
 467         self.assertEqual(
 468             a[:-1],
 469             array.array(self.typecode, self.example[:-1])
 470         )
 471
 472         self.assertEqual(
 473             a[-1:],
 474             array.array(self.typecode, self.example[-1:])
 475         )
 476
 477         self.assertEqual(
 478             a[-1:-1],
 479             array.array(self.typecode)
 480         )
 481
 482         self.assertEqual(
 483             a[2:1],
 484             array.array(self.typecode)
 485         )
 486
 487         self.assertEqual(
 488             a[1000:],
 489             array.array(self.typecode)
 490         )
 491         self.assertEqual(a[-1000:], a)
 492         self.assertEqual(a[:1000], a)
 493         self.assertEqual(
 494             a[:-1000],
 495             array.array(self.typecode)
 496         )
 497         self.assertEqual(a[-1000:1000], a)
 498         self.assertEqual(
 499             a[2000:1000],
 500             array.array(self.typecode)
 501         )
 502
 503     def test_extended_getslice(self):
 504         # Test extended slicing by comparing with list slicing
 505         # (Assumes list conversion works correctly, too)
 506         a = array.array(self.typecode, self.example)
 507         indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100)
 508         for start in indices:
 509             for stop in indices:
 510                 # Everything except the initial 0 (invalid step)
 511                 for step in indices[1:]:
 512                     self.assertEqual(list(a[start:stop:step]),
 513                                      list(a)[start:stop:step])
 514
 515     def test_setslice(self):
 516         a = array.array(self.typecode, self.example)
 517         a[:1] = a
 518         self.assertEqual(
 519             a,
 520             array.array(self.typecode, self.example + self.example[1:])
 521         )
 522
 523         a = array.array(self.typecode, self.example)
 524         a[:-1] = a
 525         self.assertEqual(
 526             a,
 527             array.array(self.typecode, self.example + self.example[-1:])
 528         )
 529
 530         a = array.array(self.typecode, self.example)
 531         a[-1:] = a
 532         self.assertEqual(
 533             a,
 534             array.array(self.typecode, self.example[:-1] + self.example)
 535         )
 536
 537         a = array.array(self.typecode, self.example)
 538         a[1:] = a
 539         self.assertEqual(
 540             a,
 541             array.array(self.typecode, self.example[:1] + self.example)
 542         )
 543
 544         a = array.array(self.typecode, self.example)
 545         a[1:-1] = a
 546         self.assertEqual(
 547             a,
 548             array.array(
 549                 self.typecode,
 550                 self.example[:1] + self.example + self.example[-1:]
 551             )
 552         )
 553
 554         a = array.array(self.typecode, self.example)
 555         a[1000:] = a
 556         self.assertEqual(
 557             a,
 558             array.array(self.typecode, 2*self.example)
 559         )
 560
 561         a = array.array(self.typecode, self.example)
 562         a[-1000:] = a
 563         self.assertEqual(
 564             a,
 565             array.array(self.typecode, self.example)
 566         )
 567
 568         a = array.array(self.typecode, self.example)
 569         a[:1000] = a
 570         self.assertEqual(
 571             a,
 572             array.array(self.typecode, self.example)
 573         )
 574
 575         a = array.array(self.typecode, self.example)
 576         a[:-1000] = a
 577         self.assertEqual(
 578             a,
 579             array.array(self.typecode, 2*self.example)
 580         )
 581
 582         a = array.array(self.typecode, self.example)
 583         a[1:0] = a
 584         self.assertEqual(
 585             a,
 586             array.array(self.typecode, self.example[:1] + self.example + self.example[1:])
 587         )
 588
 589         a = array.array(self.typecode, self.example)
 590         a[2000:1000] = a
 591         self.assertEqual(
 592             a,
 593             array.array(self.typecode, 2*self.example)
 594         )
 595
 596         a = array.array(self.typecode, self.example)
 597         self.assertRaises(TypeError, a.__setslice__, 0, 0, None)
 598         self.assertRaises(TypeError, a.__setitem__, slice(0, 0), None)
 599         self.assertRaises(TypeError, a.__setitem__, slice(0, 1), None)
 600
 601         b = array.array(self.badtypecode())
 602         self.assertRaises(TypeError, a.__setslice__, 0, 0, b)
 603         self.assertRaises(TypeError, a.__setitem__, slice(0, 0), b)
 604         self.assertRaises(TypeError, a.__setitem__, slice(0, 1), b)
 605
 606     def test_extended_set_del_slice(self):
 607         indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100)
 608         for start in indices:
 609             for stop in indices:
 610                 # Everything except the initial 0 (invalid step)
 611                 for step in indices[1:]:
 612                     a = array.array(self.typecode, self.example)
 613                     L = list(a)
 614                     # Make sure we have a slice of exactly the right length,
 615                     # but with (hopefully) different data.
 616                     data = L[start:stop:step]
 617                     data.reverse()
 618                     L[start:stop:step] = data
 619                     a[start:stop:step] = array.array(self.typecode, data)
 620                     self.assertEquals(a, array.array(self.typecode, L))
 621
 622                     del L[start:stop:step]
 623                     del a[start:stop:step]
 624                     self.assertEquals(a, array.array(self.typecode, L))
 625
 626     def test_index(self):
 627         example = 2*self.example
 628         a = array.array(self.typecode, example)
 629         self.assertRaises(TypeError, a.index)
 630         for x in example:
 631             self.assertEqual(a.index(x), example.index(x))
 632         self.assertRaises(ValueError, a.index, None)
 633         self.assertRaises(ValueError, a.index, self.outside)
 634
 635     def test_count(self):
 636         example = 2*self.example
 637         a = array.array(self.typecode, example)
 638         self.assertRaises(TypeError, a.count)
 639         for x in example:
 640             self.assertEqual(a.count(x), example.count(x))
 641         self.assertEqual(a.count(self.outside), 0)
 642         self.assertEqual(a.count(None), 0)
 643
 644     def test_remove(self):
 645         for x in self.example:
 646             example = 2*self.example
 647             a = array.array(self.typecode, example)
 648             pos = example.index(x)
 649             example2 = example[:pos] + example[pos+1:]
 650             a.remove(x)
 651             self.assertEqual(a, array.array(self.typecode, example2))
 652
 653         a = array.array(self.typecode, self.example)
 654         self.assertRaises(ValueError, a.remove, self.outside)
 655
 656         self.assertRaises(ValueError, a.remove, None)
 657
 658     def test_pop(self):
 659         a = array.array(self.typecode)
 660         self.assertRaises(IndexError, a.pop)
 661
 662         a = array.array(self.typecode, 2*self.example)
 663         self.assertRaises(TypeError, a.pop, 42, 42)
 664         self.assertRaises(TypeError, a.pop, None)
 665         self.assertRaises(IndexError, a.pop, len(a))
 666         self.assertRaises(IndexError, a.pop, -len(a)-1)
 667
 668         self.assertEntryEqual(a.pop(0), self.example[0])
 669         self.assertEqual(
 670             a,
 671             array.array(self.typecode, self.example[1:]+self.example)
 672         )
 673         self.assertEntryEqual(a.pop(1), self.example[2])
 674         self.assertEqual(
 675             a,
 676             array.array(self.typecode, self.example[1:2]+self.example[3:]+self.example)
 677         )
 678         self.assertEntryEqual(a.pop(0), self.example[1])
 679         self.assertEntryEqual(a.pop(), self.example[-1])
 680         self.assertEqual(
 681             a,
 682             array.array(self.typecode, self.example[3:]+self.example[:-1])
 683         )
 684
 685     def test_reverse(self):
 686         a = array.array(self.typecode, self.example)
 687         self.assertRaises(TypeError, a.reverse, 42)
 688         a.reverse()
 689         self.assertEqual(
 690             a,
 691             array.array(self.typecode, self.example[::-1])
 692         )
 693
 694     def test_extend(self):
 695         a = array.array(self.typecode, self.example)
 696         self.assertRaises(TypeError, a.extend)
 697         a.extend(array.array(self.typecode, self.example[::-1]))
 698         self.assertEqual(
 699             a,
 700             array.array(self.typecode, self.example+self.example[::-1])
 701         )
 702
 703         a = array.array(self.typecode, self.example)
 704         a.extend(a)
 705         self.assertEqual(
 706             a,
 707             array.array(self.typecode, self.example+self.example)
 708         )
 709
 710         b = array.array(self.badtypecode())
 711         self.assertRaises(TypeError, a.extend, b)
 712
 713         a = array.array(self.typecode, self.example)
 714         a.extend(self.example[::-1])
 715         self.assertEqual(
 716             a,
 717             array.array(self.typecode, self.example+self.example[::-1])
 718         )
 719
 720     def test_constructor_with_iterable_argument(self):
 721         a = array.array(self.typecode, iter(self.example))
 722         b = array.array(self.typecode, self.example)
 723         self.assertEqual(a, b)
 724
 725         # non-iterable argument
 726         self.assertRaises(TypeError, array.array, self.typecode, 10)
 727
 728         # pass through errors raised in __iter__
 729         class A:
 730             def __iter__(self):
 731                 raise UnicodeError
 732         self.assertRaises(UnicodeError, array.array, self.typecode, A())
 733
 734         # pass through errors raised in next()
 735         def B():
 736             raise UnicodeError
 737             yield None
 738         self.assertRaises(UnicodeError, array.array, self.typecode, B())
 739
 740     def test_coveritertraverse(self):
 741         try:
 742             import gc
 743         except ImportError:
 744             return
 745         a = array.array(self.typecode)
 746         l = [iter(a)]
 747         l.append(l)
 748         gc.collect()
 749
 750     def test_buffer(self):
 751         a = array.array(self.typecode, self.example)
 752         with test_support.check_py3k_warnings():
 753             b = buffer(a)
 754         self.assertEqual(b[0], a.tostring()[0])
 755
 756     def test_weakref(self):
 757         s = array.array(self.typecode, self.example)
 758         p = proxy(s)
 759         self.assertEqual(p.tostring(), s.tostring())
 760         s = None
 761         self.assertRaises(ReferenceError, len, p)
 762
 763     def test_bug_782369(self):
 764         import sys
 765         if hasattr(sys, "getrefcount"):
 766             for i in range(10):
 767                 b = array.array('B', range(64))
 768             rc = sys.getrefcount(10)
 769             for i in range(10):
 770                 b = array.array('B', range(64))
 771             self.assertEqual(rc, sys.getrefcount(10))
 772
 773     def test_subclass_with_kwargs(self):
 774         # SF bug #1486663 -- this used to erroneously raise a TypeError
 775         ArraySubclassWithKwargs('b', newarg=1)
 776
 777
 778 class StringTest(BaseTest):
 779
 780     def test_setitem(self):
 781         super(StringTest, self).test_setitem()
 782         a = array.array(self.typecode, self.example)
 783         self.assertRaises(TypeError, a.__setitem__, 0, self.example[:2])
 784
 785 class CharacterTest(StringTest):
 786     typecode = 'c'
 787     example = '\x01azAZ\x00\xfe'
 788     smallerexample = '\x01azAY\x00\xfe'
 789     biggerexample = '\x01azAZ\x00\xff'
 790     outside = '\x33'
 791     minitemsize = 1
 792
 793     def test_subbclassing(self):
 794         class EditableString(array.array):
 795             def __new__(cls, s, *args, **kwargs):
 796                 return array.array.__new__(cls, 'c', s)
 797
 798             def __init__(self, s, color='blue'):
 799                 self.color = color
 800
 801             def strip(self):
 802                 self[:] = array.array('c', self.tostring().strip())
 803
 804             def __repr__(self):
 805                 return 'EditableString(%r)' % self.tostring()
 806
 807         s = EditableString("\ttest\r\n")
 808         s.strip()
 809         self.assertEqual(s.tostring(), "test")
 810
 811         self.assertEqual(s.color, "blue")
 812         s.color = "red"
 813         self.assertEqual(s.color, "red")
 814         self.assertEqual(s.__dict__.keys(), ["color"])
 815
 816     def test_nounicode(self):
 817         a = array.array(self.typecode, self.example)
 818         self.assertRaises(ValueError, a.fromunicode, unicode(''))
 819         self.assertRaises(ValueError, a.tounicode)
 820
 821 tests.append(CharacterTest)
 822
 823 if test_support.have_unicode:
 824     class UnicodeTest(StringTest):
 825         typecode = 'u'
 826         example = unicode(r'\x01\u263a\x00\ufeff', 'unicode-escape')
 827         smallerexample = unicode(r'\x01\u263a\x00\ufefe', 'unicode-escape')
 828         biggerexample = unicode(r'\x01\u263a\x01\ufeff', 'unicode-escape')
 829         outside = unicode('\x33')
 830         minitemsize = 2
 831
 832         def test_unicode(self):
 833             self.assertRaises(TypeError, array.array, 'b', unicode('foo', 'ascii'))
 834
 835             a = array.array('u', unicode(r'\xa0\xc2\u1234', 'unicode-escape'))
 836             a.fromunicode(unicode(' ', 'ascii'))
 837             a.fromunicode(unicode('', 'ascii'))
 838             a.fromunicode(unicode('', 'ascii'))
 839             a.fromunicode(unicode(r'\x11abc\xff\u1234', 'unicode-escape'))
 840             s = a.tounicode()
 841             self.assertEqual(
 842                 s,
 843                 unicode(r'\xa0\xc2\u1234 \x11abc\xff\u1234', 'unicode-escape')
 844             )
 845
 846             s = unicode(r'\x00="\'a\\b\x80\xff\u0000\u0001\u1234', 'unicode-escape')
 847             a = array.array('u', s)
 848             self.assertEqual(
 849                 repr(a),
 850                 r"""array('u', u'\x00="\'a\\b\x80\xff\x00\x01\u1234')"""
 851             )
 852
 853             self.assertRaises(TypeError, a.fromunicode)
 854
 855     tests.append(UnicodeTest)
 856
 857 class NumberTest(BaseTest):
 858
 859     def test_extslice(self):
 860         a = array.array(self.typecode, range(5))
 861         self.assertEqual(a[::], a)
 862         self.assertEqual(a[::2], array.array(self.typecode, [0,2,4]))
 863         self.assertEqual(a[1::2], array.array(self.typecode, [1,3]))
 864         self.assertEqual(a[::-1], array.array(self.typecode, [4,3,2,1,0]))
 865         self.assertEqual(a[::-2], array.array(self.typecode, [4,2,0]))
 866         self.assertEqual(a[3::-2], array.array(self.typecode, [3,1]))
 867         self.assertEqual(a[-100:100:], a)
 868         self.assertEqual(a[100:-100:-1], a[::-1])
 869         self.assertEqual(a[-100L:100L:2L], array.array(self.typecode, [0,2,4]))
 870         self.assertEqual(a[1000:2000:2], array.array(self.typecode, []))
 871         self.assertEqual(a[-1000:-2000:-2], array.array(self.typecode, []))
 872
 873     def test_delslice(self):
 874         a = array.array(self.typecode, range(5))
 875         del a[::2]
 876         self.assertEqual(a, array.array(self.typecode, [1,3]))
 877         a = array.array(self.typecode, range(5))
 878         del a[1::2]
 879         self.assertEqual(a, array.array(self.typecode, [0,2,4]))
 880         a = array.array(self.typecode, range(5))
 881         del a[1::-2]
 882         self.assertEqual(a, array.array(self.typecode, [0,2,3,4]))
 883         a = array.array(self.typecode, range(10))
 884         del a[::1000]
 885         self.assertEqual(a, array.array(self.typecode, [1,2,3,4,5,6,7,8,9]))
 886         # test issue7788
 887         a = array.array(self.typecode, range(10))
 888         del a[9::1<<333]
 889
 890     def test_assignment(self):
 891         a = array.array(self.typecode, range(10))
 892         a[::2] = array.array(self.typecode, [42]*5)
 893         self.assertEqual(a, array.array(self.typecode, [42, 1, 42, 3, 42, 5, 42, 7, 42, 9]))
 894         a = array.array(self.typecode, range(10))
 895         a[::-4] = array.array(self.typecode, [10]*3)
 896         self.assertEqual(a, array.array(self.typecode, [0, 10, 2, 3, 4, 10, 6, 7, 8 ,10]))
 897         a = array.array(self.typecode, range(4))
 898         a[::-1] = a
 899         self.assertEqual(a, array.array(self.typecode, [3, 2, 1, 0]))
 900         a = array.array(self.typecode, range(10))
 901         b = a[:]
 902         c = a[:]
 903         ins = array.array(self.typecode, range(2))
 904         a[2:3] = ins
 905         b[slice(2,3)] = ins
 906         c[2:3:] = ins
 907
 908     def test_iterationcontains(self):
 909         a = array.array(self.typecode, range(10))
 910         self.assertEqual(list(a), range(10))
 911         b = array.array(self.typecode, [20])
 912         self.assertEqual(a[-1] in a, True)
 913         self.assertEqual(b[0] not in a, True)
 914
 915     def check_overflow(self, lower, upper):
 916         # method to be used by subclasses
 917
 918         # should not overflow assigning lower limit
 919         a = array.array(self.typecode, [lower])
 920         a[0] = lower
 921         # should overflow assigning less than lower limit
 922         self.assertRaises(OverflowError, array.array, self.typecode, [lower-1])
 923         self.assertRaises(OverflowError, a.__setitem__, 0, lower-1)
 924         # should not overflow assigning upper limit
 925         a = array.array(self.typecode, [upper])
 926         a[0] = upper
 927         # should overflow assigning more than upper limit
 928         self.assertRaises(OverflowError, array.array, self.typecode, [upper+1])
 929         self.assertRaises(OverflowError, a.__setitem__, 0, upper+1)
 930
 931     def test_subclassing(self):
 932         typecode = self.typecode
 933         class ExaggeratingArray(array.array):
 934             __slots__ = ['offset']
 935
 936             def __new__(cls, typecode, data, offset):
 937                 return array.array.__new__(cls, typecode, data)
 938
 939             def __init__(self, typecode, data, offset):
 940                 self.offset = offset
 941
 942             def __getitem__(self, i):
 943                 return array.array.__getitem__(self, i) + self.offset
 944
 945         a = ExaggeratingArray(self.typecode, [3, 6, 7, 11], 4)
 946         self.assertEntryEqual(a[0], 7)
 947
 948         self.assertRaises(AttributeError, setattr, a, "color", "blue")
 949
 950 class SignedNumberTest(NumberTest):
 951     example = [-1, 0, 1, 42, 0x7f]
 952     smallerexample = [-1, 0, 1, 42, 0x7e]
 953     biggerexample = [-1, 0, 1, 43, 0x7f]
 954     outside = 23
 955
 956     def test_overflow(self):
 957         a = array.array(self.typecode)
 958         lower = -1 * long(pow(2, a.itemsize * 8 - 1))
 959         upper = long(pow(2, a.itemsize * 8 - 1)) - 1L
 960         self.check_overflow(lower, upper)
 961
 962 class UnsignedNumberTest(NumberTest):
 963     example = [0, 1, 17, 23, 42, 0xff]
 964     smallerexample = [0, 1, 17, 23, 42, 0xfe]
 965     biggerexample = [0, 1, 17, 23, 43, 0xff]
 966     outside = 0xaa
 967
 968     def test_overflow(self):
 969         a = array.array(self.typecode)
 970         lower = 0
 971         upper = long(pow(2, a.itemsize * 8)) - 1L
 972         self.check_overflow(lower, upper)
 973
 974
 975 class ByteTest(SignedNumberTest):
 976     typecode = 'b'
 977     minitemsize = 1
 978 tests.append(ByteTest)
 979
 980 class UnsignedByteTest(UnsignedNumberTest):
 981     typecode = 'B'
 982     minitemsize = 1
 983 tests.append(UnsignedByteTest)
 984
 985 class ShortTest(SignedNumberTest):
 986     typecode = 'h'
 987     minitemsize = 2
 988 tests.append(ShortTest)
 989
 990 class UnsignedShortTest(UnsignedNumberTest):
 991     typecode = 'H'
 992     minitemsize = 2
 993 tests.append(UnsignedShortTest)
 994
 995 class IntTest(SignedNumberTest):
 996     typecode = 'i'
 997     minitemsize = 2
 998 tests.append(IntTest)
 999
1000 class UnsignedIntTest(UnsignedNumberTest):
1001     typecode = 'I'
1002     minitemsize = 2
1003 tests.append(UnsignedIntTest)
1004
1005 class LongTest(SignedNumberTest):
1006     typecode = 'l'
1007     minitemsize = 4
1008 tests.append(LongTest)
1009
1010 class UnsignedLongTest(UnsignedNumberTest):
1011     typecode = 'L'
1012     minitemsize = 4
1013 tests.append(UnsignedLongTest)
1014
1015 class FPTest(NumberTest):
1016     example = [-42.0, 0, 42, 1e5, -1e10]
1017     smallerexample = [-42.0, 0, 42, 1e5, -2e10]
1018     biggerexample = [-42.0, 0, 42, 1e5, 1e10]
1019     outside = 23
1020
1021     def assertEntryEqual(self, entry1, entry2):
1022         self.assertAlmostEqual(entry1, entry2)
1023
1024     def test_byteswap(self):
1025         a = array.array(self.typecode, self.example)
1026         self.assertRaises(TypeError, a.byteswap, 42)
1027         if a.itemsize in (1, 2, 4, 8):
1028             b = array.array(self.typecode, self.example)
1029             b.byteswap()
1030             if a.itemsize==1:
1031                 self.assertEqual(a, b)
1032             else:
1033                 # On alphas treating the byte swapped bit patters as
1034                 # floats/doubles results in floating point exceptions
1035                 # => compare the 8bit string values instead
1036                 self.assertNotEqual(a.tostring(), b.tostring())
1037             b.byteswap()
1038             self.assertEqual(a, b)
1039
1040 class FloatTest(FPTest):
1041     typecode = 'f'
1042     minitemsize = 4
1043 tests.append(FloatTest)
1044
1045 class DoubleTest(FPTest):
1046     typecode = 'd'
1047     minitemsize = 8
1048
1049     def test_alloc_overflow(self):
1050         from sys import maxsize
1051         a = array.array('d', [-1]*65536)
1052         try:
1053             a *= maxsize//65536 + 1
1054         except MemoryError:
1055             pass
1056         else:
1057             self.fail("Array of size > maxsize created - MemoryError expected")
1058         b = array.array('d', [ 2.71828183, 3.14159265, -1])
1059         try:
1060             b * (maxsize//3 + 1)
1061         except MemoryError:
1062             pass
1063         else:
1064             self.fail("Array of size > maxsize created - MemoryError expected")
1065
1066 tests.append(DoubleTest)
1067
1068 def test_main(verbose=None):
1069     import sys
1070
1071     test_support.run_unittest(*tests)
1072
1073     # verify reference counting
1074     if verbose and hasattr(sys, "gettotalrefcount"):
1075         import gc
1076         counts = [None] * 5
1077         for i in xrange(len(counts)):
1078             test_support.run_unittest(*tests)
1079             gc.collect()
1080             counts[i] = sys.gettotalrefcount()
1081         print counts
1082
1083 if __name__ == "__main__":
1084     test_main(verbose=True)