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