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