1 """Test the arraymodule. 2 Roger E. Masse 3 """ 4 5 import unittest 6 from test import support 7 import weakref 8 import pickle 9 import operator 10 import struct 11 import sys 12 import warnings 13 14 import array 15 from array import _array_reconstructor as array_reconstructor 16 17 try: 18 # Try to determine availability of long long independently 19 # of the array module under test 20 struct.calcsize('@q') 21 have_long_long = True 22 except struct.error: 23 have_long_long = False 24 25 sizeof_wchar = array.array('u').itemsize 26 27 28 class ArraySubclass(array.array): 29 pass 30 31 class ArraySubclassWithKwargs(array.array): 32 def __init__(self, typecode, newarg=None): 33 array.array.__init__(self) 34 35 typecodes = "ubBhHiIlLfd" 36 if have_long_long: 37 typecodes += 'qQ' 38 39 class MiscTest(unittest.TestCase): 40 41 def test_bad_constructor(self): 42 self.assertRaises(TypeError, array.array) 43 self.assertRaises(TypeError, array.array, spam=42) 44 self.assertRaises(TypeError, array.array, 'xx') 45 self.assertRaises(ValueError, array.array, 'x') 46 47 def test_empty(self): 48 # Exercise code for handling zero-length arrays 49 a = array.array('B') 50 a[:] = a 51 self.assertEqual(len(a), 0) 52 self.assertEqual(len(a + a), 0) 53 self.assertEqual(len(a * 3), 0) 54 a += a 55 self.assertEqual(len(a), 0) 56 57 58 # Machine format codes. 59 # 60 # Search for "enum machine_format_code" in Modules/arraymodule.c to get the 61 # authoritative values. 62 UNKNOWN_FORMAT = -1 63 UNSIGNED_INT8 = 0 64 SIGNED_INT8 = 1 65 UNSIGNED_INT16_LE = 2 66 UNSIGNED_INT16_BE = 3 67 SIGNED_INT16_LE = 4 68 SIGNED_INT16_BE = 5 69 UNSIGNED_INT32_LE = 6 70 UNSIGNED_INT32_BE = 7 71 SIGNED_INT32_LE = 8 72 SIGNED_INT32_BE = 9 73 UNSIGNED_INT64_LE = 10 74 UNSIGNED_INT64_BE = 11 75 SIGNED_INT64_LE = 12 76 SIGNED_INT64_BE = 13 77 IEEE_754_FLOAT_LE = 14 78 IEEE_754_FLOAT_BE = 15 79 IEEE_754_DOUBLE_LE = 16 80 IEEE_754_DOUBLE_BE = 17 81 UTF16_LE = 18 82 UTF16_BE = 19 83 UTF32_LE = 20 84 UTF32_BE = 21 85 86 class ArrayReconstructorTest(unittest.TestCase): 87 88 def test_error(self): 89 self.assertRaises(TypeError, array_reconstructor, 90 "", "b", 0, b"") 91 self.assertRaises(TypeError, array_reconstructor, 92 str, "b", 0, b"") 93 self.assertRaises(TypeError, array_reconstructor, 94 array.array, "b", '', b"") 95 self.assertRaises(TypeError, array_reconstructor, 96 array.array, "b", 0, "") 97 self.assertRaises(ValueError, array_reconstructor, 98 array.array, "?", 0, b"") 99 self.assertRaises(ValueError, array_reconstructor, 100 array.array, "b", UNKNOWN_FORMAT, b"") 101 self.assertRaises(ValueError, array_reconstructor, 102 array.array, "b", 22, b"") 103 self.assertRaises(ValueError, array_reconstructor, 104 array.array, "d", 16, b"a") 105 106 def test_numbers(self): 107 testcases = ( 108 (['B', 'H', 'I', 'L'], UNSIGNED_INT8, '=BBBB', 109 [0x80, 0x7f, 0, 0xff]), 110 (['b', 'h', 'i', 'l'], SIGNED_INT8, '=bbb', 111 [-0x80, 0x7f, 0]), 112 (['H', 'I', 'L'], UNSIGNED_INT16_LE, '<HHHH', 113 [0x8000, 0x7fff, 0, 0xffff]), 114 (['H', 'I', 'L'], UNSIGNED_INT16_BE, '>HHHH', 115 [0x8000, 0x7fff, 0, 0xffff]), 116 (['h', 'i', 'l'], SIGNED_INT16_LE, '<hhh', 117 [-0x8000, 0x7fff, 0]), 118 (['h', 'i', 'l'], SIGNED_INT16_BE, '>hhh', 119 [-0x8000, 0x7fff, 0]), 120 (['I', 'L'], UNSIGNED_INT32_LE, '<IIII', 121 [1<<31, (1<<31)-1, 0, (1<<32)-1]), 122 (['I', 'L'], UNSIGNED_INT32_BE, '>IIII', 123 [1<<31, (1<<31)-1, 0, (1<<32)-1]), 124 (['i', 'l'], SIGNED_INT32_LE, '<iii', 125 [-1<<31, (1<<31)-1, 0]), 126 (['i', 'l'], SIGNED_INT32_BE, '>iii', 127 [-1<<31, (1<<31)-1, 0]), 128 (['L'], UNSIGNED_INT64_LE, '<QQQQ', 129 [1<<31, (1<<31)-1, 0, (1<<32)-1]), 130 (['L'], UNSIGNED_INT64_BE, '>QQQQ', 131 [1<<31, (1<<31)-1, 0, (1<<32)-1]), 132 (['l'], SIGNED_INT64_LE, '<qqq', 133 [-1<<31, (1<<31)-1, 0]), 134 (['l'], SIGNED_INT64_BE, '>qqq', 135 [-1<<31, (1<<31)-1, 0]), 136 # The following tests for INT64 will raise an OverflowError 137 # when run on a 32-bit machine. The tests are simply skipped 138 # in that case. 139 (['L'], UNSIGNED_INT64_LE, '<QQQQ', 140 [1<<63, (1<<63)-1, 0, (1<<64)-1]), 141 (['L'], UNSIGNED_INT64_BE, '>QQQQ', 142 [1<<63, (1<<63)-1, 0, (1<<64)-1]), 143 (['l'], SIGNED_INT64_LE, '<qqq', 144 [-1<<63, (1<<63)-1, 0]), 145 (['l'], SIGNED_INT64_BE, '>qqq', 146 [-1<<63, (1<<63)-1, 0]), 147 (['f'], IEEE_754_FLOAT_LE, '<ffff', 148 [16711938.0, float('inf'), float('-inf'), -0.0]), 149 (['f'], IEEE_754_FLOAT_BE, '>ffff', 150 [16711938.0, float('inf'), float('-inf'), -0.0]), 151 (['d'], IEEE_754_DOUBLE_LE, '<dddd', 152 [9006104071832581.0, float('inf'), float('-inf'), -0.0]), 153 (['d'], IEEE_754_DOUBLE_BE, '>dddd', 154 [9006104071832581.0, float('inf'), float('-inf'), -0.0]) 155 ) 156 for testcase in testcases: 157 valid_typecodes, mformat_code, struct_fmt, values = testcase 158 arraystr = struct.pack(struct_fmt, *values) 159 for typecode in valid_typecodes: 160 try: 161 a = array.array(typecode, values) 162 except OverflowError: 163 continue # Skip this test case. 164 b = array_reconstructor( 165 array.array, typecode, mformat_code, arraystr) 166 self.assertEqual(a, b, 167 msg="{0!r} != {1!r}; testcase={2!r}".format(a, b, testcase)) 168 169 def test_unicode(self): 170 teststr = "Bonne Journ\xe9e \U0002030a\U00020347" 171 testcases = ( 172 (UTF16_LE, "UTF-16-LE"), 173 (UTF16_BE, "UTF-16-BE"), 174 (UTF32_LE, "UTF-32-LE"), 175 (UTF32_BE, "UTF-32-BE") 176 ) 177 for testcase in testcases: 178 mformat_code, encoding = testcase 179 a = array.array('u', teststr) 180 b = array_reconstructor( 181 array.array, 'u', mformat_code, teststr.encode(encoding)) 182 self.assertEqual(a, b, 183 msg="{0!r} != {1!r}; testcase={2!r}".format(a, b, testcase)) 184 185 186 class BaseTest: 187 # Required class attributes (provided by subclasses 188 # typecode: the typecode to test 189 # example: an initializer usable in the constructor for this type 190 # smallerexample: the same length as example, but smaller 191 # biggerexample: the same length as example, but bigger 192 # outside: An entry that is not in example 193 # minitemsize: the minimum guaranteed itemsize 194 195 def assertEntryEqual(self, entry1, entry2): 196 self.assertEqual(entry1, entry2) 197 198 def badtypecode(self): 199 # Return a typecode that is different from our own 200 return typecodes[(typecodes.index(self.typecode)+1) % len(typecodes)] 201 202 def test_constructor(self): 203 a = array.array(self.typecode) 204 self.assertEqual(a.typecode, self.typecode) 205 self.assertGreaterEqual(a.itemsize, self.minitemsize) 206 self.assertRaises(TypeError, array.array, self.typecode, None) 207 208 def test_len(self): 209 a = array.array(self.typecode) 210 a.append(self.example[0]) 211 self.assertEqual(len(a), 1) 212 213 a = array.array(self.typecode, self.example) 214 self.assertEqual(len(a), len(self.example)) 215 216 def test_buffer_info(self): 217 a = array.array(self.typecode, self.example) 218 self.assertRaises(TypeError, a.buffer_info, 42) 219 bi = a.buffer_info() 220 self.assertIsInstance(bi, tuple) 221 self.assertEqual(len(bi), 2) 222 self.assertIsInstance(bi[0], int) 223 self.assertIsInstance(bi[1], int) 224 self.assertEqual(bi[1], len(a)) 225 226 def test_byteswap(self): 227 if self.typecode == 'u': 228 example = '\U00100100' 229 else: 230 example = self.example 231 a = array.array(self.typecode, example) 232 self.assertRaises(TypeError, a.byteswap, 42) 233 if a.itemsize in (1, 2, 4, 8): 234 b = array.array(self.typecode, example) 235 b.byteswap() 236 if a.itemsize==1: 237 self.assertEqual(a, b) 238 else: 239 self.assertNotEqual(a, b) 240 b.byteswap() 241 self.assertEqual(a, b) 242 243 def test_copy(self): 244 import copy 245 a = array.array(self.typecode, self.example) 246 b = copy.copy(a) 247 self.assertNotEqual(id(a), id(b)) 248 self.assertEqual(a, b) 249 250 def test_deepcopy(self): 251 import copy 252 a = array.array(self.typecode, self.example) 253 b = copy.deepcopy(a) 254 self.assertNotEqual(id(a), id(b)) 255 self.assertEqual(a, b) 256 257 def test_reduce_ex(self): 258 a = array.array(self.typecode, self.example) 259 for protocol in range(3): 260 self.assertIs(a.__reduce_ex__(protocol)[0], array.array) 261 for protocol in range(3, pickle.HIGHEST_PROTOCOL): 262 self.assertIs(a.__reduce_ex__(protocol)[0], array_reconstructor) 263 264 def test_pickle(self): 265 for protocol in range(pickle.HIGHEST_PROTOCOL + 1): 266 a = array.array(self.typecode, self.example) 267 b = pickle.loads(pickle.dumps(a, protocol)) 268 self.assertNotEqual(id(a), id(b)) 269 self.assertEqual(a, b) 270 271 a = ArraySubclass(self.typecode, self.example) 272 a.x = 10 273 b = pickle.loads(pickle.dumps(a, protocol)) 274 self.assertNotEqual(id(a), id(b)) 275 self.assertEqual(a, b) 276 self.assertEqual(a.x, b.x) 277 self.assertEqual(type(a), type(b)) 278 279 def test_pickle_for_empty_array(self): 280 for protocol in range(pickle.HIGHEST_PROTOCOL + 1): 281 a = array.array(self.typecode) 282 b = pickle.loads(pickle.dumps(a, protocol)) 283 self.assertNotEqual(id(a), id(b)) 284 self.assertEqual(a, b) 285 286 a = ArraySubclass(self.typecode) 287 a.x = 10 288 b = pickle.loads(pickle.dumps(a, protocol)) 289 self.assertNotEqual(id(a), id(b)) 290 self.assertEqual(a, b) 291 self.assertEqual(a.x, b.x) 292 self.assertEqual(type(a), type(b)) 293 294 def test_iterator_pickle(self): 295 orig = array.array(self.typecode, self.example) 296 data = list(orig) 297 data2 = data[::-1] 298 for proto in range(pickle.HIGHEST_PROTOCOL + 1): 299 # initial iterator 300 itorig = iter(orig) 301 d = pickle.dumps((itorig, orig), proto) 302 it, a = pickle.loads(d) 303 a.fromlist(data2) 304 self.assertEqual(type(it), type(itorig)) 305 self.assertEqual(list(it), data + data2) 306 307 # running iterator 308 next(itorig) 309 d = pickle.dumps((itorig, orig), proto) 310 it, a = pickle.loads(d) 311 a.fromlist(data2) 312 self.assertEqual(type(it), type(itorig)) 313 self.assertEqual(list(it), data[1:] + data2) 314 315 # empty iterator 316 for i in range(1, len(data)): 317 next(itorig) 318 d = pickle.dumps((itorig, orig), proto) 319 it, a = pickle.loads(d) 320 a.fromlist(data2) 321 self.assertEqual(type(it), type(itorig)) 322 self.assertEqual(list(it), data2) 323 324 # exhausted iterator 325 self.assertRaises(StopIteration, next, itorig) 326 d = pickle.dumps((itorig, orig), proto) 327 it, a = pickle.loads(d) 328 a.fromlist(data2) 329 self.assertEqual(list(it), []) 330 331 def test_exhausted_iterator(self): 332 a = array.array(self.typecode, self.example) 333 self.assertEqual(list(a), list(self.example)) 334 exhit = iter(a) 335 empit = iter(a) 336 for x in exhit: # exhaust the iterator 337 next(empit) # not exhausted 338 a.append(self.outside) 339 self.assertEqual(list(exhit), []) 340 self.assertEqual(list(empit), [self.outside]) 341 self.assertEqual(list(a), list(self.example) + [self.outside]) 342 343 def test_insert(self): 344 a = array.array(self.typecode, self.example) 345 a.insert(0, self.example[0]) 346 self.assertEqual(len(a), 1+len(self.example)) 347 self.assertEqual(a[0], a[1]) 348 self.assertRaises(TypeError, a.insert) 349 self.assertRaises(TypeError, a.insert, None) 350 self.assertRaises(TypeError, a.insert, 0, None) 351 352 a = array.array(self.typecode, self.example) 353 a.insert(-1, self.example[0]) 354 self.assertEqual( 355 a, 356 array.array( 357 self.typecode, 358 self.example[:-1] + self.example[:1] + self.example[-1:] 359 ) 360 ) 361 362 a = array.array(self.typecode, self.example) 363 a.insert(-1000, self.example[0]) 364 self.assertEqual( 365 a, 366 array.array(self.typecode, self.example[:1] + self.example) 367 ) 368 369 a = array.array(self.typecode, self.example) 370 a.insert(1000, self.example[0]) 371 self.assertEqual( 372 a, 373 array.array(self.typecode, self.example + self.example[:1]) 374 ) 375 376 def test_tofromfile(self): 377 a = array.array(self.typecode, 2*self.example) 378 self.assertRaises(TypeError, a.tofile) 379 support.unlink(support.TESTFN) 380 f = open(support.TESTFN, 'wb') 381 try: 382 a.tofile(f) 383 f.close() 384 b = array.array(self.typecode) 385 f = open(support.TESTFN, 'rb') 386 self.assertRaises(TypeError, b.fromfile) 387 b.fromfile(f, len(self.example)) 388 self.assertEqual(b, array.array(self.typecode, self.example)) 389 self.assertNotEqual(a, b) 390 self.assertRaises(EOFError, b.fromfile, f, len(self.example)+1) 391 self.assertEqual(a, b) 392 f.close() 393 finally: 394 if not f.closed: 395 f.close() 396 support.unlink(support.TESTFN) 397 398 def test_fromfile_ioerror(self): 399 # Issue #5395: Check if fromfile raises a proper OSError 400 # instead of EOFError. 401 a = array.array(self.typecode) 402 f = open(support.TESTFN, 'wb') 403 try: 404 self.assertRaises(OSError, a.fromfile, f, len(self.example)) 405 finally: 406 f.close() 407 support.unlink(support.TESTFN) 408 409 def test_filewrite(self): 410 a = array.array(self.typecode, 2*self.example) 411 f = open(support.TESTFN, 'wb') 412 try: 413 f.write(a) 414 f.close() 415 b = array.array(self.typecode) 416 f = open(support.TESTFN, 'rb') 417 b.fromfile(f, len(self.example)) 418 self.assertEqual(b, array.array(self.typecode, self.example)) 419 self.assertNotEqual(a, b) 420 b.fromfile(f, len(self.example)) 421 self.assertEqual(a, b) 422 f.close() 423 finally: 424 if not f.closed: 425 f.close() 426 support.unlink(support.TESTFN) 427 428 def test_tofromlist(self): 429 a = array.array(self.typecode, 2*self.example) 430 b = array.array(self.typecode) 431 self.assertRaises(TypeError, a.tolist, 42) 432 self.assertRaises(TypeError, b.fromlist) 433 self.assertRaises(TypeError, b.fromlist, 42) 434 self.assertRaises(TypeError, b.fromlist, [None]) 435 b.fromlist(a.tolist()) 436 self.assertEqual(a, b) 437 438 def test_tofromstring(self): 439 # Warnings not raised when arguments are incorrect as Argument Clinic 440 # handles that before the warning can be raised. 441 nb_warnings = 2 442 with warnings.catch_warnings(record=True) as r: 443 warnings.filterwarnings("always", 444 message=r"(to|from)string\(\) is deprecated", 445 category=DeprecationWarning) 446 a = array.array(self.typecode, 2*self.example) 447 b = array.array(self.typecode) 448 self.assertRaises(TypeError, a.tostring, 42) 449 self.assertRaises(TypeError, b.fromstring) 450 self.assertRaises(TypeError, b.fromstring, 42) 451 b.fromstring(a.tostring()) 452 self.assertEqual(a, b) 453 if a.itemsize>1: 454 self.assertRaises(ValueError, b.fromstring, "x") 455 nb_warnings += 1 456 self.assertEqual(len(r), nb_warnings) 457 458 def test_tofrombytes(self): 459 a = array.array(self.typecode, 2*self.example) 460 b = array.array(self.typecode) 461 self.assertRaises(TypeError, a.tobytes, 42) 462 self.assertRaises(TypeError, b.frombytes) 463 self.assertRaises(TypeError, b.frombytes, 42) 464 b.frombytes(a.tobytes()) 465 c = array.array(self.typecode, bytearray(a.tobytes())) 466 self.assertEqual(a, b) 467 self.assertEqual(a, c) 468 if a.itemsize>1: 469 self.assertRaises(ValueError, b.frombytes, b"x") 470 471 def test_fromarray(self): 472 a = array.array(self.typecode, self.example) 473 b = array.array(self.typecode, a) 474 self.assertEqual(a, b) 475 476 def test_repr(self): 477 a = array.array(self.typecode, 2*self.example) 478 self.assertEqual(a, eval(repr(a), {"array": array.array})) 479 480 a = array.array(self.typecode) 481 self.assertEqual(repr(a), "array('%s')" % self.typecode) 482 483 def test_str(self): 484 a = array.array(self.typecode, 2*self.example) 485 str(a) 486 487 def test_cmp(self): 488 a = array.array(self.typecode, self.example) 489 self.assertIs(a == 42, False) 490 self.assertIs(a != 42, True) 491 492 self.assertIs(a == a, True) 493 self.assertIs(a != a, False) 494 self.assertIs(a < a, False) 495 self.assertIs(a <= a, True) 496 self.assertIs(a > a, False) 497 self.assertIs(a >= a, True) 498 499 al = array.array(self.typecode, self.smallerexample) 500 ab = array.array(self.typecode, self.biggerexample) 501 502 self.assertIs(a == 2*a, False) 503 self.assertIs(a != 2*a, True) 504 self.assertIs(a < 2*a, True) 505 self.assertIs(a <= 2*a, True) 506 self.assertIs(a > 2*a, False) 507 self.assertIs(a >= 2*a, False) 508 509 self.assertIs(a == al, False) 510 self.assertIs(a != al, True) 511 self.assertIs(a < al, False) 512 self.assertIs(a <= al, False) 513 self.assertIs(a > al, True) 514 self.assertIs(a >= al, True) 515 516 self.assertIs(a == ab, False) 517 self.assertIs(a != ab, True) 518 self.assertIs(a < ab, True) 519 self.assertIs(a <= ab, True) 520 self.assertIs(a > ab, False) 521 self.assertIs(a >= ab, False) 522 523 def test_add(self): 524 a = array.array(self.typecode, self.example) \ 525 + array.array(self.typecode, self.example[::-1]) 526 self.assertEqual( 527 a, 528 array.array(self.typecode, self.example + self.example[::-1]) 529 ) 530 531 b = array.array(self.badtypecode()) 532 self.assertRaises(TypeError, a.__add__, b) 533 534 self.assertRaises(TypeError, a.__add__, "bad") 535 536 def test_iadd(self): 537 a = array.array(self.typecode, self.example[::-1]) 538 b = a 539 a += array.array(self.typecode, 2*self.example) 540 self.assertIs(a, b) 541 self.assertEqual( 542 a, 543 array.array(self.typecode, self.example[::-1]+2*self.example) 544 ) 545 a = array.array(self.typecode, self.example) 546 a += a 547 self.assertEqual( 548 a, 549 array.array(self.typecode, self.example + self.example) 550 ) 551 552 b = array.array(self.badtypecode()) 553 self.assertRaises(TypeError, a.__add__, b) 554 555 self.assertRaises(TypeError, a.__iadd__, "bad") 556 557 def test_mul(self): 558 a = 5*array.array(self.typecode, self.example) 559 self.assertEqual( 560 a, 561 array.array(self.typecode, 5*self.example) 562 ) 563 564 a = array.array(self.typecode, self.example)*5 565 self.assertEqual( 566 a, 567 array.array(self.typecode, self.example*5) 568 ) 569 570 a = 0*array.array(self.typecode, self.example) 571 self.assertEqual( 572 a, 573 array.array(self.typecode) 574 ) 575 576 a = (-1)*array.array(self.typecode, self.example) 577 self.assertEqual( 578 a, 579 array.array(self.typecode) 580 ) 581 582 a = 5 * array.array(self.typecode, self.example[:1]) 583 self.assertEqual( 584 a, 585 array.array(self.typecode, [a[0]] * 5) 586 ) 587 588 self.assertRaises(TypeError, a.__mul__, "bad") 589 590 def test_imul(self): 591 a = array.array(self.typecode, self.example) 592 b = a 593 594 a *= 5 595 self.assertIs(a, b) 596 self.assertEqual( 597 a, 598 array.array(self.typecode, 5*self.example) 599 ) 600 601 a *= 0 602 self.assertIs(a, b) 603 self.assertEqual(a, array.array(self.typecode)) 604 605 a *= 1000 606 self.assertIs(a, b) 607 self.assertEqual(a, array.array(self.typecode)) 608 609 a *= -1 610 self.assertIs(a, b) 611 self.assertEqual(a, array.array(self.typecode)) 612 613 a = array.array(self.typecode, self.example) 614 a *= -1 615 self.assertEqual(a, array.array(self.typecode)) 616 617 self.assertRaises(TypeError, a.__imul__, "bad") 618 619 def test_getitem(self): 620 a = array.array(self.typecode, self.example) 621 self.assertEntryEqual(a[0], self.example[0]) 622 self.assertEntryEqual(a[0], self.example[0]) 623 self.assertEntryEqual(a[-1], self.example[-1]) 624 self.assertEntryEqual(a[-1], self.example[-1]) 625 self.assertEntryEqual(a[len(self.example)-1], self.example[-1]) 626 self.assertEntryEqual(a[-len(self.example)], self.example[0]) 627 self.assertRaises(TypeError, a.__getitem__) 628 self.assertRaises(IndexError, a.__getitem__, len(self.example)) 629 self.assertRaises(IndexError, a.__getitem__, -len(self.example)-1) 630 631 def test_setitem(self): 632 a = array.array(self.typecode, self.example) 633 a[0] = a[-1] 634 self.assertEntryEqual(a[0], a[-1]) 635 636 a = array.array(self.typecode, self.example) 637 a[0] = a[-1] 638 self.assertEntryEqual(a[0], a[-1]) 639 640 a = array.array(self.typecode, self.example) 641 a[-1] = a[0] 642 self.assertEntryEqual(a[0], a[-1]) 643 644 a = array.array(self.typecode, self.example) 645 a[-1] = a[0] 646 self.assertEntryEqual(a[0], a[-1]) 647 648 a = array.array(self.typecode, self.example) 649 a[len(self.example)-1] = a[0] 650 self.assertEntryEqual(a[0], a[-1]) 651 652 a = array.array(self.typecode, self.example) 653 a[-len(self.example)] = a[-1] 654 self.assertEntryEqual(a[0], a[-1]) 655 656 self.assertRaises(TypeError, a.__setitem__) 657 self.assertRaises(TypeError, a.__setitem__, None) 658 self.assertRaises(TypeError, a.__setitem__, 0, None) 659 self.assertRaises( 660 IndexError, 661 a.__setitem__, 662 len(self.example), self.example[0] 663 ) 664 self.assertRaises( 665 IndexError, 666 a.__setitem__, 667 -len(self.example)-1, self.example[0] 668 ) 669 670 def test_delitem(self): 671 a = array.array(self.typecode, self.example) 672 del a[0] 673 self.assertEqual( 674 a, 675 array.array(self.typecode, self.example[1:]) 676 ) 677 678 a = array.array(self.typecode, self.example) 679 del a[-1] 680 self.assertEqual( 681 a, 682 array.array(self.typecode, self.example[:-1]) 683 ) 684 685 a = array.array(self.typecode, self.example) 686 del a[len(self.example)-1] 687 self.assertEqual( 688 a, 689 array.array(self.typecode, self.example[:-1]) 690 ) 691 692 a = array.array(self.typecode, self.example) 693 del a[-len(self.example)] 694 self.assertEqual( 695 a, 696 array.array(self.typecode, self.example[1:]) 697 ) 698 699 self.assertRaises(TypeError, a.__delitem__) 700 self.assertRaises(TypeError, a.__delitem__, None) 701 self.assertRaises(IndexError, a.__delitem__, len(self.example)) 702 self.assertRaises(IndexError, a.__delitem__, -len(self.example)-1) 703 704 def test_getslice(self): 705 a = array.array(self.typecode, self.example) 706 self.assertEqual(a[:], a) 707 708 self.assertEqual( 709 a[1:], 710 array.array(self.typecode, self.example[1:]) 711 ) 712 713 self.assertEqual( 714 a[:1], 715 array.array(self.typecode, self.example[:1]) 716 ) 717 718 self.assertEqual( 719 a[:-1], 720 array.array(self.typecode, self.example[:-1]) 721 ) 722 723 self.assertEqual( 724 a[-1:], 725 array.array(self.typecode, self.example[-1:]) 726 ) 727 728 self.assertEqual( 729 a[-1:-1], 730 array.array(self.typecode) 731 ) 732 733 self.assertEqual( 734 a[2:1], 735 array.array(self.typecode) 736 ) 737 738 self.assertEqual( 739 a[1000:], 740 array.array(self.typecode) 741 ) 742 self.assertEqual(a[-1000:], a) 743 self.assertEqual(a[:1000], a) 744 self.assertEqual( 745 a[:-1000], 746 array.array(self.typecode) 747 ) 748 self.assertEqual(a[-1000:1000], a) 749 self.assertEqual( 750 a[2000:1000], 751 array.array(self.typecode) 752 ) 753 754 def test_extended_getslice(self): 755 # Test extended slicing by comparing with list slicing 756 # (Assumes list conversion works correctly, too) 757 a = array.array(self.typecode, self.example) 758 indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100) 759 for start in indices: 760 for stop in indices: 761 # Everything except the initial 0 (invalid step) 762 for step in indices[1:]: 763 self.assertEqual(list(a[start:stop:step]), 764 list(a)[start:stop:step]) 765 766 def test_setslice(self): 767 a = array.array(self.typecode, self.example) 768 a[:1] = a 769 self.assertEqual( 770 a, 771 array.array(self.typecode, self.example + self.example[1:]) 772 ) 773 774 a = array.array(self.typecode, self.example) 775 a[:-1] = a 776 self.assertEqual( 777 a, 778 array.array(self.typecode, self.example + self.example[-1:]) 779 ) 780 781 a = array.array(self.typecode, self.example) 782 a[-1:] = a 783 self.assertEqual( 784 a, 785 array.array(self.typecode, self.example[:-1] + self.example) 786 ) 787 788 a = array.array(self.typecode, self.example) 789 a[1:] = a 790 self.assertEqual( 791 a, 792 array.array(self.typecode, self.example[:1] + self.example) 793 ) 794 795 a = array.array(self.typecode, self.example) 796 a[1:-1] = a 797 self.assertEqual( 798 a, 799 array.array( 800 self.typecode, 801 self.example[:1] + self.example + self.example[-1:] 802 ) 803 ) 804 805 a = array.array(self.typecode, self.example) 806 a[1000:] = a 807 self.assertEqual( 808 a, 809 array.array(self.typecode, 2*self.example) 810 ) 811 812 a = array.array(self.typecode, self.example) 813 a[-1000:] = a 814 self.assertEqual( 815 a, 816 array.array(self.typecode, self.example) 817 ) 818 819 a = array.array(self.typecode, self.example) 820 a[:1000] = a 821 self.assertEqual( 822 a, 823 array.array(self.typecode, self.example) 824 ) 825 826 a = array.array(self.typecode, self.example) 827 a[:-1000] = a 828 self.assertEqual( 829 a, 830 array.array(self.typecode, 2*self.example) 831 ) 832 833 a = array.array(self.typecode, self.example) 834 a[1:0] = a 835 self.assertEqual( 836 a, 837 array.array(self.typecode, self.example[:1] + self.example + self.example[1:]) 838 ) 839 840 a = array.array(self.typecode, self.example) 841 a[2000:1000] = a 842 self.assertEqual( 843 a, 844 array.array(self.typecode, 2*self.example) 845 ) 846 847 a = array.array(self.typecode, self.example) 848 self.assertRaises(TypeError, a.__setitem__, slice(0, 0), None) 849 self.assertRaises(TypeError, a.__setitem__, slice(0, 1), None) 850 851 b = array.array(self.badtypecode()) 852 self.assertRaises(TypeError, a.__setitem__, slice(0, 0), b) 853 self.assertRaises(TypeError, a.__setitem__, slice(0, 1), b) 854 855 def test_extended_set_del_slice(self): 856 indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100) 857 for start in indices: 858 for stop in indices: 859 # Everything except the initial 0 (invalid step) 860 for step in indices[1:]: 861 a = array.array(self.typecode, self.example) 862 L = list(a) 863 # Make sure we have a slice of exactly the right length, 864 # but with (hopefully) different data. 865 data = L[start:stop:step] 866 data.reverse() 867 L[start:stop:step] = data 868 a[start:stop:step] = array.array(self.typecode, data) 869 self.assertEqual(a, array.array(self.typecode, L)) 870 871 del L[start:stop:step] 872 del a[start:stop:step] 873 self.assertEqual(a, array.array(self.typecode, L)) 874 875 def test_index(self): 876 example = 2*self.example 877 a = array.array(self.typecode, example) 878 self.assertRaises(TypeError, a.index) 879 for x in example: 880 self.assertEqual(a.index(x), example.index(x)) 881 self.assertRaises(ValueError, a.index, None) 882 self.assertRaises(ValueError, a.index, self.outside) 883 884 def test_count(self): 885 example = 2*self.example 886 a = array.array(self.typecode, example) 887 self.assertRaises(TypeError, a.count) 888 for x in example: 889 self.assertEqual(a.count(x), example.count(x)) 890 self.assertEqual(a.count(self.outside), 0) 891 self.assertEqual(a.count(None), 0) 892 893 def test_remove(self): 894 for x in self.example: 895 example = 2*self.example 896 a = array.array(self.typecode, example) 897 pos = example.index(x) 898 example2 = example[:pos] + example[pos+1:] 899 a.remove(x) 900 self.assertEqual(a, array.array(self.typecode, example2)) 901 902 a = array.array(self.typecode, self.example) 903 self.assertRaises(ValueError, a.remove, self.outside) 904 905 self.assertRaises(ValueError, a.remove, None) 906 907 def test_pop(self): 908 a = array.array(self.typecode) 909 self.assertRaises(IndexError, a.pop) 910 911 a = array.array(self.typecode, 2*self.example) 912 self.assertRaises(TypeError, a.pop, 42, 42) 913 self.assertRaises(TypeError, a.pop, None) 914 self.assertRaises(IndexError, a.pop, len(a)) 915 self.assertRaises(IndexError, a.pop, -len(a)-1) 916 917 self.assertEntryEqual(a.pop(0), self.example[0]) 918 self.assertEqual( 919 a, 920 array.array(self.typecode, self.example[1:]+self.example) 921 ) 922 self.assertEntryEqual(a.pop(1), self.example[2]) 923 self.assertEqual( 924 a, 925 array.array(self.typecode, self.example[1:2]+self.example[3:]+self.example) 926 ) 927 self.assertEntryEqual(a.pop(0), self.example[1]) 928 self.assertEntryEqual(a.pop(), self.example[-1]) 929 self.assertEqual( 930 a, 931 array.array(self.typecode, self.example[3:]+self.example[:-1]) 932 ) 933 934 def test_reverse(self): 935 a = array.array(self.typecode, self.example) 936 self.assertRaises(TypeError, a.reverse, 42) 937 a.reverse() 938 self.assertEqual( 939 a, 940 array.array(self.typecode, self.example[::-1]) 941 ) 942 943 def test_extend(self): 944 a = array.array(self.typecode, self.example) 945 self.assertRaises(TypeError, a.extend) 946 a.extend(array.array(self.typecode, self.example[::-1])) 947 self.assertEqual( 948 a, 949 array.array(self.typecode, self.example+self.example[::-1]) 950 ) 951 952 a = array.array(self.typecode, self.example) 953 a.extend(a) 954 self.assertEqual( 955 a, 956 array.array(self.typecode, self.example+self.example) 957 ) 958 959 b = array.array(self.badtypecode()) 960 self.assertRaises(TypeError, a.extend, b) 961 962 a = array.array(self.typecode, self.example) 963 a.extend(self.example[::-1]) 964 self.assertEqual( 965 a, 966 array.array(self.typecode, self.example+self.example[::-1]) 967 ) 968 969 def test_constructor_with_iterable_argument(self): 970 a = array.array(self.typecode, iter(self.example)) 971 b = array.array(self.typecode, self.example) 972 self.assertEqual(a, b) 973 974 # non-iterable argument 975 self.assertRaises(TypeError, array.array, self.typecode, 10) 976 977 # pass through errors raised in __iter__ 978 class A: 979 def __iter__(self): 980 raise UnicodeError 981 self.assertRaises(UnicodeError, array.array, self.typecode, A()) 982 983 # pass through errors raised in next() 984 def B(): 985 raise UnicodeError 986 yield None 987 self.assertRaises(UnicodeError, array.array, self.typecode, B()) 988 989 def test_coveritertraverse(self): 990 try: 991 import gc 992 except ImportError: 993 self.skipTest('gc module not available') 994 a = array.array(self.typecode) 995 l = [iter(a)] 996 l.append(l) 997 gc.collect() 998 999 def test_buffer(self): 1000 a = array.array(self.typecode, self.example) 1001 m = memoryview(a) 1002 expected = m.tobytes() 1003 self.assertEqual(a.tobytes(), expected) 1004 self.assertEqual(a.tobytes()[0], expected[0]) 1005 # Resizing is forbidden when there are buffer exports. 1006 # For issue 4509, we also check after each error that 1007 # the array was not modified. 1008 self.assertRaises(BufferError, a.append, a[0]) 1009 self.assertEqual(m.tobytes(), expected) 1010 self.assertRaises(BufferError, a.extend, a[0:1]) 1011 self.assertEqual(m.tobytes(), expected) 1012 self.assertRaises(BufferError, a.remove, a[0]) 1013 self.assertEqual(m.tobytes(), expected) 1014 self.assertRaises(BufferError, a.pop, 0) 1015 self.assertEqual(m.tobytes(), expected) 1016 self.assertRaises(BufferError, a.fromlist, a.tolist()) 1017 self.assertEqual(m.tobytes(), expected) 1018 self.assertRaises(BufferError, a.frombytes, a.tobytes()) 1019 self.assertEqual(m.tobytes(), expected) 1020 if self.typecode == 'u': 1021 self.assertRaises(BufferError, a.fromunicode, a.tounicode()) 1022 self.assertEqual(m.tobytes(), expected) 1023 self.assertRaises(BufferError, operator.imul, a, 2) 1024 self.assertEqual(m.tobytes(), expected) 1025 self.assertRaises(BufferError, operator.imul, a, 0) 1026 self.assertEqual(m.tobytes(), expected) 1027 self.assertRaises(BufferError, operator.setitem, a, slice(0, 0), a) 1028 self.assertEqual(m.tobytes(), expected) 1029 self.assertRaises(BufferError, operator.delitem, a, 0) 1030 self.assertEqual(m.tobytes(), expected) 1031 self.assertRaises(BufferError, operator.delitem, a, slice(0, 1)) 1032 self.assertEqual(m.tobytes(), expected) 1033 1034 def test_weakref(self): 1035 s = array.array(self.typecode, self.example) 1036 p = weakref.proxy(s) 1037 self.assertEqual(p.tobytes(), s.tobytes()) 1038 s = None 1039 self.assertRaises(ReferenceError, len, p) 1040 1041 @unittest.skipUnless(hasattr(sys, 'getrefcount'), 1042 'test needs sys.getrefcount()') 1043 def test_bug_782369(self): 1044 for i in range(10): 1045 b = array.array('B', range(64)) 1046 rc = sys.getrefcount(10) 1047 for i in range(10): 1048 b = array.array('B', range(64)) 1049 self.assertEqual(rc, sys.getrefcount(10)) 1050 1051 def test_subclass_with_kwargs(self): 1052 # SF bug #1486663 -- this used to erroneously raise a TypeError 1053 ArraySubclassWithKwargs('b', newarg=1) 1054 1055 def test_create_from_bytes(self): 1056 # XXX This test probably needs to be moved in a subclass or 1057 # generalized to use self.typecode. 1058 a = array.array('H', b"1234") 1059 self.assertEqual(len(a) * a.itemsize, 4) 1060 1061 @support.cpython_only 1062 def test_sizeof_with_buffer(self): 1063 a = array.array(self.typecode, self.example) 1064 basesize = support.calcvobjsize('Pn2Pi') 1065 buffer_size = a.buffer_info()[1] * a.itemsize 1066 support.check_sizeof(self, a, basesize + buffer_size) 1067 1068 @support.cpython_only 1069 def test_sizeof_without_buffer(self): 1070 a = array.array(self.typecode) 1071 basesize = support.calcvobjsize('Pn2Pi') 1072 support.check_sizeof(self, a, basesize) 1073 1074 def test_initialize_with_unicode(self): 1075 if self.typecode != 'u': 1076 with self.assertRaises(TypeError) as cm: 1077 a = array.array(self.typecode, 'foo') 1078 self.assertIn("cannot use a str", str(cm.exception)) 1079 with self.assertRaises(TypeError) as cm: 1080 a = array.array(self.typecode, array.array('u', 'foo')) 1081 self.assertIn("cannot use a unicode array", str(cm.exception)) 1082 else: 1083 a = array.array(self.typecode, "foo") 1084 a = array.array(self.typecode, array.array('u', 'foo')) 1085 1086 @support.cpython_only 1087 def test_obsolete_write_lock(self): 1088 from _testcapi import getbuffer_with_null_view 1089 a = array.array('B', b"") 1090 self.assertRaises(BufferError, getbuffer_with_null_view, a) 1091 1092 def test_free_after_iterating(self): 1093 support.check_free_after_iterating(self, iter, array.array, 1094 (self.typecode,)) 1095 support.check_free_after_iterating(self, reversed, array.array, 1096 (self.typecode,)) 1097 1098 class StringTest(BaseTest): 1099 1100 def test_setitem(self): 1101 super().test_setitem() 1102 a = array.array(self.typecode, self.example) 1103 self.assertRaises(TypeError, a.__setitem__, 0, self.example[:2]) 1104 1105 class UnicodeTest(StringTest, unittest.TestCase): 1106 typecode = 'u' 1107 example = '\x01\u263a\x00\ufeff' 1108 smallerexample = '\x01\u263a\x00\ufefe' 1109 biggerexample = '\x01\u263a\x01\ufeff' 1110 outside = str('\x33') 1111 minitemsize = 2 1112 1113 def test_unicode(self): 1114 self.assertRaises(TypeError, array.array, 'b', 'foo') 1115 1116 a = array.array('u', '\xa0\xc2\u1234') 1117 a.fromunicode(' ') 1118 a.fromunicode('') 1119 a.fromunicode('') 1120 a.fromunicode('\x11abc\xff\u1234') 1121 s = a.tounicode() 1122 self.assertEqual(s, '\xa0\xc2\u1234 \x11abc\xff\u1234') 1123 self.assertEqual(a.itemsize, sizeof_wchar) 1124 1125 s = '\x00="\'a\\b\x80\xff\u0000\u0001\u1234' 1126 a = array.array('u', s) 1127 self.assertEqual( 1128 repr(a), 1129 "array('u', '\\x00=\"\\'a\\\\b\\x80\xff\\x00\\x01\u1234')") 1130 1131 self.assertRaises(TypeError, a.fromunicode) 1132 1133 def test_issue17223(self): 1134 # this used to crash 1135 if sizeof_wchar == 4: 1136 # U+FFFFFFFF is an invalid code point in Unicode 6.0 1137 invalid_str = b'\xff\xff\xff\xff' 1138 else: 1139 # PyUnicode_FromUnicode() cannot fail with 16-bit wchar_t 1140 self.skipTest("specific to 32-bit wchar_t") 1141 a = array.array('u', invalid_str) 1142 self.assertRaises(ValueError, a.tounicode) 1143 self.assertRaises(ValueError, str, a) 1144 1145 class NumberTest(BaseTest): 1146 1147 def test_extslice(self): 1148 a = array.array(self.typecode, range(5)) 1149 self.assertEqual(a[::], a) 1150 self.assertEqual(a[::2], array.array(self.typecode, [0,2,4])) 1151 self.assertEqual(a[1::2], array.array(self.typecode, [1,3])) 1152 self.assertEqual(a[::-1], array.array(self.typecode, [4,3,2,1,0])) 1153 self.assertEqual(a[::-2], array.array(self.typecode, [4,2,0])) 1154 self.assertEqual(a[3::-2], array.array(self.typecode, [3,1])) 1155 self.assertEqual(a[-100:100:], a) 1156 self.assertEqual(a[100:-100:-1], a[::-1]) 1157 self.assertEqual(a[-100:100:2], array.array(self.typecode, [0,2,4])) 1158 self.assertEqual(a[1000:2000:2], array.array(self.typecode, [])) 1159 self.assertEqual(a[-1000:-2000:-2], array.array(self.typecode, [])) 1160 1161 def test_delslice(self): 1162 a = array.array(self.typecode, range(5)) 1163 del a[::2] 1164 self.assertEqual(a, array.array(self.typecode, [1,3])) 1165 a = array.array(self.typecode, range(5)) 1166 del a[1::2] 1167 self.assertEqual(a, array.array(self.typecode, [0,2,4])) 1168 a = array.array(self.typecode, range(5)) 1169 del a[1::-2] 1170 self.assertEqual(a, array.array(self.typecode, [0,2,3,4])) 1171 a = array.array(self.typecode, range(10)) 1172 del a[::1000] 1173 self.assertEqual(a, array.array(self.typecode, [1,2,3,4,5,6,7,8,9])) 1174 # test issue7788 1175 a = array.array(self.typecode, range(10)) 1176 del a[9::1<<333] 1177 1178 def test_assignment(self): 1179 a = array.array(self.typecode, range(10)) 1180 a[::2] = array.array(self.typecode, [42]*5) 1181 self.assertEqual(a, array.array(self.typecode, [42, 1, 42, 3, 42, 5, 42, 7, 42, 9])) 1182 a = array.array(self.typecode, range(10)) 1183 a[::-4] = array.array(self.typecode, [10]*3) 1184 self.assertEqual(a, array.array(self.typecode, [0, 10, 2, 3, 4, 10, 6, 7, 8 ,10])) 1185 a = array.array(self.typecode, range(4)) 1186 a[::-1] = a 1187 self.assertEqual(a, array.array(self.typecode, [3, 2, 1, 0])) 1188 a = array.array(self.typecode, range(10)) 1189 b = a[:] 1190 c = a[:] 1191 ins = array.array(self.typecode, range(2)) 1192 a[2:3] = ins 1193 b[slice(2,3)] = ins 1194 c[2:3:] = ins 1195 1196 def test_iterationcontains(self): 1197 a = array.array(self.typecode, range(10)) 1198 self.assertEqual(list(a), list(range(10))) 1199 b = array.array(self.typecode, [20]) 1200 self.assertEqual(a[-1] in a, True) 1201 self.assertEqual(b[0] not in a, True) 1202 1203 def check_overflow(self, lower, upper): 1204 # method to be used by subclasses 1205 1206 # should not overflow assigning lower limit 1207 a = array.array(self.typecode, [lower]) 1208 a[0] = lower 1209 # should overflow assigning less than lower limit 1210 self.assertRaises(OverflowError, array.array, self.typecode, [lower-1]) 1211 self.assertRaises(OverflowError, a.__setitem__, 0, lower-1) 1212 # should not overflow assigning upper limit 1213 a = array.array(self.typecode, [upper]) 1214 a[0] = upper 1215 # should overflow assigning more than upper limit 1216 self.assertRaises(OverflowError, array.array, self.typecode, [upper+1]) 1217 self.assertRaises(OverflowError, a.__setitem__, 0, upper+1) 1218 1219 def test_subclassing(self): 1220 typecode = self.typecode 1221 class ExaggeratingArray(array.array): 1222 __slots__ = ['offset'] 1223 1224 def __new__(cls, typecode, data, offset): 1225 return array.array.__new__(cls, typecode, data) 1226 1227 def __init__(self, typecode, data, offset): 1228 self.offset = offset 1229 1230 def __getitem__(self, i): 1231 return array.array.__getitem__(self, i) + self.offset 1232 1233 a = ExaggeratingArray(self.typecode, [3, 6, 7, 11], 4) 1234 self.assertEntryEqual(a[0], 7) 1235 1236 self.assertRaises(AttributeError, setattr, a, "color", "blue") 1237 1238 def test_frombytearray(self): 1239 a = array.array('b', range(10)) 1240 b = array.array(self.typecode, a) 1241 self.assertEqual(a, b) 1242 1243 class SignedNumberTest(NumberTest): 1244 example = [-1, 0, 1, 42, 0x7f] 1245 smallerexample = [-1, 0, 1, 42, 0x7e] 1246 biggerexample = [-1, 0, 1, 43, 0x7f] 1247 outside = 23 1248 1249 def test_overflow(self): 1250 a = array.array(self.typecode) 1251 lower = -1 * int(pow(2, a.itemsize * 8 - 1)) 1252 upper = int(pow(2, a.itemsize * 8 - 1)) - 1 1253 self.check_overflow(lower, upper) 1254 1255 class UnsignedNumberTest(NumberTest): 1256 example = [0, 1, 17, 23, 42, 0xff] 1257 smallerexample = [0, 1, 17, 23, 42, 0xfe] 1258 biggerexample = [0, 1, 17, 23, 43, 0xff] 1259 outside = 0xaa 1260 1261 def test_overflow(self): 1262 a = array.array(self.typecode) 1263 lower = 0 1264 upper = int(pow(2, a.itemsize * 8)) - 1 1265 self.check_overflow(lower, upper) 1266 1267 def test_bytes_extend(self): 1268 s = bytes(self.example) 1269 1270 a = array.array(self.typecode, self.example) 1271 a.extend(s) 1272 self.assertEqual( 1273 a, 1274 array.array(self.typecode, self.example+self.example) 1275 ) 1276 1277 a = array.array(self.typecode, self.example) 1278 a.extend(bytearray(reversed(s))) 1279 self.assertEqual( 1280 a, 1281 array.array(self.typecode, self.example+self.example[::-1]) 1282 ) 1283 1284 1285 class ByteTest(SignedNumberTest, unittest.TestCase): 1286 typecode = 'b' 1287 minitemsize = 1 1288 1289 class UnsignedByteTest(UnsignedNumberTest, unittest.TestCase): 1290 typecode = 'B' 1291 minitemsize = 1 1292 1293 class ShortTest(SignedNumberTest, unittest.TestCase): 1294 typecode = 'h' 1295 minitemsize = 2 1296 1297 class UnsignedShortTest(UnsignedNumberTest, unittest.TestCase): 1298 typecode = 'H' 1299 minitemsize = 2 1300 1301 class IntTest(SignedNumberTest, unittest.TestCase): 1302 typecode = 'i' 1303 minitemsize = 2 1304 1305 class UnsignedIntTest(UnsignedNumberTest, unittest.TestCase): 1306 typecode = 'I' 1307 minitemsize = 2 1308 1309 class LongTest(SignedNumberTest, unittest.TestCase): 1310 typecode = 'l' 1311 minitemsize = 4 1312 1313 class UnsignedLongTest(UnsignedNumberTest, unittest.TestCase): 1314 typecode = 'L' 1315 minitemsize = 4 1316 1317 @unittest.skipIf(not have_long_long, 'need long long support') 1318 class LongLongTest(SignedNumberTest, unittest.TestCase): 1319 typecode = 'q' 1320 minitemsize = 8 1321 1322 @unittest.skipIf(not have_long_long, 'need long long support') 1323 class UnsignedLongLongTest(UnsignedNumberTest, unittest.TestCase): 1324 typecode = 'Q' 1325 minitemsize = 8 1326 1327 class FPTest(NumberTest): 1328 example = [-42.0, 0, 42, 1e5, -1e10] 1329 smallerexample = [-42.0, 0, 42, 1e5, -2e10] 1330 biggerexample = [-42.0, 0, 42, 1e5, 1e10] 1331 outside = 23 1332 1333 def assertEntryEqual(self, entry1, entry2): 1334 self.assertAlmostEqual(entry1, entry2) 1335 1336 def test_byteswap(self): 1337 a = array.array(self.typecode, self.example) 1338 self.assertRaises(TypeError, a.byteswap, 42) 1339 if a.itemsize in (1, 2, 4, 8): 1340 b = array.array(self.typecode, self.example) 1341 b.byteswap() 1342 if a.itemsize==1: 1343 self.assertEqual(a, b) 1344 else: 1345 # On alphas treating the byte swapped bit patters as 1346 # floats/doubles results in floating point exceptions 1347 # => compare the 8bit string values instead 1348 self.assertNotEqual(a.tobytes(), b.tobytes()) 1349 b.byteswap() 1350 self.assertEqual(a, b) 1351 1352 class FloatTest(FPTest, unittest.TestCase): 1353 typecode = 'f' 1354 minitemsize = 4 1355 1356 class DoubleTest(FPTest, unittest.TestCase): 1357 typecode = 'd' 1358 minitemsize = 8 1359 1360 def test_alloc_overflow(self): 1361 from sys import maxsize 1362 a = array.array('d', [-1]*65536) 1363 try: 1364 a *= maxsize//65536 + 1 1365 except MemoryError: 1366 pass 1367 else: 1368 self.fail("Array of size > maxsize created - MemoryError expected") 1369 b = array.array('d', [ 2.71828183, 3.14159265, -1]) 1370 try: 1371 b * (maxsize//3 + 1) 1372 except MemoryError: 1373 pass 1374 else: 1375 self.fail("Array of size > maxsize created - MemoryError expected") 1376 1377 1378 if __name__ == "__main__": 1379 unittest.main() 1380
