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) 1096
