← Back to branch summary

~ubuntu-branches/ubuntu/maverick/python3.1/maverick

« back to all changes in this revision

Viewing changes to Lib/test/test_array.py

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-03-23 00:01:27 UTC
  • Revision ID: james.westby@ubuntu.com-20090323000127-5fstfxju4ufrhthq
Tags: upstream-3.1~a1+20090322
Import upstream version 3.1~a1+20090322

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/test/test_array.py
 
1
#! /usr/bin/env python
 
2
"""Test the arraymodule.
 
3
   Roger E. Masse
 
4
"""
 
5
 
 
6
import unittest
 
7
from test import support
 
8
from weakref import proxy
 
9
import array, io, math
 
10
from pickle import loads, dumps, HIGHEST_PROTOCOL
 
11
import operator
 
12
 
 
13
class ArraySubclass(array.array):
 
14
    pass
 
15
 
 
16
class ArraySubclassWithKwargs(array.array):
 
17
    def __init__(self, typecode, newarg=None):
 
18
        array.array.__init__(typecode)
 
19
 
 
20
tests = [] # list to accumulate all tests
 
21
typecodes = "ubBhHiIlLfd"
 
22
 
 
23
class BadConstructorTest(unittest.TestCase):
 
24
 
 
25
    def test_constructor(self):
 
26
        self.assertRaises(TypeError, array.array)
 
27
        self.assertRaises(TypeError, array.array, spam=42)
 
28
        self.assertRaises(TypeError, array.array, 'xx')
 
29
        self.assertRaises(ValueError, array.array, 'x')
 
30
 
 
31
tests.append(BadConstructorTest)
 
32
 
 
33
class BaseTest(unittest.TestCase):
 
34
    # Required class attributes (provided by subclasses
 
35
    # typecode: the typecode to test
 
36
    # example: an initializer usable in the constructor for this type
 
37
    # smallerexample: the same length as example, but smaller
 
38
    # biggerexample: the same length as example, but bigger
 
39
    # outside: An entry that is not in example
 
40
    # minitemsize: the minimum guaranteed itemsize
 
41
 
 
42
    def assertEntryEqual(self, entry1, entry2):
 
43
        self.assertEqual(entry1, entry2)
 
44
 
 
45
    def badtypecode(self):
 
46
        # Return a typecode that is different from our own
 
47
        return typecodes[(typecodes.index(self.typecode)+1) % len(typecodes)]
 
48
 
 
49
    def test_constructor(self):
 
50
        a = array.array(self.typecode)
 
51
        self.assertEqual(a.typecode, self.typecode)
 
52
        self.assert_(a.itemsize>=self.minitemsize)
 
53
        self.assertRaises(TypeError, array.array, self.typecode, None)
 
54
 
 
55
    def test_len(self):
 
56
        a = array.array(self.typecode)
 
57
        a.append(self.example[0])
 
58
        self.assertEqual(len(a), 1)
 
59
 
 
60
        a = array.array(self.typecode, self.example)
 
61
        self.assertEqual(len(a), len(self.example))
 
62
 
 
63
    def test_buffer_info(self):
 
64
        a = array.array(self.typecode, self.example)
 
65
        self.assertRaises(TypeError, a.buffer_info, 42)
 
66
        bi = a.buffer_info()
 
67
        self.assert_(isinstance(bi, tuple))
 
68
        self.assertEqual(len(bi), 2)
 
69
        self.assert_(isinstance(bi[0], int))
 
70
        self.assert_(isinstance(bi[1], int))
 
71
        self.assertEqual(bi[1], len(a))
 
72
 
 
73
    def test_byteswap(self):
 
74
        a = array.array(self.typecode, self.example)
 
75
        self.assertRaises(TypeError, a.byteswap, 42)
 
76
        if a.itemsize in (1, 2, 4, 8):
 
77
            b = array.array(self.typecode, self.example)
 
78
            b.byteswap()
 
79
            if a.itemsize==1:
 
80
                self.assertEqual(a, b)
 
81
            else:
 
82
                self.assertNotEqual(a, b)
 
83
            b.byteswap()
 
84
            self.assertEqual(a, b)
 
85
 
 
86
    def test_copy(self):
 
87
        import copy
 
88
        a = array.array(self.typecode, self.example)
 
89
        b = copy.copy(a)
 
90
        self.assertNotEqual(id(a), id(b))
 
91
        self.assertEqual(a, b)
 
92
 
 
93
    def test_deepcopy(self):
 
94
        import copy
 
95
        a = array.array(self.typecode, self.example)
 
96
        b = copy.deepcopy(a)
 
97
        self.assertNotEqual(id(a), id(b))
 
98
        self.assertEqual(a, b)
 
99
 
 
100
    def test_pickle(self):
 
101
        for protocol in range(HIGHEST_PROTOCOL + 1):
 
102
            a = array.array(self.typecode, self.example)
 
103
            b = loads(dumps(a, protocol))
 
104
            self.assertNotEqual(id(a), id(b))
 
105
            self.assertEqual(a, b)
 
106
 
 
107
            a = ArraySubclass(self.typecode, self.example)
 
108
            a.x = 10
 
109
            b = loads(dumps(a, protocol))
 
110
            self.assertNotEqual(id(a), id(b))
 
111
            self.assertEqual(a, b)
 
112
            self.assertEqual(a.x, b.x)
 
113
            self.assertEqual(type(a), type(b))
 
114
 
 
115
    def test_pickle_for_empty_array(self):
 
116
        for protocol in range(HIGHEST_PROTOCOL + 1):
 
117
            a = array.array(self.typecode)
 
118
            b = loads(dumps(a, protocol))
 
119
            self.assertNotEqual(id(a), id(b))
 
120
            self.assertEqual(a, b)
 
121
 
 
122
            a = ArraySubclass(self.typecode)
 
123
            a.x = 10
 
124
            b = loads(dumps(a, protocol))
 
125
            self.assertNotEqual(id(a), id(b))
 
126
            self.assertEqual(a, b)
 
127
            self.assertEqual(a.x, b.x)
 
128
            self.assertEqual(type(a), type(b))
 
129
 
 
130
    def test_insert(self):
 
131
        a = array.array(self.typecode, self.example)
 
132
        a.insert(0, self.example[0])
 
133
        self.assertEqual(len(a), 1+len(self.example))
 
134
        self.assertEqual(a[0], a[1])
 
135
        self.assertRaises(TypeError, a.insert)
 
136
        self.assertRaises(TypeError, a.insert, None)
 
137
        self.assertRaises(TypeError, a.insert, 0, None)
 
138
 
 
139
        a = array.array(self.typecode, self.example)
 
140
        a.insert(-1, self.example[0])
 
141
        self.assertEqual(
 
142
            a,
 
143
            array.array(
 
144
                self.typecode,
 
145
                self.example[:-1] + self.example[:1] + self.example[-1:]
 
146
            )
 
147
        )
 
148
 
 
149
        a = array.array(self.typecode, self.example)
 
150
        a.insert(-1000, self.example[0])
 
151
        self.assertEqual(
 
152
            a,
 
153
            array.array(self.typecode, self.example[:1] + self.example)
 
154
        )
 
155
 
 
156
        a = array.array(self.typecode, self.example)
 
157
        a.insert(1000, self.example[0])
 
158
        self.assertEqual(
 
159
            a,
 
160
            array.array(self.typecode, self.example + self.example[:1])
 
161
        )
 
162
 
 
163
    def test_tofromfile(self):
 
164
        a = array.array(self.typecode, 2*self.example)
 
165
        self.assertRaises(TypeError, a.tofile)
 
166
        support.unlink(support.TESTFN)
 
167
        f = open(support.TESTFN, 'wb')
 
168
        try:
 
169
            a.tofile(f)
 
170
            f.close()
 
171
            b = array.array(self.typecode)
 
172
            f = open(support.TESTFN, 'rb')
 
173
            self.assertRaises(TypeError, b.fromfile)
 
174
            b.fromfile(f, len(self.example))
 
175
            self.assertEqual(b, array.array(self.typecode, self.example))
 
176
            self.assertNotEqual(a, b)
 
177
            self.assertRaises(EOFError, b.fromfile, f, len(self.example)+1)
 
178
            self.assertEqual(a, b)
 
179
            f.close()
 
180
        finally:
 
181
            if not f.closed:
 
182
                f.close()
 
183
            support.unlink(support.TESTFN)
 
184
 
 
185
    def test_tofromlist(self):
 
186
        a = array.array(self.typecode, 2*self.example)
 
187
        b = array.array(self.typecode)
 
188
        self.assertRaises(TypeError, a.tolist, 42)
 
189
        self.assertRaises(TypeError, b.fromlist)
 
190
        self.assertRaises(TypeError, b.fromlist, 42)
 
191
        self.assertRaises(TypeError, b.fromlist, [None])
 
192
        b.fromlist(a.tolist())
 
193
        self.assertEqual(a, b)
 
194
 
 
195
    def test_tofromstring(self):
 
196
        a = array.array(self.typecode, 2*self.example)
 
197
        b = array.array(self.typecode)
 
198
        self.assertRaises(TypeError, a.tostring, 42)
 
199
        self.assertRaises(TypeError, b.fromstring)
 
200
        self.assertRaises(TypeError, b.fromstring, 42)
 
201
        b.fromstring(a.tostring())
 
202
        self.assertEqual(a, b)
 
203
        if a.itemsize>1:
 
204
            self.assertRaises(ValueError, b.fromstring, "x")
 
205
 
 
206
    def test_repr(self):
 
207
        a = array.array(self.typecode, 2*self.example)
 
208
        self.assertEqual(a, eval(repr(a), {"array": array.array}))
 
209
 
 
210
        a = array.array(self.typecode)
 
211
        self.assertEqual(repr(a), "array('%s')" % self.typecode)
 
212
 
 
213
    def test_str(self):
 
214
        a = array.array(self.typecode, 2*self.example)
 
215
        str(a)
 
216
 
 
217
    def test_cmp(self):
 
218
        a = array.array(self.typecode, self.example)
 
219
        self.assert_((a == 42) is False)
 
220
        self.assert_((a != 42) is True)
 
221
 
 
222
        self.assert_((a == a) is True)
 
223
        self.assert_((a != a) is False)
 
224
        self.assert_((a < a) is False)
 
225
        self.assert_((a <= a) is True)
 
226
        self.assert_((a > a) is False)
 
227
        self.assert_((a >= a) is True)
 
228
 
 
229
        al = array.array(self.typecode, self.smallerexample)
 
230
        ab = array.array(self.typecode, self.biggerexample)
 
231
 
 
232
        self.assert_((a == 2*a) is False)
 
233
        self.assert_((a != 2*a) is True)
 
234
        self.assert_((a < 2*a) is True)
 
235
        self.assert_((a <= 2*a) is True)
 
236
        self.assert_((a > 2*a) is False)
 
237
        self.assert_((a >= 2*a) is False)
 
238
 
 
239
        self.assert_((a == al) is False)
 
240
        self.assert_((a != al) is True)
 
241
        self.assert_((a < al) is False)
 
242
        self.assert_((a <= al) is False)
 
243
        self.assert_((a > al) is True)
 
244
        self.assert_((a >= al) is True)
 
245
 
 
246
        self.assert_((a == ab) is False)
 
247
        self.assert_((a != ab) is True)
 
248
        self.assert_((a < ab) is True)
 
249
        self.assert_((a <= ab) is True)
 
250
        self.assert_((a > ab) is False)
 
251
        self.assert_((a >= ab) is False)
 
252
 
 
253
    def test_add(self):
 
254
        a = array.array(self.typecode, self.example) \
 
255
            + array.array(self.typecode, self.example[::-1])
 
256
        self.assertEqual(
 
257
            a,
 
258
            array.array(self.typecode, self.example + self.example[::-1])
 
259
        )
 
260
 
 
261
        b = array.array(self.badtypecode())
 
262
        self.assertRaises(TypeError, a.__add__, b)
 
263
 
 
264
        self.assertRaises(TypeError, a.__add__, "bad")
 
265
 
 
266
    def test_iadd(self):
 
267
        a = array.array(self.typecode, self.example[::-1])
 
268
        b = a
 
269
        a += array.array(self.typecode, 2*self.example)
 
270
        self.assert_(a is b)
 
271
        self.assertEqual(
 
272
            a,
 
273
            array.array(self.typecode, self.example[::-1]+2*self.example)
 
274
        )
 
275
 
 
276
        b = array.array(self.badtypecode())
 
277
        self.assertRaises(TypeError, a.__add__, b)
 
278
 
 
279
        self.assertRaises(TypeError, a.__iadd__, "bad")
 
280
 
 
281
    def test_mul(self):
 
282
        a = 5*array.array(self.typecode, self.example)
 
283
        self.assertEqual(
 
284
            a,
 
285
            array.array(self.typecode, 5*self.example)
 
286
        )
 
287
 
 
288
        a = array.array(self.typecode, self.example)*5
 
289
        self.assertEqual(
 
290
            a,
 
291
            array.array(self.typecode, self.example*5)
 
292
        )
 
293
 
 
294
        a = 0*array.array(self.typecode, self.example)
 
295
        self.assertEqual(
 
296
            a,
 
297
            array.array(self.typecode)
 
298
        )
 
299
 
 
300
        a = (-1)*array.array(self.typecode, self.example)
 
301
        self.assertEqual(
 
302
            a,
 
303
            array.array(self.typecode)
 
304
        )
 
305
 
 
306
        self.assertRaises(TypeError, a.__mul__, "bad")
 
307
 
 
308
    def test_imul(self):
 
309
        a = array.array(self.typecode, self.example)
 
310
        b = a
 
311
 
 
312
        a *= 5
 
313
        self.assert_(a is b)
 
314
        self.assertEqual(
 
315
            a,
 
316
            array.array(self.typecode, 5*self.example)
 
317
        )
 
318
 
 
319
        a *= 0
 
320
        self.assert_(a is b)
 
321
        self.assertEqual(a, array.array(self.typecode))
 
322
 
 
323
        a *= 1000
 
324
        self.assert_(a is b)
 
325
        self.assertEqual(a, array.array(self.typecode))
 
326
 
 
327
        a *= -1
 
328
        self.assert_(a is b)
 
329
        self.assertEqual(a, array.array(self.typecode))
 
330
 
 
331
        a = array.array(self.typecode, self.example)
 
332
        a *= -1
 
333
        self.assertEqual(a, array.array(self.typecode))
 
334
 
 
335
        self.assertRaises(TypeError, a.__imul__, "bad")
 
336
 
 
337
    def test_getitem(self):
 
338
        a = array.array(self.typecode, self.example)
 
339
        self.assertEntryEqual(a[0], self.example[0])
 
340
        self.assertEntryEqual(a[0], self.example[0])
 
341
        self.assertEntryEqual(a[-1], self.example[-1])
 
342
        self.assertEntryEqual(a[-1], self.example[-1])
 
343
        self.assertEntryEqual(a[len(self.example)-1], self.example[-1])
 
344
        self.assertEntryEqual(a[-len(self.example)], self.example[0])
 
345
        self.assertRaises(TypeError, a.__getitem__)
 
346
        self.assertRaises(IndexError, a.__getitem__, len(self.example))
 
347
        self.assertRaises(IndexError, a.__getitem__, -len(self.example)-1)
 
348
 
 
349
    def test_setitem(self):
 
350
        a = array.array(self.typecode, self.example)
 
351
        a[0] = a[-1]
 
352
        self.assertEntryEqual(a[0], a[-1])
 
353
 
 
354
        a = array.array(self.typecode, self.example)
 
355
        a[0] = a[-1]
 
356
        self.assertEntryEqual(a[0], a[-1])
 
357
 
 
358
        a = array.array(self.typecode, self.example)
 
359
        a[-1] = a[0]
 
360
        self.assertEntryEqual(a[0], a[-1])
 
361
 
 
362
        a = array.array(self.typecode, self.example)
 
363
        a[-1] = a[0]
 
364
        self.assertEntryEqual(a[0], a[-1])
 
365
 
 
366
        a = array.array(self.typecode, self.example)
 
367
        a[len(self.example)-1] = a[0]
 
368
        self.assertEntryEqual(a[0], a[-1])
 
369
 
 
370
        a = array.array(self.typecode, self.example)
 
371
        a[-len(self.example)] = a[-1]
 
372
        self.assertEntryEqual(a[0], a[-1])
 
373
 
 
374
        self.assertRaises(TypeError, a.__setitem__)
 
375
        self.assertRaises(TypeError, a.__setitem__, None)
 
376
        self.assertRaises(TypeError, a.__setitem__, 0, None)
 
377
        self.assertRaises(
 
378
            IndexError,
 
379
            a.__setitem__,
 
380
            len(self.example), self.example[0]
 
381
        )
 
382
        self.assertRaises(
 
383
            IndexError,
 
384
            a.__setitem__,
 
385
            -len(self.example)-1, self.example[0]
 
386
        )
 
387
 
 
388
    def test_delitem(self):
 
389
        a = array.array(self.typecode, self.example)
 
390
        del a[0]
 
391
        self.assertEqual(
 
392
            a,
 
393
            array.array(self.typecode, self.example[1:])
 
394
        )
 
395
 
 
396
        a = array.array(self.typecode, self.example)
 
397
        del a[-1]
 
398
        self.assertEqual(
 
399
            a,
 
400
            array.array(self.typecode, self.example[:-1])
 
401
        )
 
402
 
 
403
        a = array.array(self.typecode, self.example)
 
404
        del a[len(self.example)-1]
 
405
        self.assertEqual(
 
406
            a,
 
407
            array.array(self.typecode, self.example[:-1])
 
408
        )
 
409
 
 
410
        a = array.array(self.typecode, self.example)
 
411
        del a[-len(self.example)]
 
412
        self.assertEqual(
 
413
            a,
 
414
            array.array(self.typecode, self.example[1:])
 
415
        )
 
416
 
 
417
        self.assertRaises(TypeError, a.__delitem__)
 
418
        self.assertRaises(TypeError, a.__delitem__, None)
 
419
        self.assertRaises(IndexError, a.__delitem__, len(self.example))
 
420
        self.assertRaises(IndexError, a.__delitem__, -len(self.example)-1)
 
421
 
 
422
    def test_getslice(self):
 
423
        a = array.array(self.typecode, self.example)
 
424
        self.assertEqual(a[:], a)
 
425
 
 
426
        self.assertEqual(
 
427
            a[1:],
 
428
            array.array(self.typecode, self.example[1:])
 
429
        )
 
430
 
 
431
        self.assertEqual(
 
432
            a[:1],
 
433
            array.array(self.typecode, self.example[:1])
 
434
        )
 
435
 
 
436
        self.assertEqual(
 
437
            a[:-1],
 
438
            array.array(self.typecode, self.example[:-1])
 
439
        )
 
440
 
 
441
        self.assertEqual(
 
442
            a[-1:],
 
443
            array.array(self.typecode, self.example[-1:])
 
444
        )
 
445
 
 
446
        self.assertEqual(
 
447
            a[-1:-1],
 
448
            array.array(self.typecode)
 
449
        )
 
450
 
 
451
        self.assertEqual(
 
452
            a[2:1],
 
453
            array.array(self.typecode)
 
454
        )
 
455
 
 
456
        self.assertEqual(
 
457
            a[1000:],
 
458
            array.array(self.typecode)
 
459
        )
 
460
        self.assertEqual(a[-1000:], a)
 
461
        self.assertEqual(a[:1000], a)
 
462
        self.assertEqual(
 
463
            a[:-1000],
 
464
            array.array(self.typecode)
 
465
        )
 
466
        self.assertEqual(a[-1000:1000], a)
 
467
        self.assertEqual(
 
468
            a[2000:1000],
 
469
            array.array(self.typecode)
 
470
        )
 
471
 
 
472
    def test_extended_getslice(self):
 
473
        # Test extended slicing by comparing with list slicing
 
474
        # (Assumes list conversion works correctly, too)
 
475
        a = array.array(self.typecode, self.example)
 
476
        indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100)
 
477
        for start in indices:
 
478
            for stop in indices:
 
479
                # Everything except the initial 0 (invalid step)
 
480
                for step in indices[1:]:
 
481
                    self.assertEqual(list(a[start:stop:step]),
 
482
                                     list(a)[start:stop:step])
 
483
 
 
484
    def test_setslice(self):
 
485
        a = array.array(self.typecode, self.example)
 
486
        a[:1] = a
 
487
        self.assertEqual(
 
488
            a,
 
489
            array.array(self.typecode, self.example + self.example[1:])
 
490
        )
 
491
 
 
492
        a = array.array(self.typecode, self.example)
 
493
        a[:-1] = a
 
494
        self.assertEqual(
 
495
            a,
 
496
            array.array(self.typecode, self.example + self.example[-1:])
 
497
        )
 
498
 
 
499
        a = array.array(self.typecode, self.example)
 
500
        a[-1:] = a
 
501
        self.assertEqual(
 
502
            a,
 
503
            array.array(self.typecode, self.example[:-1] + self.example)
 
504
        )
 
505
 
 
506
        a = array.array(self.typecode, self.example)
 
507
        a[1:] = a
 
508
        self.assertEqual(
 
509
            a,
 
510
            array.array(self.typecode, self.example[:1] + self.example)
 
511
        )
 
512
 
 
513
        a = array.array(self.typecode, self.example)
 
514
        a[1:-1] = a
 
515
        self.assertEqual(
 
516
            a,
 
517
            array.array(
 
518
                self.typecode,
 
519
                self.example[:1] + self.example + self.example[-1:]
 
520
            )
 
521
        )
 
522
 
 
523
        a = array.array(self.typecode, self.example)
 
524
        a[1000:] = a
 
525
        self.assertEqual(
 
526
            a,
 
527
            array.array(self.typecode, 2*self.example)
 
528
        )
 
529
 
 
530
        a = array.array(self.typecode, self.example)
 
531
        a[-1000:] = a
 
532
        self.assertEqual(
 
533
            a,
 
534
            array.array(self.typecode, self.example)
 
535
        )
 
536
 
 
537
        a = array.array(self.typecode, self.example)
 
538
        a[:1000] = a
 
539
        self.assertEqual(
 
540
            a,
 
541
            array.array(self.typecode, self.example)
 
542
        )
 
543
 
 
544
        a = array.array(self.typecode, self.example)
 
545
        a[:-1000] = a
 
546
        self.assertEqual(
 
547
            a,
 
548
            array.array(self.typecode, 2*self.example)
 
549
        )
 
550
 
 
551
        a = array.array(self.typecode, self.example)
 
552
        a[1:0] = a
 
553
        self.assertEqual(
 
554
            a,
 
555
            array.array(self.typecode, self.example[:1] + self.example + self.example[1:])
 
556
        )
 
557
 
 
558
        a = array.array(self.typecode, self.example)
 
559
        a[2000:1000] = a
 
560
        self.assertEqual(
 
561
            a,
 
562
            array.array(self.typecode, 2*self.example)
 
563
        )
 
564
 
 
565
        a = array.array(self.typecode, self.example)
 
566
        self.assertRaises(TypeError, a.__setitem__, slice(0, 0), None)
 
567
        self.assertRaises(TypeError, a.__setitem__, slice(0, 1), None)
 
568
 
 
569
        b = array.array(self.badtypecode())
 
570
        self.assertRaises(TypeError, a.__setitem__, slice(0, 0), b)
 
571
        self.assertRaises(TypeError, a.__setitem__, slice(0, 1), b)
 
572
 
 
573
    def test_extended_set_del_slice(self):
 
574
        indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100)
 
575
        for start in indices:
 
576
            for stop in indices:
 
577
                # Everything except the initial 0 (invalid step)
 
578
                for step in indices[1:]:
 
579
                    a = array.array(self.typecode, self.example)
 
580
                    L = list(a)
 
581
                    # Make sure we have a slice of exactly the right length,
 
582
                    # but with (hopefully) different data.
 
583
                    data = L[start:stop:step]
 
584
                    data.reverse()
 
585
                    L[start:stop:step] = data
 
586
                    a[start:stop:step] = array.array(self.typecode, data)
 
587
                    self.assertEquals(a, array.array(self.typecode, L))
 
588
 
 
589
                    del L[start:stop:step]
 
590
                    del a[start:stop:step]
 
591
                    self.assertEquals(a, array.array(self.typecode, L))
 
592
 
 
593
    def test_index(self):
 
594
        example = 2*self.example
 
595
        a = array.array(self.typecode, example)
 
596
        self.assertRaises(TypeError, a.index)
 
597
        for x in example:
 
598
            self.assertEqual(a.index(x), example.index(x))
 
599
        self.assertRaises(ValueError, a.index, None)
 
600
        self.assertRaises(ValueError, a.index, self.outside)
 
601
 
 
602
    def test_count(self):
 
603
        example = 2*self.example
 
604
        a = array.array(self.typecode, example)
 
605
        self.assertRaises(TypeError, a.count)
 
606
        for x in example:
 
607
            self.assertEqual(a.count(x), example.count(x))
 
608
        self.assertEqual(a.count(self.outside), 0)
 
609
        self.assertEqual(a.count(None), 0)
 
610
 
 
611
    def test_remove(self):
 
612
        for x in self.example:
 
613
            example = 2*self.example
 
614
            a = array.array(self.typecode, example)
 
615
            pos = example.index(x)
 
616
            example2 = example[:pos] + example[pos+1:]
 
617
            a.remove(x)
 
618
            self.assertEqual(a, array.array(self.typecode, example2))
 
619
 
 
620
        a = array.array(self.typecode, self.example)
 
621
        self.assertRaises(ValueError, a.remove, self.outside)
 
622
 
 
623
        self.assertRaises(ValueError, a.remove, None)
 
624
 
 
625
    def test_pop(self):
 
626
        a = array.array(self.typecode)
 
627
        self.assertRaises(IndexError, a.pop)
 
628
 
 
629
        a = array.array(self.typecode, 2*self.example)
 
630
        self.assertRaises(TypeError, a.pop, 42, 42)
 
631
        self.assertRaises(TypeError, a.pop, None)
 
632
        self.assertRaises(IndexError, a.pop, len(a))
 
633
        self.assertRaises(IndexError, a.pop, -len(a)-1)
 
634
 
 
635
        self.assertEntryEqual(a.pop(0), self.example[0])
 
636
        self.assertEqual(
 
637
            a,
 
638
            array.array(self.typecode, self.example[1:]+self.example)
 
639
        )
 
640
        self.assertEntryEqual(a.pop(1), self.example[2])
 
641
        self.assertEqual(
 
642
            a,
 
643
            array.array(self.typecode, self.example[1:2]+self.example[3:]+self.example)
 
644
        )
 
645
        self.assertEntryEqual(a.pop(0), self.example[1])
 
646
        self.assertEntryEqual(a.pop(), self.example[-1])
 
647
        self.assertEqual(
 
648
            a,
 
649
            array.array(self.typecode, self.example[3:]+self.example[:-1])
 
650
        )
 
651
 
 
652
    def test_reverse(self):
 
653
        a = array.array(self.typecode, self.example)
 
654
        self.assertRaises(TypeError, a.reverse, 42)
 
655
        a.reverse()
 
656
        self.assertEqual(
 
657
            a,
 
658
            array.array(self.typecode, self.example[::-1])
 
659
        )
 
660
 
 
661
    def test_extend(self):
 
662
        a = array.array(self.typecode, self.example)
 
663
        self.assertRaises(TypeError, a.extend)
 
664
        a.extend(array.array(self.typecode, self.example[::-1]))
 
665
        self.assertEqual(
 
666
            a,
 
667
            array.array(self.typecode, self.example+self.example[::-1])
 
668
        )
 
669
 
 
670
        b = array.array(self.badtypecode())
 
671
        self.assertRaises(TypeError, a.extend, b)
 
672
 
 
673
        a = array.array(self.typecode, self.example)
 
674
        a.extend(self.example[::-1])
 
675
        self.assertEqual(
 
676
            a,
 
677
            array.array(self.typecode, self.example+self.example[::-1])
 
678
        )
 
679
 
 
680
    def test_constructor_with_iterable_argument(self):
 
681
        a = array.array(self.typecode, iter(self.example))
 
682
        b = array.array(self.typecode, self.example)
 
683
        self.assertEqual(a, b)
 
684
 
 
685
        # non-iterable argument
 
686
        self.assertRaises(TypeError, array.array, self.typecode, 10)
 
687
 
 
688
        # pass through errors raised in __iter__
 
689
        class A:
 
690
            def __iter__(self):
 
691
                raise UnicodeError
 
692
        self.assertRaises(UnicodeError, array.array, self.typecode, A())
 
693
 
 
694
        # pass through errors raised in next()
 
695
        def B():
 
696
            raise UnicodeError
 
697
            yield None
 
698
        self.assertRaises(UnicodeError, array.array, self.typecode, B())
 
699
 
 
700
    def test_coveritertraverse(self):
 
701
        try:
 
702
            import gc
 
703
        except ImportError:
 
704
            return
 
705
        a = array.array(self.typecode)
 
706
        l = [iter(a)]
 
707
        l.append(l)
 
708
        gc.collect()
 
709
 
 
710
    def test_buffer(self):
 
711
        a = array.array(self.typecode, self.example)
 
712
        m = memoryview(a)
 
713
        b = bytes(m)
 
714
        self.assertEqual(b, a.tostring())
 
715
        self.assertEqual(b[0], a.tostring()[0])
 
716
        # Resizing is forbidden when there are buffer exports
 
717
        self.assertRaises(BufferError, a.append, a[0])
 
718
        self.assertRaises(BufferError, a.extend, a[0:1])
 
719
        self.assertRaises(BufferError, a.remove, a[0])
 
720
        self.assertRaises(BufferError, a.fromlist, a.tolist())
 
721
        self.assertRaises(BufferError, a.fromstring, a.tostring())
 
722
        if self.typecode == 'u':
 
723
            self.assertRaises(BufferError, a.fromunicode, a.tounicode())
 
724
        self.assertRaises(BufferError, operator.setitem, a, slice(0, 0), a)
 
725
        self.assertRaises(BufferError, operator.delitem, a, 0)
 
726
        self.assertRaises(BufferError, operator.delitem, a, slice(0, 1))
 
727
        self.assertRaises(BufferError, operator.imul, a, 2)
 
728
        self.assertRaises(BufferError, operator.imul, a, 0)
 
729
 
 
730
    def test_weakref(self):
 
731
        s = array.array(self.typecode, self.example)
 
732
        p = proxy(s)
 
733
        self.assertEqual(p.tostring(), s.tostring())
 
734
        s = None
 
735
        self.assertRaises(ReferenceError, len, p)
 
736
 
 
737
    def test_bug_782369(self):
 
738
        import sys
 
739
        if hasattr(sys, "getrefcount"):
 
740
            for i in range(10):
 
741
                b = array.array('B', range(64))
 
742
            rc = sys.getrefcount(10)
 
743
            for i in range(10):
 
744
                b = array.array('B', range(64))
 
745
            self.assertEqual(rc, sys.getrefcount(10))
 
746
 
 
747
    def test_subclass_with_kwargs(self):
 
748
        # SF bug #1486663 -- this used to erroneously raise a TypeError
 
749
        ArraySubclassWithKwargs('b', newarg=1)
 
750
 
 
751
    def test_create_from_bytes(self):
 
752
        a = array.array('H', b"1234")
 
753
        self.assertEqual(len(a) * a.itemsize, 4)
 
754
 
 
755
 
 
756
class StringTest(BaseTest):
 
757
 
 
758
    def test_setitem(self):
 
759
        super().test_setitem()
 
760
        a = array.array(self.typecode, self.example)
 
761
        self.assertRaises(TypeError, a.__setitem__, 0, self.example[:2])
 
762
 
 
763
class UnicodeTest(StringTest):
 
764
    typecode = 'u'
 
765
    example = '\x01\u263a\x00\ufeff'
 
766
    smallerexample = '\x01\u263a\x00\ufefe'
 
767
    biggerexample = '\x01\u263a\x01\ufeff'
 
768
    outside = str('\x33')
 
769
    minitemsize = 2
 
770
 
 
771
    def test_unicode(self):
 
772
        self.assertRaises(TypeError, array.array, 'b', 'foo')
 
773
 
 
774
        a = array.array('u', '\xa0\xc2\u1234')
 
775
        a.fromunicode(' ')
 
776
        a.fromunicode('')
 
777
        a.fromunicode('')
 
778
        a.fromunicode('\x11abc\xff\u1234')
 
779
        s = a.tounicode()
 
780
        self.assertEqual(s, '\xa0\xc2\u1234 \x11abc\xff\u1234')
 
781
 
 
782
        s = '\x00="\'a\\b\x80\xff\u0000\u0001\u1234'
 
783
        a = array.array('u', s)
 
784
        self.assertEqual(
 
785
            repr(a),
 
786
            "array('u', '\\x00=\"\\'a\\\\b\\x80\xff\\x00\\x01\u1234')")
 
787
 
 
788
        self.assertRaises(TypeError, a.fromunicode)
 
789
 
 
790
tests.append(UnicodeTest)
 
791
 
 
792
class NumberTest(BaseTest):
 
793
 
 
794
    def test_extslice(self):
 
795
        a = array.array(self.typecode, range(5))
 
796
        self.assertEqual(a[::], a)
 
797
        self.assertEqual(a[::2], array.array(self.typecode, [0,2,4]))
 
798
        self.assertEqual(a[1::2], array.array(self.typecode, [1,3]))
 
799
        self.assertEqual(a[::-1], array.array(self.typecode, [4,3,2,1,0]))
 
800
        self.assertEqual(a[::-2], array.array(self.typecode, [4,2,0]))
 
801
        self.assertEqual(a[3::-2], array.array(self.typecode, [3,1]))
 
802
        self.assertEqual(a[-100:100:], a)
 
803
        self.assertEqual(a[100:-100:-1], a[::-1])
 
804
        self.assertEqual(a[-100:100:2], array.array(self.typecode, [0,2,4]))
 
805
        self.assertEqual(a[1000:2000:2], array.array(self.typecode, []))
 
806
        self.assertEqual(a[-1000:-2000:-2], array.array(self.typecode, []))
 
807
 
 
808
    def test_delslice(self):
 
809
        a = array.array(self.typecode, range(5))
 
810
        del a[::2]
 
811
        self.assertEqual(a, array.array(self.typecode, [1,3]))
 
812
        a = array.array(self.typecode, range(5))
 
813
        del a[1::2]
 
814
        self.assertEqual(a, array.array(self.typecode, [0,2,4]))
 
815
        a = array.array(self.typecode, range(5))
 
816
        del a[1::-2]
 
817
        self.assertEqual(a, array.array(self.typecode, [0,2,3,4]))
 
818
        a = array.array(self.typecode, range(10))
 
819
        del a[::1000]
 
820
        self.assertEqual(a, array.array(self.typecode, [1,2,3,4,5,6,7,8,9]))
 
821
 
 
822
    def test_assignment(self):
 
823
        a = array.array(self.typecode, range(10))
 
824
        a[::2] = array.array(self.typecode, [42]*5)
 
825
        self.assertEqual(a, array.array(self.typecode, [42, 1, 42, 3, 42, 5, 42, 7, 42, 9]))
 
826
        a = array.array(self.typecode, range(10))
 
827
        a[::-4] = array.array(self.typecode, [10]*3)
 
828
        self.assertEqual(a, array.array(self.typecode, [0, 10, 2, 3, 4, 10, 6, 7, 8 ,10]))
 
829
        a = array.array(self.typecode, range(4))
 
830
        a[::-1] = a
 
831
        self.assertEqual(a, array.array(self.typecode, [3, 2, 1, 0]))
 
832
        a = array.array(self.typecode, range(10))
 
833
        b = a[:]
 
834
        c = a[:]
 
835
        ins = array.array(self.typecode, range(2))
 
836
        a[2:3] = ins
 
837
        b[slice(2,3)] = ins
 
838
        c[2:3:] = ins
 
839
 
 
840
    def test_iterationcontains(self):
 
841
        a = array.array(self.typecode, range(10))
 
842
        self.assertEqual(list(a), list(range(10)))
 
843
        b = array.array(self.typecode, [20])
 
844
        self.assertEqual(a[-1] in a, True)
 
845
        self.assertEqual(b[0] not in a, True)
 
846
 
 
847
    def check_overflow(self, lower, upper):
 
848
        # method to be used by subclasses
 
849
 
 
850
        # should not overflow assigning lower limit
 
851
        a = array.array(self.typecode, [lower])
 
852
        a[0] = lower
 
853
        # should overflow assigning less than lower limit
 
854
        self.assertRaises(OverflowError, array.array, self.typecode, [lower-1])
 
855
        self.assertRaises(OverflowError, a.__setitem__, 0, lower-1)
 
856
        # should not overflow assigning upper limit
 
857
        a = array.array(self.typecode, [upper])
 
858
        a[0] = upper
 
859
        # should overflow assigning more than upper limit
 
860
        self.assertRaises(OverflowError, array.array, self.typecode, [upper+1])
 
861
        self.assertRaises(OverflowError, a.__setitem__, 0, upper+1)
 
862
 
 
863
    def test_subclassing(self):
 
864
        typecode = self.typecode
 
865
        class ExaggeratingArray(array.array):
 
866
            __slots__ = ['offset']
 
867
 
 
868
            def __new__(cls, typecode, data, offset):
 
869
                return array.array.__new__(cls, typecode, data)
 
870
 
 
871
            def __init__(self, typecode, data, offset):
 
872
                self.offset = offset
 
873
 
 
874
            def __getitem__(self, i):
 
875
                return array.array.__getitem__(self, i) + self.offset
 
876
 
 
877
        a = ExaggeratingArray(self.typecode, [3, 6, 7, 11], 4)
 
878
        self.assertEntryEqual(a[0], 7)
 
879
 
 
880
        self.assertRaises(AttributeError, setattr, a, "color", "blue")
 
881
 
 
882
class SignedNumberTest(NumberTest):
 
883
    example = [-1, 0, 1, 42, 0x7f]
 
884
    smallerexample = [-1, 0, 1, 42, 0x7e]
 
885
    biggerexample = [-1, 0, 1, 43, 0x7f]
 
886
    outside = 23
 
887
 
 
888
    def test_overflow(self):
 
889
        a = array.array(self.typecode)
 
890
        lower = -1 * int(pow(2, a.itemsize * 8 - 1))
 
891
        upper = int(pow(2, a.itemsize * 8 - 1)) - 1
 
892
        self.check_overflow(lower, upper)
 
893
 
 
894
class UnsignedNumberTest(NumberTest):
 
895
    example = [0, 1, 17, 23, 42, 0xff]
 
896
    smallerexample = [0, 1, 17, 23, 42, 0xfe]
 
897
    biggerexample = [0, 1, 17, 23, 43, 0xff]
 
898
    outside = 0xaa
 
899
 
 
900
    def test_overflow(self):
 
901
        a = array.array(self.typecode)
 
902
        lower = 0
 
903
        upper = int(pow(2, a.itemsize * 8)) - 1
 
904
        self.check_overflow(lower, upper)
 
905
 
 
906
 
 
907
class ByteTest(SignedNumberTest):
 
908
    typecode = 'b'
 
909
    minitemsize = 1
 
910
tests.append(ByteTest)
 
911
 
 
912
class UnsignedByteTest(UnsignedNumberTest):
 
913
    typecode = 'B'
 
914
    minitemsize = 1
 
915
tests.append(UnsignedByteTest)
 
916
 
 
917
class ShortTest(SignedNumberTest):
 
918
    typecode = 'h'
 
919
    minitemsize = 2
 
920
tests.append(ShortTest)
 
921
 
 
922
class UnsignedShortTest(UnsignedNumberTest):
 
923
    typecode = 'H'
 
924
    minitemsize = 2
 
925
tests.append(UnsignedShortTest)
 
926
 
 
927
class IntTest(SignedNumberTest):
 
928
    typecode = 'i'
 
929
    minitemsize = 2
 
930
tests.append(IntTest)
 
931
 
 
932
class UnsignedIntTest(UnsignedNumberTest):
 
933
    typecode = 'I'
 
934
    minitemsize = 2
 
935
tests.append(UnsignedIntTest)
 
936
 
 
937
class LongTest(SignedNumberTest):
 
938
    typecode = 'l'
 
939
    minitemsize = 4
 
940
tests.append(LongTest)
 
941
 
 
942
class UnsignedLongTest(UnsignedNumberTest):
 
943
    typecode = 'L'
 
944
    minitemsize = 4
 
945
tests.append(UnsignedLongTest)
 
946
 
 
947
class FPTest(NumberTest):
 
948
    example = [-42.0, 0, 42, 1e5, -1e10]
 
949
    smallerexample = [-42.0, 0, 42, 1e5, -2e10]
 
950
    biggerexample = [-42.0, 0, 42, 1e5, 1e10]
 
951
    outside = 23
 
952
 
 
953
    def assertEntryEqual(self, entry1, entry2):
 
954
        self.assertAlmostEqual(entry1, entry2)
 
955
 
 
956
    def test_byteswap(self):
 
957
        a = array.array(self.typecode, self.example)
 
958
        self.assertRaises(TypeError, a.byteswap, 42)
 
959
        if a.itemsize in (1, 2, 4, 8):
 
960
            b = array.array(self.typecode, self.example)
 
961
            b.byteswap()
 
962
            if a.itemsize==1:
 
963
                self.assertEqual(a, b)
 
964
            else:
 
965
                # On alphas treating the byte swapped bit patters as
 
966
                # floats/doubles results in floating point exceptions
 
967
                # => compare the 8bit string values instead
 
968
                self.assertNotEqual(a.tostring(), b.tostring())
 
969
            b.byteswap()
 
970
            self.assertEqual(a, b)
 
971
 
 
972
class FloatTest(FPTest):
 
973
    typecode = 'f'
 
974
    minitemsize = 4
 
975
tests.append(FloatTest)
 
976
 
 
977
class DoubleTest(FPTest):
 
978
    typecode = 'd'
 
979
    minitemsize = 8
 
980
 
 
981
    def test_alloc_overflow(self):
 
982
        from sys import maxsize
 
983
        a = array.array('d', [-1]*65536)
 
984
        try:
 
985
            a *= maxsize//65536 + 1
 
986
        except MemoryError:
 
987
            pass
 
988
        else:
 
989
            self.fail("Array of size > maxsize created - MemoryError expected")
 
990
        b = array.array('d', [ 2.71828183, 3.14159265, -1])
 
991
        try:
 
992
            b * (maxsize//3 + 1)
 
993
        except MemoryError:
 
994
            pass
 
995
        else:
 
996
            self.fail("Array of size > maxsize created - MemoryError expected")
 
997
 
 
998
tests.append(DoubleTest)
 
999
 
 
1000
def test_main(verbose=None):
 
1001
    import sys
 
1002
 
 
1003
    support.run_unittest(*tests)
 
1004
 
 
1005
    # verify reference counting
 
1006
    if verbose and hasattr(sys, "gettotalrefcount"):
 
1007
        import gc
 
1008
        counts = [None] * 5
 
1009
        for i in range(len(counts)):
 
1010
            support.run_unittest(*tests)
 
1011
            gc.collect()
 
1012
            counts[i] = sys.gettotalrefcount()
 
1013
        print(counts)
 
1014
 
 
1015
if __name__ == "__main__":
 
1016
    test_main(verbose=True)