projects / OpenSPARC-T2-SAM / blame
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Initial commit of OpenSPARC T2 architecture model.
[OpenSPARC-T2-SAM] / sam-t2 / devtools / amd64 / lib / python2.4 / test / test_array.py
CommitLineData
920dae64
AT		 1#! /usr/bin/env python
2"""Test the arraymodule.
3 Roger E. Masse
4"""
5
6import unittest
7from test import test_support
8from weakref import proxy
9import array, cStringIO, math
10
11tests = [] # list to accumulate all tests
12typecodes = "cubBhHiIlLfd"
13
14class 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
22tests.append(BadConstructorTest)
23
24class 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
657class 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
664class 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
701tests.append(CharacterTest)
702
703if 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
737class 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
827class 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
839class 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
852class ByteTest(SignedNumberTest):
853 typecode = 'b'
854 minitemsize = 1
855tests.append(ByteTest)
856
857class UnsignedByteTest(UnsignedNumberTest):
858 typecode = 'B'
859 minitemsize = 1
860tests.append(UnsignedByteTest)
861
862class ShortTest(SignedNumberTest):
863 typecode = 'h'
864 minitemsize = 2
865tests.append(ShortTest)
866
867class UnsignedShortTest(UnsignedNumberTest):
868 typecode = 'H'
869 minitemsize = 2
870tests.append(UnsignedShortTest)
871
872class IntTest(SignedNumberTest):
873 typecode = 'i'
874 minitemsize = 2
875tests.append(IntTest)
876
877class UnsignedIntTest(UnsignedNumberTest):
878 typecode = 'I'
879 minitemsize = 2
880tests.append(UnsignedIntTest)
881
882class LongTest(SignedNumberTest):
883 typecode = 'l'
884 minitemsize = 4
885tests.append(LongTest)
886
887class UnsignedLongTest(UnsignedNumberTest):
888 typecode = 'L'
889 minitemsize = 4
890tests.append(UnsignedLongTest)
891
892class 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
917class FloatTest(FPTest):
918 typecode = 'f'
919 minitemsize = 4
920tests.append(FloatTest)
921
922class DoubleTest(FPTest):
923 typecode = 'd'
924 minitemsize = 8
925tests.append(DoubleTest)
926
927def 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
942if __name__ == "__main__":
943 test_main(verbose=True)
Full OpenSPARC architecture tarball including simulator, hypervisor, and OBP.