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