diff options
Diffstat (limited to 'Lib')
| -rw-r--r-- | Lib/test/output/test_winsound | 2 | ||||
| -rwxr-xr-x | Lib/test/test_array.py | 1184 | ||||
| -rw-r--r-- | Lib/test/test_winsound.py | 114 |
3 files changed, 920 insertions, 380 deletions
diff --git a/Lib/test/output/test_winsound b/Lib/test/output/test_winsound deleted file mode 100644 index f361e93..0000000 --- a/Lib/test/output/test_winsound +++ /dev/null @@ -1,2 +0,0 @@ -test_winsound -Hopefully you heard some sounds increasing in frequency! 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) - -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]) + +import unittest +from test import test_support +import array, cStringIO, math + +tests = [] # list to accumulate all tests +typecodes = "cubBhHiIlLfd" + +class BadConstructorTest(unittest.TestCase): + + 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') + +tests.append(BadConstructorTest) + +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 assertEntryEqual(self, entry1, entry2): + self.assertEqual(entry1, entry2) + + def badtypecode(self): + # Return a typecode that is different from our own + return typecodes[(typecodes.index(self.typecode)+1) % len(typecodes)] + + 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) + + def test_len(self): + a = array.array(self.typecode) + a.append(self.example[0]) + self.assertEqual(len(a), 1) + + a = array.array(self.typecode, self.example) + self.assertEqual(len(a), len(self.example)) + + 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 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) + + 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 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})) + + a = array.array(self.typecode) + self.assertEqual(repr(a), "array('%s')" % self.typecode) + + def test_str(self): + a = array.array(self.typecode, 2*self.example) + str(a) + + def test_cmp(self): + a = array.array(self.typecode, self.example) + self.assert_((a == 42) is False) + self.assert_((a != 42) is True) + + 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) + + as = array.array(self.typecode, self.smallerexample) + ab = array.array(self.typecode, self.biggerexample) + + 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) + + 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) + + 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) + + 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]) + ) + + 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, [1, 2, 3, 4, 5, 5]): - raise TestFailed, "array(%s) self-slice-assign (head)" % `type` - a = array.array(type, [1, 2, 3, 4, 5]) + 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, [1, 1, 2, 3, 4, 5]): - raise TestFailed, "array(%s) self-slice-assign (tail)" % `type` - a = array.array(type, [1, 2, 3, 4, 5]) + 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, [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` + 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, [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) - - - -main() + + 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) + +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() diff --git a/Lib/test/test_winsound.py b/Lib/test/test_winsound.py index be0b471..def8c87 100644 --- a/Lib/test/test_winsound.py +++ b/Lib/test/test_winsound.py @@ -1,18 +1,102 @@ # Ridiculously simple test of the winsound module for Windows. +import unittest +from test import test_support import winsound, time -for i in range(100, 2000, 100): - winsound.Beep(i, 75) -print "Hopefully you heard some sounds increasing in frequency!" -winsound.MessageBeep() -time.sleep(0.5) -winsound.MessageBeep(winsound.MB_OK) -time.sleep(0.5) -winsound.MessageBeep(winsound.MB_ICONASTERISK) -time.sleep(0.5) -winsound.MessageBeep(winsound.MB_ICONEXCLAMATION) -time.sleep(0.5) -winsound.MessageBeep(winsound.MB_ICONHAND) -time.sleep(0.5) -winsound.MessageBeep(winsound.MB_ICONQUESTION) -time.sleep(0.5) + +class BeepTest(unittest.TestCase): + + def test_errors(self): + self.assertRaises(TypeError, winsound.Beep) + self.assertRaises(ValueError, winsound.Beep, 36, 75) + self.assertRaises(ValueError, winsound.Beep, 32768, 75) + + def test_extremes(self): + winsound.Beep(37, 75) + winsound.Beep(32767, 75) + + def test_increasingfrequency(self): + for i in xrange(100, 2000, 100): + winsound.Beep(i, 75) + +class MessageBeepTest(unittest.TestCase): + + def tearDown(self): + time.sleep(0.5) + + def test_default(self): + self.assertRaises(TypeError, winsound.MessageBeep, "bad") + self.assertRaises(TypeError, winsound.MessageBeep, 42, 42) + winsound.MessageBeep() + + def test_ok(self): + winsound.MessageBeep(winsound.MB_OK) + + def test_asterisk(self): + winsound.MessageBeep(winsound.MB_ICONASTERISK) + + def test_exclamation(self): + winsound.MessageBeep(winsound.MB_ICONEXCLAMATION) + + def test_hand(self): + winsound.MessageBeep(winsound.MB_ICONHAND) + + def test_question(self): + winsound.MessageBeep(winsound.MB_ICONQUESTION) + +class PlaySoundTest(unittest.TestCase): + + def test_errors(self): + self.assertRaises(TypeError, winsound.PlaySound) + self.assertRaises(TypeError, winsound.PlaySound, "bad", "bad") + self.assertRaises( + RuntimeError, + winsound.PlaySound, + "none", winsound.SND_ASYNC | winsound.SND_MEMORY + ) + + def test_alias_asterisk(self): + winsound.PlaySound('SystemAsterisk', winsound.SND_ALIAS) + + def test_alias_exclamation(self): + winsound.PlaySound('SystemExclamation', winsound.SND_ALIAS) + + def test_alias_exit(self): + winsound.PlaySound('SystemExit', winsound.SND_ALIAS) + + def test_alias_hand(self): + winsound.PlaySound('SystemHand', winsound.SND_ALIAS) + + def test_alias_question(self): + winsound.PlaySound('SystemQuestion', winsound.SND_ALIAS) + + def test_alias_fallback(self): + winsound.PlaySound('!"$%&/(#+*', winsound.SND_ALIAS) + + def test_alias_nofallback(self): + try: + winsound.PlaySound( + '!"$%&/(#+*', + winsound.SND_ALIAS | winsound.SND_NODEFAULT + ) + except RuntimeError: + pass + + def test_stopasync(self): + winsound.PlaySound( + 'SystemQuestion', + winsound.SND_ALIAS | winsound.SND_ASYNC | winsound.SND_LOOP + ) + time.sleep(0.5) + self.assertRaises( + RuntimeError, + winsound.PlaySound, + 'SystemQuestion', winsound.SND_ALIAS | winsound.SND_NOSTOP + ) + winsound.PlaySound(None, winsound.SND_PURGE) + +def test_main(): + test_support.run_unittest(BeepTest, MessageBeepTest, PlaySoundTest) + +if __name__=="__main__": + test_main() |