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