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