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