diff -r b54b4c119a33 Lib/test/test_bytes.py --- a/Lib/test/test_bytes.py Wed Jan 30 10:51:48 2008 +0100 +++ b/Lib/test/test_bytes.py Wed Jan 30 11:55:00 2008 +0100 @@ -13,9 +13,24 @@ import tempfile import tempfile import unittest import warnings +import functools import test.test_support import test.string_tests import test.buffer_tests + + +def with_types(*types): + def decorator(f): + @functools.wraps(f) + def wrapped(self): + for typ in types: + try: + f(self, typ) + except AssertionError as e: + e.args = ('with %s: %s' % (typ, e.args[0]),) + raise e + return wrapped + return decorator class BytesTest(unittest.TestCase): @@ -26,13 +41,15 @@ class BytesTest(unittest.TestCase): def tearDown(self): warnings.filters = self.warning_filters - def test_basics(self): - b = bytearray() - self.assertEqual(type(b), bytearray) - self.assertEqual(b.__class__, bytearray) + @with_types(bytes, bytearray) + def test_basics(self, typ): + b = typ() + self.assertEqual(type(b), typ) + self.assertEqual(b.__class__, typ) - def test_empty_sequence(self): - b = bytearray() + @with_types(bytes, bytearray) + def test_empty_sequence(self, typ): + b = typ() self.assertEqual(len(b), 0) self.assertRaises(IndexError, lambda: b[0]) self.assertRaises(IndexError, lambda: b[1]) @@ -46,24 +63,27 @@ class BytesTest(unittest.TestCase): self.assertRaises(IndexError, lambda: b[-sys.maxsize-2]) self.assertRaises(IndexError, lambda: b[-10**100]) - def test_from_list(self): + @with_types(bytes, bytearray) + def test_from_list(self, typ): ints = list(range(256)) - b = bytearray(i for i in ints) + b = typ(i for i in ints) self.assertEqual(len(b), 256) self.assertEqual(list(b), ints) - def test_from_index(self): + @with_types(bytes, bytearray) + def test_from_index(self, typ): class C: def __init__(self, i=0): self.i = i def __index__(self): return self.i - b = bytearray([C(), C(1), C(254), C(255)]) + b = typ([C(), C(1), C(254), C(255)]) self.assertEqual(list(b), [0, 1, 254, 255]) self.assertRaises(ValueError, bytearray, [C(-1)]) self.assertRaises(ValueError, bytearray, [C(256)]) - def test_from_ssize(self): + @with_types(bytes, bytearray) + def test_from_ssize(self, typ): self.assertEqual(bytearray(0), b'') self.assertEqual(bytearray(1), b'\x00') self.assertEqual(bytearray(5), b'\x00\x00\x00\x00\x00') @@ -72,26 +92,28 @@ class BytesTest(unittest.TestCase): self.assertEqual(bytearray('0', 'ascii'), b'0') self.assertEqual(bytearray(b'0'), b'0') - def test_constructor_type_errors(self): - self.assertRaises(TypeError, bytearray, 0.0) + @with_types(bytes, bytearray) + def test_constructor_type_errors(self, typ): + self.assertRaises(TypeError, typ, 0.0) class C: pass - self.assertRaises(TypeError, bytearray, ["0"]) - self.assertRaises(TypeError, bytearray, [0.0]) - self.assertRaises(TypeError, bytearray, [None]) - self.assertRaises(TypeError, bytearray, [C()]) + self.assertRaises(TypeError, typ, ["0"]) + self.assertRaises(TypeError, typ, [0.0]) + self.assertRaises(TypeError, typ, [None]) + self.assertRaises(TypeError, typ, [C()]) - def test_constructor_value_errors(self): - self.assertRaises(ValueError, bytearray, [-1]) - self.assertRaises(ValueError, bytearray, [-sys.maxsize]) - self.assertRaises(ValueError, bytearray, [-sys.maxsize-1]) - self.assertRaises(ValueError, bytearray, [-sys.maxsize-2]) - self.assertRaises(ValueError, bytearray, [-10**100]) - self.assertRaises(ValueError, bytearray, [256]) - self.assertRaises(ValueError, bytearray, [257]) - self.assertRaises(ValueError, bytearray, [sys.maxsize]) - self.assertRaises(ValueError, bytearray, [sys.maxsize+1]) - self.assertRaises(ValueError, bytearray, [10**100]) + @with_types(bytes, bytearray) + def test_constructor_value_errors(self, typ): + self.assertRaises(ValueError, typ, [-1]) + self.assertRaises(ValueError, typ, [-sys.maxsize]) + self.assertRaises(ValueError, typ, [-sys.maxsize-1]) + self.assertRaises(ValueError, typ, [-sys.maxsize-2]) + self.assertRaises(ValueError, typ, [-10**100]) + self.assertRaises(ValueError, typ, [256]) + self.assertRaises(ValueError, typ, [257]) + self.assertRaises(ValueError, typ, [sys.maxsize]) + self.assertRaises(ValueError, typ, [sys.maxsize+1]) + self.assertRaises(ValueError, typ, [10**100]) def test_repr_str(self): warnings.simplefilter('ignore', BytesWarning) @@ -101,14 +123,15 @@ class BytesTest(unittest.TestCase): self.assertEqual(f(bytearray([0, 1, 254, 255])), "bytearray(b'\\x00\\x01\\xfe\\xff')") self.assertEqual(f(b"abc"), "b'abc'") - self.assertEqual(f(b"'"), '''b"'"''') - self.assertEqual(f(b"'\""), r"""b'\'"'""") + self.assertEqual(f(b"'"), '''b"'"''') # ''' + self.assertEqual(f(b"'\""), r"""b'\'"'""") # ' - def test_compare(self): - b1 = bytearray([1, 2, 3]) - b2 = bytearray([1, 2, 3]) - b3 = bytearray([1, 3]) + @with_types(bytes, bytearray) + def test_compare(self, typ): + b1 = typ([1, 2, 3]) + b2 = typ([1, 2, 3]) + b3 = typ([1, 3]) self.assertEqual(b1, b2) self.failUnless(b2 != b3) @@ -157,16 +180,17 @@ class BytesTest(unittest.TestCase): self.assertEqual(bytes(b"abc") < b"ab", False) self.assertEqual(bytes(b"abc") <= b"ab", False) - def test_compare_to_str(self): + @with_types(bytes, bytearray) + def test_compare_to_str(self, typ): warnings.simplefilter('ignore', BytesWarning) # Byte comparisons with unicode should always fail! # Test this for all expected byte orders and Unicode character sizes - self.assertEqual(b"\0a\0b\0c" == "abc", False) - self.assertEqual(b"\0\0\0a\0\0\0b\0\0\0c" == "abc", False) - self.assertEqual(b"a\0b\0c\0" == "abc", False) - self.assertEqual(b"a\0\0\0b\0\0\0c\0\0\0" == "abc", False) - self.assertEqual(bytearray() == str(), False) - self.assertEqual(bytearray() != str(), True) + self.assertEqual(typ(b"\0a\0b\0c") == "abc", False) + self.assertEqual(typ(b"\0\0\0a\0\0\0b\0\0\0c") == "abc", False) + self.assertEqual(typ(b"a\0b\0c\0") == "abc", False) + self.assertEqual(typ(b"a\0\0\0b\0\0\0c\0\0\0") == "abc", False) + self.assertEqual(typ() == str(), False) + self.assertEqual(typ() != str(), True) def test_nohash(self): self.assertRaises(TypeError, hash, bytearray()) @@ -203,9 +227,10 @@ class BytesTest(unittest.TestCase): except os.error: pass - def test_reversed(self): + @with_types(bytes, bytearray) + def test_reversed(self, typ): input = list(map(ord, "Hello")) - b = bytearray(input) + b = typ(input) output = list(reversed(b)) input.reverse() self.assertEqual(output, input) @@ -221,9 +246,10 @@ class BytesTest(unittest.TestCase): b.reverse() self.assertFalse(b) - def test_getslice(self): + @with_types(bytes, bytearray) + def test_getslice(self, typ): def by(s): - return bytearray(map(ord, s)) + return typ(map(ord, s)) b = by("Hello, world") self.assertEqual(b[:5], by("Hello")) @@ -241,16 +267,17 @@ class BytesTest(unittest.TestCase): self.assertEqual(b[-5:100], by("world")) self.assertEqual(b[-100:5], by("Hello")) - def test_extended_getslice(self): + @with_types(bytes, bytearray) + def test_extended_getslice(self, typ): # Test extended slicing by comparing with list slicing. L = list(range(255)) - b = bytearray(L) + b = typ(L) indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100) for start in indices: for stop in indices: # Skip step 0 (invalid) for step in indices[1:]: - self.assertEqual(b[start:stop:step], bytearray(L[start:stop:step])) + self.assertEqual(b[start:stop:step], typ(L[start:stop:step])) def test_regexps(self): def by(s): @@ -355,22 +382,24 @@ class BytesTest(unittest.TestCase): b[8:] = b self.assertEqual(b, bytearray(list(range(8)) + list(range(256)))) - def test_encoding(self): + @with_types(bytes, bytearray) + def test_encoding(self, typ): sample = "Hello world\n\u1234\u5678\u9abc\udef0" for enc in ("utf8", "utf16"): - b = bytearray(sample, enc) - self.assertEqual(b, bytearray(sample.encode(enc))) - self.assertRaises(UnicodeEncodeError, bytearray, sample, "latin1") - b = bytearray(sample, "latin1", "ignore") - self.assertEqual(b, bytearray(sample[:-4], "utf-8")) + b = typ(sample, enc) + self.assertEqual(b, typ(sample.encode(enc))) + self.assertRaises(UnicodeEncodeError, typ, sample, "latin1") + b = typ(sample, "latin1", "ignore") + self.assertEqual(b, typ(sample[:-4], "utf-8")) - def test_decode(self): + @with_types(bytes, bytearray) + def test_decode(self, typ): sample = "Hello world\n\u1234\u5678\u9abc\def0\def0" for enc in ("utf8", "utf16"): - b = bytearray(sample, enc) + b = typ(sample, enc) self.assertEqual(b.decode(enc), sample) sample = "Hello world\n\x80\x81\xfe\xff" - b = bytearray(sample, "latin1") + b = typ(sample, "latin1") self.assertRaises(UnicodeDecodeError, b.decode, "utf8") self.assertEqual(b.decode("utf8", "ignore"), "Hello world\n") @@ -385,26 +414,32 @@ class BytesTest(unittest.TestCase): self.assertEqual(str(b''), "b''") self.assertEqual(str(b'x'), "b'x'") self.assertEqual(str(b'\x80'), "b'\\x80'") + self.assertEqual(str(bytearray(b'')), "bytearray(b'')") + self.assertEqual(str(bytearray(b'x')), "bytearray(b'x')") + self.assertEqual(str(bytearray(b'\x80')), "bytearray(b'\\x80')") - def test_from_int(self): - b = bytearray(0) - self.assertEqual(b, bytearray()) - b = bytearray(10) - self.assertEqual(b, bytearray([0]*10)) - b = bytearray(10000) - self.assertEqual(b, bytearray([0]*10000)) + @with_types(bytes, bytearray) + def test_from_int(self, typ): + b = typ(0) + self.assertEqual(b, typ()) + b = typ(10) + self.assertEqual(b, typ([0]*10)) + b = typ(10000) + self.assertEqual(b, typ([0]*10000)) - def test_concat(self): - b1 = b"abc" - b2 = b"def" + @with_types(bytes, bytearray) + def test_concat(self, typ): + b1 = typ(b"abc") + b2 = typ(b"def") self.assertEqual(b1 + b2, b"abcdef") self.assertEqual(b1 + bytes(b"def"), b"abcdef") self.assertEqual(bytes(b"def") + b1, b"defabc") self.assertRaises(TypeError, lambda: b1 + "def") self.assertRaises(TypeError, lambda: "abc" + b2) - def test_repeat(self): - for b in b"abc", bytearray(b"abc"): + @with_types(bytes, bytearray) + def test_repeat(self, typ): + for b in b"abc", typ(b"abc"): self.assertEqual(b * 3, b"abcabcabc") self.assertEqual(b * 0, b"") self.assertEqual(b * -1, b"") @@ -414,8 +449,9 @@ class BytesTest(unittest.TestCase): self.assertRaises((OverflowError, MemoryError), lambda: b * sys.maxsize) - def test_repeat_1char(self): - self.assertEqual(b'x'*100, bytearray([ord('x')]*100)) + @with_types(bytes, bytearray) + def test_repeat_1char(self, typ): + self.assertEqual(typ(b'x')*100, typ([ord('x')]*100)) def test_iconcat(self): b = bytearray(b"abc") @@ -449,29 +485,30 @@ class BytesTest(unittest.TestCase): self.assertEqual(b, b1) self.failUnless(b is b1) - def test_contains(self): - for b in b"abc", bytearray(b"abc"): - self.failUnless(ord('a') in b) - self.failUnless(int(ord('a')) in b) - self.failIf(200 in b) - self.failIf(200 in b) - self.assertRaises(ValueError, lambda: 300 in b) - self.assertRaises(ValueError, lambda: -1 in b) - self.assertRaises(TypeError, lambda: None in b) - self.assertRaises(TypeError, lambda: float(ord('a')) in b) - self.assertRaises(TypeError, lambda: "a" in b) - for f in bytes, bytearray: - self.failUnless(f(b"") in b) - self.failUnless(f(b"a") in b) - self.failUnless(f(b"b") in b) - self.failUnless(f(b"c") in b) - self.failUnless(f(b"ab") in b) - self.failUnless(f(b"bc") in b) - self.failUnless(f(b"abc") in b) - self.failIf(f(b"ac") in b) - self.failIf(f(b"d") in b) - self.failIf(f(b"dab") in b) - self.failIf(f(b"abd") in b) + @with_types(bytes, bytearray) + def test_contains(self, typ): + b = typ(b"abc") + self.failUnless(ord('a') in b) + self.failUnless(int(ord('a')) in b) + self.failIf(200 in b) + self.failIf(200 in b) + self.assertRaises(ValueError, lambda: 300 in b) + self.assertRaises(ValueError, lambda: -1 in b) + self.assertRaises(TypeError, lambda: None in b) + self.assertRaises(TypeError, lambda: float(ord('a')) in b) + self.assertRaises(TypeError, lambda: "a" in b) + for f in bytes, bytearray: + self.failUnless(f(b"") in b) + self.failUnless(f(b"a") in b) + self.failUnless(f(b"b") in b) + self.failUnless(f(b"c") in b) + self.failUnless(f(b"ab") in b) + self.failUnless(f(b"bc") in b) + self.failUnless(f(b"abc") in b) + self.failIf(f(b"ac") in b) + self.failIf(f(b"d") in b) + self.failIf(f(b"dab") in b) + self.failIf(f(b"abd") in b) def test_alloc(self): b = bytearray() @@ -485,29 +522,34 @@ class BytesTest(unittest.TestCase): if alloc not in seq: seq.append(alloc) - def test_fromhex(self): - self.assertRaises(TypeError, bytearray.fromhex) - self.assertRaises(TypeError, bytearray.fromhex, 1) - self.assertEquals(bytearray.fromhex(''), bytearray()) + @with_types(bytes, bytearray) + def test_fromhex(self, typ): + self.assertRaises(TypeError, typ.fromhex) + self.assertRaises(TypeError, typ.fromhex, 1) + # To be fixed + if typ != bytes: + self.assertEquals(typ.fromhex(''), typ()) b = bytearray([0x1a, 0x2b, 0x30]) - self.assertEquals(bytearray.fromhex('1a2B30'), b) - self.assertEquals(bytearray.fromhex(' 1A 2B 30 '), b) - self.assertEquals(bytearray.fromhex('0000'), b'\0\0') - self.assertRaises(TypeError, bytearray.fromhex, b'1B') - self.assertRaises(ValueError, bytearray.fromhex, 'a') - self.assertRaises(ValueError, bytearray.fromhex, 'rt') - self.assertRaises(ValueError, bytearray.fromhex, '1a b cd') - self.assertRaises(ValueError, bytearray.fromhex, '\x00') - self.assertRaises(ValueError, bytearray.fromhex, '12 \x00 34') + self.assertEquals(typ.fromhex('1a2B30'), b) + self.assertEquals(typ.fromhex(' 1A 2B 30 '), b) + self.assertEquals(typ.fromhex('0000'), b'\0\0') + self.assertRaises(TypeError, typ.fromhex, b'1B') + self.assertRaises(ValueError, typ.fromhex, 'a') + self.assertRaises(ValueError, typ.fromhex, 'rt') + self.assertRaises(ValueError, typ.fromhex, '1a b cd') + self.assertRaises(ValueError, typ.fromhex, '\x00') + self.assertRaises(ValueError, typ.fromhex, '12 \x00 34') - def test_join(self): - self.assertEqual(b"".join([]), b"") - self.assertEqual(b"".join([b""]), b"") + @with_types(bytes, bytearray) + def test_join(self, typ): + self.assertEqual(typ(b"").join([]), b"") + self.assertEqual(typ(b"").join([b""]), b"") for lst in [[b"abc"], [b"a", b"bc"], [b"ab", b"c"], [b"a", b"b", b"c"]]: - self.assertEqual(b"".join(lst), b"abc") - self.assertEqual(b"".join(tuple(lst)), b"abc") - self.assertEqual(b"".join(iter(lst)), b"abc") - self.assertEqual(b".".join([b"ab", b"cd"]), b"ab.cd") + lst = list(map(typ, lst)) + self.assertEqual(typ(b"").join(lst), b"abc") + self.assertEqual(typ(b"").join(tuple(lst)), b"abc") + self.assertEqual(typ(b"").join(iter(lst)), b"abc") + self.assertEqual(typ(b".").join([b"ab", b"cd"]), b"ab.cd") # XXX more... def test_literal(self): @@ -574,15 +616,17 @@ class BytesTest(unittest.TestCase): def test_nosort(self): self.assertRaises(AttributeError, lambda: bytearray().sort()) - def test_index(self): - b = b'parrot' + @with_types(bytes, bytearray) + def test_index(self, typ): + b = typ(b'parrot') self.assertEqual(b.index('p'), 0) self.assertEqual(b.index('rr'), 2) self.assertEqual(b.index('t'), 5) self.assertRaises(ValueError, lambda: b.index('w')) - def test_count(self): - b = b'mississippi' + @with_types(bytes, bytearray) + def test_count(self, typ): + b = typ(b'mississippi') self.assertEqual(b.count(b'i'), 4) self.assertEqual(b.count(b'ss'), 2) self.assertEqual(b.count(b'w'), 0) @@ -606,17 +650,19 @@ class BytesTest(unittest.TestCase): self.assertEqual(b, b'mississippi') self.assertRaises(TypeError, lambda: b.insert(0, b'1')) - def test_startswith(self): - b = b'hello' - self.assertFalse(bytearray().startswith(b"anything")) + @with_types(bytes, bytearray) + def test_startswith(self, typ): + b = typ(b'hello') + self.assertFalse(typ().startswith(b"anything")) self.assertTrue(b.startswith(b"hello")) self.assertTrue(b.startswith(b"hel")) self.assertTrue(b.startswith(b"h")) self.assertFalse(b.startswith(b"hellow")) self.assertFalse(b.startswith(b"ha")) - def test_endswith(self): - b = b'hello' + @with_types(bytes, bytearray) + def test_endswith(self, typ): + b = typ(b'hello') self.assertFalse(bytearray().endswith(b"anything")) self.assertTrue(b.endswith(b"hello")) self.assertTrue(b.endswith(b"llo")) @@ -624,8 +670,9 @@ class BytesTest(unittest.TestCase): self.assertFalse(b.endswith(b"whello")) self.assertFalse(b.endswith(b"no")) - def test_find(self): - b = b'mississippi' + @with_types(bytes, bytearray) + def test_find(self, typ): + b = typ(b'mississippi') self.assertEqual(b.find(b'ss'), 2) self.assertEqual(b.find(b'ss', 3), 5) self.assertEqual(b.find(b'ss', 1, 7), 2) @@ -633,31 +680,35 @@ class BytesTest(unittest.TestCase): self.assertEqual(b.find(b'w'), -1) self.assertEqual(b.find(b'mississippian'), -1) - def test_rfind(self): - b = b'mississippi' + @with_types(bytes, bytearray) + def test_rfind(self, typ): + b = typ(b'mississippi') self.assertEqual(b.rfind(b'ss'), 5) self.assertEqual(b.rfind(b'ss', 3), 5) self.assertEqual(b.rfind(b'ss', 0, 6), 2) self.assertEqual(b.rfind(b'w'), -1) self.assertEqual(b.rfind(b'mississippian'), -1) - def test_index(self): - b = b'world' + @with_types(bytes, bytearray) + def test_index(self, typ): + b = typ(b'world') self.assertEqual(b.index(b'w'), 0) self.assertEqual(b.index(b'orl'), 1) self.assertRaises(ValueError, b.index, b'worm') self.assertRaises(ValueError, b.index, b'ldo') - def test_rindex(self): + @with_types(bytes, bytearray) + def test_rindex(self, typ): # XXX could be more rigorous - b = b'world' + b = typ(b'world') self.assertEqual(b.rindex(b'w'), 0) self.assertEqual(b.rindex(b'orl'), 1) self.assertRaises(ValueError, b.rindex, b'worm') self.assertRaises(ValueError, b.rindex, b'ldo') - def test_replace(self): - b = b'mississippi' + @with_types(bytes, bytearray) + def test_replace(self, typ): + b = typ(b'mississippi') self.assertEqual(b.replace(b'i', b'a'), b'massassappa') self.assertEqual(b.replace(b'ss', b'x'), b'mixixippi') @@ -669,80 +720,93 @@ class BytesTest(unittest.TestCase): self.assertEqual(b, b'hello') self.assertEqual(c, b'hee') - def test_split(self): - b = b'mississippi' + @with_types(bytes, bytearray) + def test_split(self, typ): + b = typ(b'mississippi') self.assertEqual(b.split(b'i'), [b'm', b'ss', b'ss', b'pp', b'']) self.assertEqual(b.split(b'ss'), [b'mi', b'i', b'ippi']) self.assertEqual(b.split(b'w'), [b]) - def test_split_whitespace(self): + @with_types(bytes, bytearray) + def test_split_whitespace(self, typ): for b in (b' arf barf ', b'arf\tbarf', b'arf\nbarf', b'arf\rbarf', b'arf\fbarf', b'arf\vbarf'): + b = typ(b) self.assertEqual(b.split(), [b'arf', b'barf']) self.assertEqual(b.split(None), [b'arf', b'barf']) self.assertEqual(b.split(None, 2), [b'arf', b'barf']) - self.assertEqual(b' a bb c '.split(None, 0), [b'a bb c ']) - self.assertEqual(b' a bb c '.split(None, 1), [b'a', b'bb c ']) - self.assertEqual(b' a bb c '.split(None, 2), [b'a', b'bb', b'c ']) - self.assertEqual(b' a bb c '.split(None, 3), [b'a', b'bb', b'c']) + for b in (b'a\x1Cb', b'a\x1Db', b'a\x1Eb', b'a\x1Fb'): + b = typ(b) + self.assertEqual(b.split(), [b]) + self.assertEqual(typ(b' a bb c ').split(None, 0), [b'a bb c ']) + self.assertEqual(typ(b' a bb c ').split(None, 1), [b'a', b'bb c ']) + self.assertEqual(typ(b' a bb c ').split(None, 2), [b'a', b'bb', b'c ']) + self.assertEqual(typ(b' a bb c ').split(None, 3), [b'a', b'bb', b'c']) def test_split_bytearray(self): self.assertEqual(b'a b'.split(memoryview(b' ')), [b'a', b'b']) - def test_split_string_error(self): - self.assertRaises(TypeError, b'a b'.split, ' ') + @with_types(bytes, bytearray) + def test_split_string_error(self, typ): + self.assertRaises(TypeError, typ(b'a b').split, ' ') - def test_rsplit(self): - b = b'mississippi' + @with_types(bytes, bytearray) + def test_rsplit(self, typ): + b = typ(b'mississippi') self.assertEqual(b.rsplit(b'i'), [b'm', b'ss', b'ss', b'pp', b'']) self.assertEqual(b.rsplit(b'ss'), [b'mi', b'i', b'ippi']) self.assertEqual(b.rsplit(b'w'), [b]) - def test_rsplit_whitespace(self): + @with_types(bytes, bytearray) + def test_rsplit_whitespace(self, typ): for b in (b' arf barf ', b'arf\tbarf', b'arf\nbarf', b'arf\rbarf', b'arf\fbarf', b'arf\vbarf'): + b = typ(b) self.assertEqual(b.rsplit(), [b'arf', b'barf']) self.assertEqual(b.rsplit(None), [b'arf', b'barf']) self.assertEqual(b.rsplit(None, 2), [b'arf', b'barf']) - self.assertEqual(b' a bb c '.rsplit(None, 0), [b' a bb c']) - self.assertEqual(b' a bb c '.rsplit(None, 1), [b' a bb', b'c']) - self.assertEqual(b' a bb c '.rsplit(None, 2), [b' a', b'bb', b'c']) - self.assertEqual(b' a bb c '.rsplit(None, 3), [b'a', b'bb', b'c']) + self.assertEqual(typ(b' a bb c ').rsplit(None, 0), [b' a bb c']) + self.assertEqual(typ(b' a bb c ').rsplit(None, 1), [b' a bb', b'c']) + self.assertEqual(typ(b' a bb c ').rsplit(None, 2), [b' a', b'bb', b'c']) + self.assertEqual(typ(b' a bb c ').rsplit(None, 3), [b'a', b'bb', b'c']) def test_rsplit_bytearray(self): self.assertEqual(b'a b'.rsplit(memoryview(b' ')), [b'a', b'b']) - def test_rsplit_string_error(self): - self.assertRaises(TypeError, b'a b'.rsplit, ' ') + @with_types(bytes, bytearray) + def test_rsplit_string_error(self, typ): + self.assertRaises(TypeError, typ(b'a b').rsplit, ' ') - def test_rsplit_unicodewhitespace(self): - b = b"\x09\x0A\x0B\x0C\x0D\x1C\x1D\x1E\x1F" + @with_types(bytes, bytearray) + def test_rsplit_unicodewhitespace(self, typ): + b = typ(b"\x09\x0A\x0B\x0C\x0D\x1C\x1D\x1E\x1F") self.assertEqual(b.split(), [b'\x1c\x1d\x1e\x1f']) self.assertEqual(b.rsplit(), [b'\x1c\x1d\x1e\x1f']) - ba = bytearray(b) - self.assertEqual(ba.split(), [bytearray(b'\x1c\x1d\x1e\x1f')]) - self.assertEqual(ba.rsplit(), [bytearray(b'\x1c\x1d\x1e\x1f')]) - - def test_partition(self): - b = b'mississippi' + @with_types(bytes, bytearray) + def test_partition(self, typ): + b = typ(b'mississippi') self.assertEqual(b.partition(b'ss'), (b'mi', b'ss', b'issippi')) self.assertEqual(b.rpartition(b'w'), (b'', b'', b'mississippi')) - def test_rpartition(self): - b = b'mississippi' + @with_types(bytes, bytearray) + def test_rpartition(self, typ): + b = typ(b'mississippi') self.assertEqual(b.rpartition(b'ss'), (b'missi', b'ss', b'ippi')) self.assertEqual(b.rpartition(b'i'), (b'mississipp', b'i', b'')) - def test_pickling(self): + @with_types(bytes, bytearray) + def test_pickling(self, typ): for proto in range(pickle.HIGHEST_PROTOCOL): for b in b"", b"a", b"abc", b"\xffab\x80", b"\0\0\377\0\0": + b = typ(b) ps = pickle.dumps(b, proto) q = pickle.loads(ps) self.assertEqual(b, q) - def test_strip(self): - b = b'mississippi' + @with_types(bytes, bytearray) + def test_strip(self, typ): + b = typ(b'mississippi') self.assertEqual(b.strip(b'i'), b'mississipp') self.assertEqual(b.strip(b'm'), b'ississippi') self.assertEqual(b.strip(b'pi'), b'mississ') @@ -750,40 +814,46 @@ class BytesTest(unittest.TestCase): self.assertEqual(b.strip(b'pim'), b'ssiss') self.assertEqual(b.strip(b), b'') - def test_lstrip(self): - b = b'mississippi' + @with_types(bytes, bytearray) + def test_lstrip(self, typ): + b = typ(b'mississippi') self.assertEqual(b.lstrip(b'i'), b'mississippi') self.assertEqual(b.lstrip(b'm'), b'ississippi') self.assertEqual(b.lstrip(b'pi'), b'mississippi') self.assertEqual(b.lstrip(b'im'), b'ssissippi') self.assertEqual(b.lstrip(b'pim'), b'ssissippi') - def test_rstrip(self): - b = b'mississippi' + @with_types(bytes, bytearray) + def test_rstrip(self, typ): + b = typ(b'mississippi') self.assertEqual(b.rstrip(b'i'), b'mississipp') self.assertEqual(b.rstrip(b'm'), b'mississippi') self.assertEqual(b.rstrip(b'pi'), b'mississ') self.assertEqual(b.rstrip(b'im'), b'mississipp') self.assertEqual(b.rstrip(b'pim'), b'mississ') - def test_strip_whitespace(self): - b = b' \t\n\r\f\vabc \t\n\r\f\v' + @with_types(bytes, bytearray) + def test_strip_whitespace(self, typ): + b = typ(b' \t\n\r\f\vabc \t\n\r\f\v') self.assertEqual(b.strip(), b'abc') self.assertEqual(b.lstrip(), b'abc \t\n\r\f\v') self.assertEqual(b.rstrip(), b' \t\n\r\f\vabc') - def test_strip_bytearray(self): - self.assertEqual(b'abc'.strip(memoryview(b'ac')), b'b') - self.assertEqual(b'abc'.lstrip(memoryview(b'ac')), b'bc') - self.assertEqual(b'abc'.rstrip(memoryview(b'ac')), b'ab') + @with_types(bytes, bytearray) + def test_strip_bytearray(self, typ): + self.assertEqual(typ(b'abc').strip(memoryview(b'ac')), b'b') + self.assertEqual(typ(b'abc').lstrip(memoryview(b'ac')), b'bc') + self.assertEqual(typ(b'abc').rstrip(memoryview(b'ac')), b'ab') - def test_strip_string_error(self): - self.assertRaises(TypeError, b'abc'.strip, 'b') - self.assertRaises(TypeError, b'abc'.lstrip, 'b') - self.assertRaises(TypeError, b'abc'.rstrip, 'b') + @with_types(bytes, bytearray) + def test_strip_string_error(self, typ): + self.assertRaises(TypeError, typ(b'abc').strip, 'b') + self.assertRaises(TypeError, typ(b'abc').lstrip, 'b') + self.assertRaises(TypeError, typ(b'abc').rstrip, 'b') - def test_ord(self): - b = b'\0A\x7f\x80\xff' + @with_types(bytes, bytearray) + def test_ord(self, typ): + b = typ(b'\0A\x7f\x80\xff') self.assertEqual([ord(b[i:i+1]) for i in range(len(b))], [0, 65, 127, 128, 255]) @@ -841,8 +911,7 @@ class BytearrayPEP3137Test(unittest.Test methname+' returned self on a mutable object') -class BytesAsStringTest(test.string_tests.BaseTest): - type2test = bytearray +class FixedStringTest(test.string_tests.BaseTest): def fixtype(self, obj): if isinstance(obj, str): @@ -860,6 +929,12 @@ class BytesAsStringTest(test.string_test pass def test_lower(self): pass + +class ByteArrayAsStringTest(FixedStringTest): + type2test = bytearray + +class BytesAsStringTest(FixedStringTest): + type2test = bytes class ByteArraySubclass(bytearray): @@ -943,6 +1018,7 @@ def test_main(): def test_main(): test.test_support.run_unittest(BytesTest) test.test_support.run_unittest(BytesAsStringTest) + test.test_support.run_unittest(ByteArrayAsStringTest) test.test_support.run_unittest(ByteArraySubclassTest) test.test_support.run_unittest(BytearrayPEP3137Test)