Port test_array and test_winsound to PyUnit. Enhance tests for array
(code coverage for Modules/arraymodule.c is at 91%)
From SF patch #736962.
diff --git a/Lib/test/test_array.py b/Lib/test/test_array.py
index 6aa3cf0..68f2787 100755
--- a/Lib/test/test_array.py
+++ b/Lib/test/test_array.py
@@ -2,380 +2,838 @@
"""Test the arraymodule.
Roger E. Masse
"""
-import array
-from test.test_support import verbose, TESTFN, unlink, TestFailed,\
- have_unicode, vereq
-def main():
- testtype('c', 'c')
- if have_unicode:
- testtype('u', unicode(r'\u263a', 'unicode-escape'))
- for type in (['b', 'h', 'i', 'l', 'f', 'd']):
- testtype(type, 1)
- if have_unicode:
- testunicode()
- testsubclassing()
- unlink(TESTFN)
+import unittest
+from test import test_support
+import array, cStringIO, math
-def testunicode():
- try:
- array.array('b', unicode('foo', 'ascii'))
- except TypeError:
- pass
- else:
- raise TestFailed("creating a non-unicode array from "
- "a Unicode string should fail")
+tests = [] # list to accumulate all tests
+typecodes = "cubBhHiIlLfd"
- x = array.array('u', unicode(r'\xa0\xc2\u1234', 'unicode-escape'))
- x.fromunicode(unicode(' ', 'ascii'))
- x.fromunicode(unicode('', 'ascii'))
- x.fromunicode(unicode('', 'ascii'))
- x.fromunicode(unicode(r'\x11abc\xff\u1234', 'unicode-escape'))
- s = x.tounicode()
- if s != unicode(r'\xa0\xc2\u1234 \x11abc\xff\u1234', 'unicode-escape'):
- raise TestFailed("fromunicode()/tounicode()")
+class BadConstructorTest(unittest.TestCase):
- s = unicode(r'\x00="\'a\\b\x80\xff\u0000\u0001\u1234', 'unicode-escape')
- a = array.array('u', s)
- if verbose:
- print "repr of type 'u' array:", repr(a)
- print " expected: array('u', %r)" % s
+ def test_constructor(self):
+ self.assertRaises(TypeError, array.array)
+ self.assertRaises(TypeError, array.array, spam=42)
+ self.assertRaises(TypeError, array.array, 'xx')
+ self.assertRaises(ValueError, array.array, 'x')
-def testsubclassing():
- class EditableString(array.array):
- def __new__(cls, s, *args, **kwargs):
- return array.array.__new__(cls, 'c', s)
+tests.append(BadConstructorTest)
- def __init__(self, s, color='blue'):
- array.array.__init__(self, 'c', s)
- self.color = color
+class BaseTest(unittest.TestCase):
+ # Required class attributes (provided by subclasses
+ # typecode: the typecode to test
+ # example: an initializer usable in the constructor for this type
+ # smallerexample: the same length as example, but smaller
+ # biggerexample: the same length as example, but bigger
+ # outside: An entry that is not in example
+ # minitemsize: the minimum guaranteed itemsize
- def strip(self):
- self[:] = array.array('c', self.tostring().strip())
+ def assertEntryEqual(self, entry1, entry2):
+ self.assertEqual(entry1, entry2)
- def __repr__(self):
- return 'EditableString(%r)' % self.tostring()
+ def badtypecode(self):
+ # Return a typecode that is different from our own
+ return typecodes[(typecodes.index(self.typecode)+1) % len(typecodes)]
- s = EditableString("\ttest\r\n")
- s.strip()
- if s.tostring() != 'test':
- raise TestFailed, "subclassing array.array failed somewhere"
- if s.color != 'blue':
- raise TestFailed, "assigning attributes to instance of array subclass"
- s.color = 'red'
- if s.color != 'red':
- raise TestFailed, "assigning attributes to instance of array subclass"
- if s.__dict__.keys() != ['color']:
- raise TestFailed, "array subclass __dict__"
+ def test_constructor(self):
+ a = array.array(self.typecode)
+ self.assertEqual(a.typecode, self.typecode)
+ self.assert_(a.itemsize>=self.minitemsize)
+ self.assertRaises(TypeError, array.array, self.typecode, None)
- class ExaggeratingArray(array.array):
- __slots__ = ['offset']
+ def test_len(self):
+ a = array.array(self.typecode)
+ a.append(self.example[0])
+ self.assertEqual(len(a), 1)
- def __new__(cls, typecode, data, offset):
- return array.array.__new__(cls, typecode, data)
+ a = array.array(self.typecode, self.example)
+ self.assertEqual(len(a), len(self.example))
- def __init__(self, typecode, data, offset):
- self.offset = offset
+ def test_buffer_info(self):
+ a = array.array(self.typecode, self.example)
+ self.assertRaises(TypeError, a.buffer_info, 42)
+ bi = a.buffer_info()
+ self.assert_(isinstance(bi, tuple))
+ self.assertEqual(len(bi), 2)
+ self.assert_(isinstance(bi[0], int))
+ self.assert_(isinstance(bi[1], int))
+ self.assertEqual(bi[1], len(a))
- def __getitem__(self, i):
- return array.array.__getitem__(self, i) + self.offset
+ def test_byteswap(self):
+ a = array.array(self.typecode, self.example)
+ self.assertRaises(TypeError, a.byteswap, 42)
+ if a.itemsize in (1, 2, 4, 8):
+ b = array.array(self.typecode, self.example)
+ b.byteswap()
+ if a.itemsize==1:
+ self.assertEqual(a, b)
+ else:
+ self.assertNotEqual(a, b)
+ b.byteswap()
+ self.assertEqual(a, b)
- a = ExaggeratingArray('i', [3, 6, 7, 11], 4)
- if a[0] != 7:
- raise TestFailed, "array subclass overriding __getitem__"
- try:
- a.color = 'blue'
- except AttributeError:
- pass
- else:
- raise TestFailed, "array subclass __slots__ was ignored"
+ def test_insert(self):
+ a = array.array(self.typecode, self.example)
+ a.insert(0, self.example[0])
+ self.assertEqual(len(a), 1+len(self.example))
+ self.assertEqual(a[0], a[1])
+ self.assertRaises(TypeError, a.insert)
+ self.assertRaises(TypeError, a.insert, None)
+ def test_tofromfile(self):
+ a = array.array(self.typecode, 2*self.example)
+ self.assertRaises(TypeError, a.tofile)
+ self.assertRaises(TypeError, a.tofile, cStringIO.StringIO())
+ f = open(test_support.TESTFN, 'wb')
+ try:
+ a.tofile(f)
+ f.close()
+ b = array.array(self.typecode)
+ f = open(test_support.TESTFN, 'rb')
+ self.assertRaises(TypeError, b.fromfile)
+ self.assertRaises(
+ TypeError,
+ b.fromfile,
+ cStringIO.StringIO(), len(self.example)
+ )
+ b.fromfile(f, len(self.example))
+ self.assertEqual(b, array.array(self.typecode, self.example))
+ self.assertNotEqual(a, b)
+ b.fromfile(f, len(self.example))
+ self.assertEqual(a, b)
+ self.assertRaises(EOFError, b.fromfile, f, 1)
+ f.close()
+ finally:
+ if not f.closed:
+ f.close()
+ test_support.unlink(test_support.TESTFN)
-def testoverflow(type, lowerLimit, upperLimit):
- # should not overflow assigning lower limit
- if verbose:
- print "overflow test: array(%s, [%s])" % (`type`, `lowerLimit`)
- try:
- a = array.array(type, [lowerLimit])
- except:
- raise TestFailed, "array(%s) overflowed assigning %s" %\
- (`type`, `lowerLimit`)
- # should overflow assigning less than lower limit
- if verbose:
- print "overflow test: array(%s, [%s])" % (`type`, `lowerLimit-1`)
- try:
- a = array.array(type, [lowerLimit-1])
- raise TestFailed, "array(%s) did not overflow assigning %s" %\
- (`type`, `lowerLimit-1`)
- except OverflowError:
- pass
- # should not overflow assigning upper limit
- if verbose:
- print "overflow test: array(%s, [%s])" % (`type`, `upperLimit`)
- try:
- a = array.array(type, [upperLimit])
- except:
- raise TestFailed, "array(%s) overflowed assigning %s" %\
- (`type`, `upperLimit`)
- # should overflow assigning more than upper limit
- if verbose:
- print "overflow test: array(%s, [%s])" % (`type`, `upperLimit+1`)
- try:
- a = array.array(type, [upperLimit+1])
- raise TestFailed, "array(%s) did not overflow assigning %s" %\
- (`type`, `upperLimit+1`)
- except OverflowError:
- pass
+ def test_tofromlist(self):
+ a = array.array(self.typecode, 2*self.example)
+ b = array.array(self.typecode)
+ self.assertRaises(TypeError, a.tolist, 42)
+ self.assertRaises(TypeError, b.fromlist)
+ self.assertRaises(TypeError, b.fromlist, 42)
+ self.assertRaises(TypeError, b.fromlist, [None])
+ b.fromlist(a.tolist())
+ self.assertEqual(a, b)
+ def test_tofromstring(self):
+ a = array.array(self.typecode, 2*self.example)
+ b = array.array(self.typecode)
+ self.assertRaises(TypeError, a.tostring, 42)
+ self.assertRaises(TypeError, b.fromstring)
+ self.assertRaises(TypeError, b.fromstring, 42)
+ b.fromstring(a.tostring())
+ self.assertEqual(a, b)
+ if a.itemsize>1:
+ self.assertRaises(ValueError, b.fromstring, "x")
+ def test_repr(self):
+ a = array.array(self.typecode, 2*self.example)
+ self.assertEqual(a, eval(repr(a), {"array": array.array}))
-def testtype(type, example):
- a = array.array(type)
- a.append(example)
- if verbose:
- print 40*'*'
- print 'array after append: ', a
- a.typecode
- a.itemsize
- if a.typecode in ('i', 'b', 'h', 'l'):
- a.byteswap()
+ a = array.array(self.typecode)
+ self.assertEqual(repr(a), "array('%s')" % self.typecode)
- if a.typecode == 'c':
- f = open(TESTFN, "w")
- f.write("The quick brown fox jumps over the lazy dog.\n")
- f.close()
- f = open(TESTFN, 'r')
- a.fromfile(f, 10)
- f.close()
- if verbose:
- print 'char array with 10 bytes of TESTFN appended: ', a
- a.fromlist(['a', 'b', 'c'])
- if verbose:
- print 'char array with list appended: ', a
+ def test_str(self):
+ a = array.array(self.typecode, 2*self.example)
+ str(a)
- a.insert(0, example)
- if verbose:
- print 'array of %s after inserting another:' % a.typecode, a
- f = open(TESTFN, 'w')
- a.tofile(f)
- f.close()
+ def test_cmp(self):
+ a = array.array(self.typecode, self.example)
+ self.assert_((a == 42) is False)
+ self.assert_((a != 42) is True)
- # This block is just to verify that the operations don't blow up.
- a.tolist()
- a.tostring()
- repr(a)
- str(a)
+ self.assert_((a == a) is True)
+ self.assert_((a != a) is False)
+ self.assert_((a < a) is False)
+ self.assert_((a <= a) is True)
+ self.assert_((a > a) is False)
+ self.assert_((a >= a) is True)
- if verbose:
- print 'array of %s converted to a list: ' % a.typecode, a.tolist()
- if verbose:
- print 'array of %s converted to a string: ' \
- % a.typecode, `a.tostring()`
+ as = array.array(self.typecode, self.smallerexample)
+ ab = array.array(self.typecode, self.biggerexample)
- # Try out inplace addition and multiplication
- a = array.array(type, [example])
- b = a
- a += array.array(type, [example]*2)
- if a is not b:
- raise TestFailed, "array(%s) inplace addition" % `type`
- if a != array.array(type, [example] * 3):
- raise TestFailed, "array(%s) inplace addition" % `type`
+ self.assert_((a == 2*a) is False)
+ self.assert_((a != 2*a) is True)
+ self.assert_((a < 2*a) is True)
+ self.assert_((a <= 2*a) is True)
+ self.assert_((a > 2*a) is False)
+ self.assert_((a >= 2*a) is False)
- a *= 5
- if a is not b:
- raise TestFailed, "array(%s) inplace multiplication" % `type`
- if a != array.array(type, [example] * 15):
- raise TestFailed, "array(%s) inplace multiplication" % `type`
+ self.assert_((a == as) is False)
+ self.assert_((a != as) is True)
+ self.assert_((a < as) is False)
+ self.assert_((a <= as) is False)
+ self.assert_((a > as) is True)
+ self.assert_((a >= as) is True)
- a *= 0
- if a is not b:
- raise TestFailed, "array(%s) inplace multiplication by 0" % `type`
- if a != array.array(type, []):
- raise TestFailed, "array(%s) inplace multiplication by 0" % `type`
+ self.assert_((a == ab) is False)
+ self.assert_((a != ab) is True)
+ self.assert_((a < ab) is True)
+ self.assert_((a <= ab) is True)
+ self.assert_((a > ab) is False)
+ self.assert_((a >= ab) is False)
- a *= 1000
- if a is not b:
- raise TestFailed, "empty array(%s) inplace multiplication" % `type`
- if a != array.array(type, []):
- raise TestFailed, "empty array(%s) inplace multiplication" % `type`
+ def test_add(self):
+ a = array.array(self.typecode, self.example) \
+ + array.array(self.typecode, self.example[::-1])
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example + self.example[::-1])
+ )
- if type == 'c':
- a = array.array(type, "abcde")
+ b = array.array(self.badtypecode())
+ self.assertRaises(TypeError, a.__add__, b)
+
+ self.assertRaises(TypeError, a.__add__, "bad")
+
+ def test_iadd(self):
+ a = array.array(self.typecode, self.example[::-1])
+ b = a
+ a += array.array(self.typecode, 2*self.example)
+ self.assert_(a is b)
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example[::-1]+2*self.example)
+ )
+
+ b = array.array(self.badtypecode())
+ self.assertRaises(TypeError, a.__add__, b)
+
+ self.assertRaises(TypeError, a.__iadd__, "bad")
+
+ def test_mul(self):
+ a = 5*array.array(self.typecode, self.example)
+ self.assertEqual(
+ a,
+ array.array(self.typecode, 5*self.example)
+ )
+
+ a = array.array(self.typecode, self.example)*5
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example*5)
+ )
+
+ a = 0*array.array(self.typecode, self.example)
+ self.assertEqual(
+ a,
+ array.array(self.typecode)
+ )
+
+ a = (-1)*array.array(self.typecode, self.example)
+ self.assertEqual(
+ a,
+ array.array(self.typecode)
+ )
+
+ self.assertRaises(TypeError, a.__mul__, "bad")
+
+ def test_imul(self):
+ a = array.array(self.typecode, self.example)
+ b = a
+
+ a *= 5
+ self.assert_(a is b)
+ self.assertEqual(
+ a,
+ array.array(self.typecode, 5*self.example)
+ )
+
+ a *= 0
+ self.assert_(a is b)
+ self.assertEqual(a, array.array(self.typecode))
+
+ a *= 1000
+ self.assert_(a is b)
+ self.assertEqual(a, array.array(self.typecode))
+
+ a *= -1
+ self.assert_(a is b)
+ self.assertEqual(a, array.array(self.typecode))
+
+ a = array.array(self.typecode, self.example)
+ a *= -1
+ self.assertEqual(a, array.array(self.typecode))
+
+ self.assertRaises(TypeError, a.__imul__, "bad")
+
+ def test_getitem(self):
+ a = array.array(self.typecode, self.example)
+ self.assertEntryEqual(a[0], self.example[0])
+ self.assertEntryEqual(a[0L], self.example[0])
+ self.assertEntryEqual(a[-1], self.example[-1])
+ self.assertEntryEqual(a[-1L], self.example[-1])
+ self.assertEntryEqual(a[len(self.example)-1], self.example[-1])
+ self.assertEntryEqual(a[-len(self.example)], self.example[0])
+ self.assertRaises(TypeError, a.__getitem__)
+ self.assertRaises(IndexError, a.__getitem__, len(self.example))
+ self.assertRaises(IndexError, a.__getitem__, -len(self.example)-1)
+
+ def test_setitem(self):
+ a = array.array(self.typecode, self.example)
+ a[0] = a[-1]
+ self.assertEntryEqual(a[0], a[-1])
+
+ a = array.array(self.typecode, self.example)
+ a[0L] = a[-1]
+ self.assertEntryEqual(a[0], a[-1])
+
+ a = array.array(self.typecode, self.example)
+ a[-1] = a[0]
+ self.assertEntryEqual(a[0], a[-1])
+
+ a = array.array(self.typecode, self.example)
+ a[-1L] = a[0]
+ self.assertEntryEqual(a[0], a[-1])
+
+ a = array.array(self.typecode, self.example)
+ a[len(self.example)-1] = a[0]
+ self.assertEntryEqual(a[0], a[-1])
+
+ a = array.array(self.typecode, self.example)
+ a[-len(self.example)] = a[-1]
+ self.assertEntryEqual(a[0], a[-1])
+
+ self.assertRaises(TypeError, a.__setitem__)
+ self.assertRaises(TypeError, a.__setitem__, None)
+ self.assertRaises(TypeError, a.__setitem__, 0, None)
+ self.assertRaises(
+ IndexError,
+ a.__setitem__,
+ len(self.example), self.example[0]
+ )
+ self.assertRaises(
+ IndexError,
+ a.__setitem__,
+ -len(self.example)-1, self.example[0]
+ )
+
+ def test_delitem(self):
+ a = array.array(self.typecode, self.example)
+ del a[0]
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example[1:])
+ )
+
+ a = array.array(self.typecode, self.example)
+ del a[-1]
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example[:-1])
+ )
+
+ a = array.array(self.typecode, self.example)
+ del a[len(self.example)-1]
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example[:-1])
+ )
+
+ a = array.array(self.typecode, self.example)
+ del a[-len(self.example)]
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example[1:])
+ )
+
+ self.assertRaises(TypeError, a.__delitem__)
+ self.assertRaises(TypeError, a.__delitem__, None)
+ self.assertRaises(IndexError, a.__delitem__, len(self.example))
+ self.assertRaises(IndexError, a.__delitem__, -len(self.example)-1)
+
+ def test_getslice(self):
+ a = array.array(self.typecode, self.example)
+ self.assertEqual(a[:], a)
+
+ self.assertEqual(
+ a[1:],
+ array.array(self.typecode, self.example[1:])
+ )
+
+ self.assertEqual(
+ a[:1],
+ array.array(self.typecode, self.example[:1])
+ )
+
+ self.assertEqual(
+ a[:-1],
+ array.array(self.typecode, self.example[:-1])
+ )
+
+ self.assertEqual(
+ a[-1:],
+ array.array(self.typecode, self.example[-1:])
+ )
+
+ self.assertEqual(
+ a[-1:-1],
+ array.array(self.typecode)
+ )
+
+ self.assertEqual(
+ a[1000:],
+ array.array(self.typecode)
+ )
+ self.assertEqual(a[-1000:], a)
+ self.assertEqual(a[:1000], a)
+ self.assertEqual(
+ a[:-1000],
+ array.array(self.typecode)
+ )
+ self.assertEqual(a[-1000:1000], a)
+ self.assertEqual(
+ a[2000:1000],
+ array.array(self.typecode)
+ )
+
+ def test_setslice(self):
+ a = array.array(self.typecode, self.example)
+ a[:1] = a
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example + self.example[1:])
+ )
+
+ a = array.array(self.typecode, self.example)
a[:-1] = a
- if a != array.array(type, "abcdee"):
- raise TestFailed, "array(%s) self-slice-assign (head)" % `type`
- a = array.array(type, "abcde")
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example + self.example[-1:])
+ )
+
+ a = array.array(self.typecode, self.example)
+ a[-1:] = a
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example[:-1] + self.example)
+ )
+
+ a = array.array(self.typecode, self.example)
a[1:] = a
- if a != array.array(type, "aabcde"):
- raise TestFailed, "array(%s) self-slice-assign (tail)" % `type`
- a = array.array(type, "abcde")
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example[:1] + self.example)
+ )
+
+ a = array.array(self.typecode, self.example)
a[1:-1] = a
- if a != array.array(type, "aabcdee"):
- raise TestFailed, "array(%s) self-slice-assign (cntr)" % `type`
- if a.index("e") != 5:
- raise TestFailed, "array(%s) index-test" % `type`
- if a.count("a") != 2:
- raise TestFailed, "array(%s) count-test" % `type`
- a.remove("e")
- if a != array.array(type, "aabcde"):
- raise TestFailed, "array(%s) remove-test" % `type`
- if a.pop(0) != "a":
- raise TestFailed, "array(%s) pop-test" % `type`
- if a.pop(1) != "b":
- raise TestFailed, "array(%s) pop-test" % `type`
- a.extend(array.array(type, "xyz"))
- if a != array.array(type, "acdexyz"):
- raise TestFailed, "array(%s) extend-test" % `type`
- a.pop()
- a.pop()
- a.pop()
- x = a.pop()
- if x != 'e':
- raise TestFailed, "array(%s) pop-test" % `type`
- if a != array.array(type, "acd"):
- raise TestFailed, "array(%s) pop-test" % `type`
+ self.assertEqual(
+ a,
+ array.array(
+ self.typecode,
+ self.example[:1] + self.example + self.example[-1:]
+ )
+ )
+
+ a = array.array(self.typecode, self.example)
+ a[1000:] = a
+ self.assertEqual(
+ a,
+ array.array(self.typecode, 2*self.example)
+ )
+
+ a = array.array(self.typecode, self.example)
+ a[-1000:] = a
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example)
+ )
+
+ a = array.array(self.typecode, self.example)
+ a[:1000] = a
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example)
+ )
+
+ a = array.array(self.typecode, self.example)
+ a[:-1000] = a
+ self.assertEqual(
+ a,
+ array.array(self.typecode, 2*self.example)
+ )
+
+ a = array.array(self.typecode, self.example)
+ a[1:0] = a
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example[:1] + self.example + self.example[1:])
+ )
+
+ a = array.array(self.typecode, self.example)
+ a[2000:1000] = a
+ self.assertEqual(
+ a,
+ array.array(self.typecode, 2*self.example)
+ )
+
+ a = array.array(self.typecode, self.example)
+ self.assertRaises(TypeError, a.__setslice__, 0, 0, None)
+ self.assertRaises(TypeError, a.__setitem__, slice(0, 1), None)
+
+ b = array.array(self.badtypecode())
+ self.assertRaises(TypeError, a.__setslice__, 0, 0, b)
+ self.assertRaises(TypeError, a.__setitem__, slice(0, 1), b)
+
+ def test_index(self):
+ example = 2*self.example
+ a = array.array(self.typecode, example)
+ self.assertRaises(TypeError, a.index)
+ for x in example:
+ self.assertEqual(a.index(x), example.index(x))
+ self.assertRaises(ValueError, a.index, None)
+ self.assertRaises(ValueError, a.index, self.outside)
+
+ def test_count(self):
+ example = 2*self.example
+ a = array.array(self.typecode, example)
+ self.assertRaises(TypeError, a.count)
+ for x in example:
+ self.assertEqual(a.count(x), example.count(x))
+ self.assertEqual(a.count(self.outside), 0)
+ self.assertEqual(a.count(None), 0)
+
+ def test_remove(self):
+ for x in self.example:
+ example = 2*self.example
+ a = array.array(self.typecode, example)
+ pos = example.index(x)
+ example2 = example[:pos] + example[pos+1:]
+ a.remove(x)
+ self.assertEqual(a, array.array(self.typecode, example2))
+
+ a = array.array(self.typecode, self.example)
+ self.assertRaises(ValueError, a.remove, self.outside)
+
+ self.assertRaises(ValueError, a.remove, None)
+
+ def test_pop(self):
+ a = array.array(self.typecode)
+ self.assertRaises(IndexError, a.pop)
+
+ a = array.array(self.typecode, 2*self.example)
+ self.assertRaises(TypeError, a.pop, 42, 42)
+ self.assertRaises(TypeError, a.pop, None)
+ self.assertRaises(IndexError, a.pop, len(a))
+ self.assertRaises(IndexError, a.pop, -len(a)-1)
+
+ self.assertEntryEqual(a.pop(0), self.example[0])
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example[1:]+self.example)
+ )
+ self.assertEntryEqual(a.pop(1), self.example[2])
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example[1:2]+self.example[3:]+self.example)
+ )
+ self.assertEntryEqual(a.pop(0), self.example[1])
+ self.assertEntryEqual(a.pop(), self.example[-1])
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example[3:]+self.example[:-1])
+ )
+
+ def test_reverse(self):
+ a = array.array(self.typecode, self.example)
+ self.assertRaises(TypeError, a.reverse, 42)
a.reverse()
- if a != array.array(type, "dca"):
- raise TestFailed, "array(%s) reverse-test" % `type`
- elif type == 'u':
- a = array.array(type, unicode("abcde", 'ascii'))
- a[:-1] = a
- if a != array.array(type, unicode("abcdee", 'ascii')):
- raise TestFailed, "array(%s) self-slice-assign (head)" % `type`
- a = array.array(type, unicode("abcde", 'ascii'))
- a[1:] = a
- if a != array.array(type, unicode("aabcde", 'ascii')):
- raise TestFailed, "array(%s) self-slice-assign (tail)" % `type`
- a = array.array(type, unicode("abcde", 'ascii'))
- a[1:-1] = a
- if a != array.array(type, unicode("aabcdee", 'ascii')):
- raise TestFailed, "array(%s) self-slice-assign (cntr)" % `type`
- if a.index(unicode("e", 'ascii')) != 5:
- raise TestFailed, "array(%s) index-test" % `type`
- if a.count(unicode("a", 'ascii')) != 2:
- raise TestFailed, "array(%s) count-test" % `type`
- a.remove(unicode("e", 'ascii'))
- if a != array.array(type, unicode("aabcde", 'ascii')):
- raise TestFailed, "array(%s) remove-test" % `type`
- if a.pop(0) != unicode("a", 'ascii'):
- raise TestFailed, "array(%s) pop-test" % `type`
- if a.pop(1) != unicode("b", 'ascii'):
- raise TestFailed, "array(%s) pop-test" % `type`
- a.extend(array.array(type, unicode("xyz", 'ascii')))
- if a != array.array(type, unicode("acdexyz", 'ascii')):
- raise TestFailed, "array(%s) extend-test" % `type`
- a.pop()
- a.pop()
- a.pop()
- x = a.pop()
- if x != unicode('e', 'ascii'):
- raise TestFailed, "array(%s) pop-test" % `type`
- if a != array.array(type, unicode("acd", 'ascii')):
- raise TestFailed, "array(%s) pop-test" % `type`
- a.reverse()
- if a != array.array(type, unicode("dca", 'ascii')):
- raise TestFailed, "array(%s) reverse-test" % `type`
- else:
- a = array.array(type, [1, 2, 3, 4, 5])
- a[:-1] = a
- if a != array.array(type, [1, 2, 3, 4, 5, 5]):
- raise TestFailed, "array(%s) self-slice-assign (head)" % `type`
- a = array.array(type, [1, 2, 3, 4, 5])
- a[1:] = a
- if a != array.array(type, [1, 1, 2, 3, 4, 5]):
- raise TestFailed, "array(%s) self-slice-assign (tail)" % `type`
- a = array.array(type, [1, 2, 3, 4, 5])
- a[1:-1] = a
- if a != array.array(type, [1, 1, 2, 3, 4, 5, 5]):
- raise TestFailed, "array(%s) self-slice-assign (cntr)" % `type`
- if a.index(5) != 5:
- raise TestFailed, "array(%s) index-test" % `type`
- if a.count(1) != 2:
- raise TestFailed, "array(%s) count-test" % `type`
- a.remove(5)
- if a != array.array(type, [1, 1, 2, 3, 4, 5]):
- raise TestFailed, "array(%s) remove-test" % `type`
- if a.pop(0) != 1:
- raise TestFailed, "array(%s) pop-test" % `type`
- if a.pop(1) != 2:
- raise TestFailed, "array(%s) pop-test" % `type`
- a.extend(array.array(type, [7, 8, 9]))
- if a != array.array(type, [1, 3, 4, 5, 7, 8, 9]):
- raise TestFailed, "array(%s) extend-test" % `type`
- a.pop()
- a.pop()
- a.pop()
- x = a.pop()
- if x != 5:
- raise TestFailed, "array(%s) pop-test" % `type`
- if a != array.array(type, [1, 3, 4]):
- raise TestFailed, "array(%s) pop-test" % `type`
- a.reverse()
- if a != array.array(type, [4, 3, 1]):
- raise TestFailed, "array(%s) reverse-test" % `type`
- # extended slicing
- # subscription
- a = array.array(type, [0,1,2,3,4])
- vereq(a[::], a)
- vereq(a[::2], array.array(type, [0,2,4]))
- vereq(a[1::2], array.array(type, [1,3]))
- vereq(a[::-1], array.array(type, [4,3,2,1,0]))
- vereq(a[::-2], array.array(type, [4,2,0]))
- vereq(a[3::-2], array.array(type, [3,1]))
- vereq(a[-100:100:], a)
- vereq(a[100:-100:-1], a[::-1])
- vereq(a[-100L:100L:2L], array.array(type, [0,2,4]))
- vereq(a[1000:2000:2], array.array(type, []))
- vereq(a[-1000:-2000:-2], array.array(type, []))
- # deletion
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example[::-1])
+ )
+
+ def test_extend(self):
+ a = array.array(self.typecode, self.example)
+ self.assertRaises(TypeError, a.extend)
+ a.extend(array.array(self.typecode, self.example[::-1]))
+ self.assertEqual(
+ a,
+ array.array(self.typecode, self.example+self.example[::-1])
+ )
+
+ b = array.array(self.badtypecode())
+ self.assertRaises(TypeError, a.extend, b)
+
+ def test_coveritertraverse(self):
+ try:
+ import gc
+ except ImportError:
+ return
+ a = array.array(self.typecode)
+ l = [iter(a)]
+ l.append(l)
+ gc.collect()
+
+ def test_buffer(self):
+ a = array.array(self.typecode, self.example)
+ b = buffer(a)
+ self.assertEqual(b[0], a.tostring()[0])
+
+class StringTest(BaseTest):
+
+ def test_setitem(self):
+ super(StringTest, self).test_setitem()
+ a = array.array(self.typecode, self.example)
+ self.assertRaises(TypeError, a.__setitem__, 0, self.example[:2])
+
+class CharacterTest(StringTest):
+ typecode = 'c'
+ example = '\x01azAZ\x00\xfe'
+ smallerexample = '\x01azAY\x00\xfe'
+ biggerexample = '\x01azAZ\x00\xff'
+ outside = '\x33'
+ minitemsize = 1
+
+ def test_subbclassing(self):
+ class EditableString(array.array):
+ def __new__(cls, s, *args, **kwargs):
+ return array.array.__new__(cls, 'c', s)
+
+ def __init__(self, s, color='blue'):
+ array.array.__init__(self, 'c', s)
+ self.color = color
+
+ def strip(self):
+ self[:] = array.array('c', self.tostring().strip())
+
+ def __repr__(self):
+ return 'EditableString(%r)' % self.tostring()
+
+ s = EditableString("\ttest\r\n")
+ s.strip()
+ self.assertEqual(s.tostring(), "test")
+
+ self.assertEqual(s.color, "blue")
+ s.color = "red"
+ self.assertEqual(s.color, "red")
+ self.assertEqual(s.__dict__.keys(), ["color"])
+
+ def test_nounicode(self):
+ a = array.array(self.typecode, self.example)
+ self.assertRaises(ValueError, a.fromunicode, unicode(''))
+ self.assertRaises(ValueError, a.tounicode)
+
+tests.append(CharacterTest)
+
+if test_support.have_unicode:
+ class UnicodeTest(StringTest):
+ typecode = 'u'
+ example = unicode(r'\x01\u263a\x00\ufeff', 'unicode-escape')
+ smallerexample = unicode(r'\x01\u263a\x00\ufefe', 'unicode-escape')
+ biggerexample = unicode(r'\x01\u263a\x01\ufeff', 'unicode-escape')
+ outside = unicode('\x33')
+ minitemsize = 2
+
+ def test_unicode(self):
+ self.assertRaises(TypeError, array.array, 'b', unicode('foo', 'ascii'))
+
+ a = array.array('u', unicode(r'\xa0\xc2\u1234', 'unicode-escape'))
+ a.fromunicode(unicode(' ', 'ascii'))
+ a.fromunicode(unicode('', 'ascii'))
+ a.fromunicode(unicode('', 'ascii'))
+ a.fromunicode(unicode(r'\x11abc\xff\u1234', 'unicode-escape'))
+ s = a.tounicode()
+ self.assertEqual(
+ s,
+ unicode(r'\xa0\xc2\u1234 \x11abc\xff\u1234', 'unicode-escape')
+ )
+
+ s = unicode(r'\x00="\'a\\b\x80\xff\u0000\u0001\u1234', 'unicode-escape')
+ a = array.array('u', s)
+ self.assertEqual(
+ repr(a),
+ r"""array('u', u'\x00="\'a\\b\x80\xff\x00\x01\u1234')"""
+ )
+
+ self.assertRaises(TypeError, a.fromunicode)
+
+ tests.append(UnicodeTest)
+
+class NumberTest(BaseTest):
+
+ def test_extslice(self):
+ a = array.array(self.typecode, range(5))
+ self.assertEqual(a[::], a)
+ self.assertEqual(a[::2], array.array(self.typecode, [0,2,4]))
+ self.assertEqual(a[1::2], array.array(self.typecode, [1,3]))
+ self.assertEqual(a[::-1], array.array(self.typecode, [4,3,2,1,0]))
+ self.assertEqual(a[::-2], array.array(self.typecode, [4,2,0]))
+ self.assertEqual(a[3::-2], array.array(self.typecode, [3,1]))
+ self.assertEqual(a[-100:100:], a)
+ self.assertEqual(a[100:-100:-1], a[::-1])
+ self.assertEqual(a[-100L:100L:2L], array.array(self.typecode, [0,2,4]))
+ self.assertEqual(a[1000:2000:2], array.array(self.typecode, []))
+ self.assertEqual(a[-1000:-2000:-2], array.array(self.typecode, []))
+
+ def test_delslice(self):
+ a = array.array(self.typecode, range(5))
del a[::2]
- vereq(a, array.array(type, [1,3]))
- a = array.array(type, range(5))
+ self.assertEqual(a, array.array(self.typecode, [1,3]))
+ a = array.array(self.typecode, range(5))
del a[1::2]
- vereq(a, array.array(type, [0,2,4]))
- a = array.array(type, range(5))
+ self.assertEqual(a, array.array(self.typecode, [0,2,4]))
+ a = array.array(self.typecode, range(5))
del a[1::-2]
- vereq(a, array.array(type, [0,2,3,4]))
- a = array.array(type, range(10))
+ self.assertEqual(a, array.array(self.typecode, [0,2,3,4]))
+ a = array.array(self.typecode, range(10))
del a[::1000]
- vereq(a, array.array(type, [1,2,3,4,5,6,7,8,9]))
- # assignment
- a = array.array(type, range(10))
- a[::2] = array.array(type, [-1]*5)
- vereq(a, array.array(type, [-1, 1, -1, 3, -1, 5, -1, 7, -1, 9]))
- a = array.array(type, range(10))
- a[::-4] = array.array(type, [10]*3)
- vereq(a, array.array(type, [0, 10, 2, 3, 4, 10, 6, 7, 8 ,10]))
- a = array.array(type, range(4))
+ self.assertEqual(a, array.array(self.typecode, [1,2,3,4,5,6,7,8,9]))
+
+ def test_assignment(self):
+ a = array.array(self.typecode, range(10))
+ a[::2] = array.array(self.typecode, [42]*5)
+ self.assertEqual(a, array.array(self.typecode, [42, 1, 42, 3, 42, 5, 42, 7, 42, 9]))
+ a = array.array(self.typecode, range(10))
+ a[::-4] = array.array(self.typecode, [10]*3)
+ self.assertEqual(a, array.array(self.typecode, [0, 10, 2, 3, 4, 10, 6, 7, 8 ,10]))
+ a = array.array(self.typecode, range(4))
a[::-1] = a
- vereq(a, array.array(type, [3, 2, 1, 0]))
- a = array.array(type, range(10))
+ self.assertEqual(a, array.array(self.typecode, [3, 2, 1, 0]))
+ a = array.array(self.typecode, range(10))
b = a[:]
c = a[:]
- ins = array.array(type, range(2))
+ ins = array.array(self.typecode, range(2))
a[2:3] = ins
b[slice(2,3)] = ins
c[2:3:] = ins
- # iteration and contains
- a = array.array(type, range(10))
- vereq(list(a), range(10))
- b = array.array(type, [20])
- vereq(a[-1] in a, True)
- vereq(b[0] not in a, True)
- # test that overflow exceptions are raised as expected for assignment
- # to array of specific integral types
- from math import pow
- if type in ('b', 'h', 'i', 'l'):
- # check signed and unsigned versions
- a = array.array(type)
- signedLowerLimit = -1 * long(pow(2, a.itemsize * 8 - 1))
- signedUpperLimit = long(pow(2, a.itemsize * 8 - 1)) - 1L
- unsignedLowerLimit = 0
- unsignedUpperLimit = long(pow(2, a.itemsize * 8)) - 1L
- testoverflow(type, signedLowerLimit, signedUpperLimit)
- testoverflow(type.upper(), unsignedLowerLimit, unsignedUpperLimit)
+ def test_iterationcontains(self):
+ a = array.array(self.typecode, range(10))
+ self.assertEqual(list(a), range(10))
+ b = array.array(self.typecode, [20])
+ self.assertEqual(a[-1] in a, True)
+ self.assertEqual(b[0] not in a, True)
+
+ def check_overflow(self, lower, upper):
+ # method to be used by subclasses
+
+ # should not overflow assigning lower limit
+ a = array.array(self.typecode, [lower])
+ a[0] = lower
+ # should overflow assigning less than lower limit
+ self.assertRaises(OverflowError, array.array, self.typecode, [lower-1])
+ self.assertRaises(OverflowError, a.__setitem__, 0, lower-1)
+ # should not overflow assigning upper limit
+ a = array.array(self.typecode, [upper])
+ a[0] = upper
+ # should overflow assigning more than upper limit
+ self.assertRaises(OverflowError, array.array, self.typecode, [upper+1])
+ self.assertRaises(OverflowError, a.__setitem__, 0, upper+1)
+
+ def test_subclassing(self):
+ typecode = self.typecode
+ class ExaggeratingArray(array.array):
+ __slots__ = ['offset']
+
+ def __new__(cls, typecode, data, offset):
+ return array.array.__new__(cls, typecode, data)
+
+ def __init__(self, typecode, data, offset):
+ self.offset = offset
+
+ def __getitem__(self, i):
+ return array.array.__getitem__(self, i) + self.offset
+
+ a = ExaggeratingArray(self.typecode, [3, 6, 7, 11], 4)
+ self.assertEntryEqual(a[0], 7)
+
+ self.assertRaises(AttributeError, setattr, a, "color", "blue")
+
+class SignedNumberTest(NumberTest):
+ example = [-1, 0, 1, 42, 0x7f]
+ smallerexample = [-1, 0, 1, 42, 0x7e]
+ biggerexample = [-1, 0, 1, 43, 0x7f]
+ outside = 23
+
+ def test_overflow(self):
+ a = array.array(self.typecode)
+ lower = -1 * long(pow(2, a.itemsize * 8 - 1))
+ upper = long(pow(2, a.itemsize * 8 - 1)) - 1L
+ self.check_overflow(lower, upper)
+
+class UnsignedNumberTest(NumberTest):
+ example = [0, 1, 17, 23, 42, 0xff]
+ smallerexample = [0, 1, 17, 23, 42, 0xfe]
+ biggerexample = [0, 1, 17, 23, 43, 0xff]
+ outside = 0xaa
+
+ def test_overflow(self):
+ a = array.array(self.typecode)
+ lower = 0
+ upper = long(pow(2, a.itemsize * 8)) - 1L
+ self.check_overflow(lower, upper)
+class ByteTest(SignedNumberTest):
+ typecode = 'b'
+ minitemsize = 1
+tests.append(ByteTest)
-main()
+class UnsignedByteTest(UnsignedNumberTest):
+ typecode = 'B'
+ minitemsize = 1
+tests.append(UnsignedByteTest)
+
+class ShortTest(SignedNumberTest):
+ typecode = 'h'
+ minitemsize = 2
+tests.append(ShortTest)
+
+class UnsignedShortTest(UnsignedNumberTest):
+ typecode = 'H'
+ minitemsize = 2
+tests.append(UnsignedShortTest)
+
+class IntTest(SignedNumberTest):
+ typecode = 'i'
+ minitemsize = 2
+tests.append(IntTest)
+
+class UnsignedIntTest(UnsignedNumberTest):
+ typecode = 'I'
+ minitemsize = 2
+tests.append(UnsignedIntTest)
+
+class LongTest(SignedNumberTest):
+ typecode = 'l'
+ minitemsize = 4
+tests.append(LongTest)
+
+class UnsignedLongTest(UnsignedNumberTest):
+ typecode = 'L'
+ minitemsize = 4
+tests.append(UnsignedLongTest)
+
+class FPTest(NumberTest):
+ example = [-42.0, 0, 42, 1e5, -1e10]
+ smallerexample = [-42.0, 0, 42, 1e5, -2e10]
+ biggerexample = [-42.0, 0, 42, 1e5, 1e10]
+ outside = 23
+
+ def assertEntryEqual(self, entry1, entry2):
+ self.assertAlmostEqual(entry1, entry2)
+
+class FloatTest(FPTest):
+ typecode = 'f'
+ minitemsize = 4
+tests.append(FloatTest)
+
+class DoubleTest(FPTest):
+ typecode = 'd'
+ minitemsize = 8
+tests.append(DoubleTest)
+
+def test_main():
+ test_support.run_unittest(*tests)
+
+if __name__=="__main__":
+ test_main()
+
+
+#main()