376 lines
14 KiB
Python
Executable File
376 lines
14 KiB
Python
Executable File
#! /usr/bin/env python
|
|
"""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)
|
|
|
|
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")
|
|
|
|
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()")
|
|
|
|
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 testsubclassing():
|
|
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()
|
|
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__"
|
|
|
|
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('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 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 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()
|
|
|
|
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
|
|
|
|
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()
|
|
|
|
# This block is just to verify that the operations don't blow up.
|
|
a.tolist()
|
|
a.tostring()
|
|
repr(a)
|
|
str(a)
|
|
|
|
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()`
|
|
|
|
# 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`
|
|
|
|
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`
|
|
|
|
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`
|
|
|
|
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`
|
|
|
|
if type == 'c':
|
|
a = array.array(type, "abcde")
|
|
a[:-1] = a
|
|
if a != array.array(type, "abcdee"):
|
|
raise TestFailed, "array(%s) self-slice-assign (head)" % `type`
|
|
a = array.array(type, "abcde")
|
|
a[1:] = a
|
|
if a != array.array(type, "aabcde"):
|
|
raise TestFailed, "array(%s) self-slice-assign (tail)" % `type`
|
|
a = array.array(type, "abcde")
|
|
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`
|
|
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
|
|
del a[::2]
|
|
vereq(a, array.array(type, [1,3]))
|
|
a = array.array(type, range(5))
|
|
del a[1::2]
|
|
vereq(a, array.array(type, [0,2,4]))
|
|
a = array.array(type, range(5))
|
|
del a[1::-2]
|
|
vereq(a, array.array(type, [0,2,3,4]))
|
|
a = array.array(type, 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))
|
|
a[::-1] = a
|
|
vereq(a, array.array(type, [3, 2, 1, 0]))
|
|
a = array.array(type, range(10))
|
|
b = a[:]
|
|
c = a[:]
|
|
ins = array.array(type, range(2))
|
|
a[2:3] = ins
|
|
b[slice(2,3)] = ins
|
|
c[2:3:] = ins
|
|
|
|
# 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)
|
|
|
|
|
|
|
|
main()
|