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