diff options
Diffstat (limited to 'Lib/test/test_bytes.py')
| -rw-r--r-- | Lib/test/test_bytes.py | 303 |
1 files changed, 197 insertions, 106 deletions
diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py index 520459d039c..89e22740fc6 100644 --- a/Lib/test/test_bytes.py +++ b/Lib/test/test_bytes.py @@ -13,7 +13,7 @@ import functools import pickle import tempfile import unittest -import test.test_support +import test.support import test.string_tests import test.buffer_tests @@ -22,7 +22,7 @@ if sys.flags.bytes_warning: def check_bytes_warnings(func): @functools.wraps(func) def wrapper(*args, **kw): - with test.test_support.check_warnings(('', BytesWarning)): + with test.support.check_warnings(('', BytesWarning)): return func(*args, **kw) return wrapper else: @@ -45,19 +45,26 @@ class BaseBytesTest(unittest.TestCase): self.assertEqual(type(b), self.type2test) self.assertEqual(b.__class__, self.type2test) + def test_copy(self): + a = self.type2test(b"abcd") + for copy_method in (copy.copy, copy.deepcopy): + b = copy_method(a) + self.assertEqual(a, b) + self.assertEqual(type(a), type(b)) + def test_empty_sequence(self): b = self.type2test() self.assertEqual(len(b), 0) self.assertRaises(IndexError, lambda: b[0]) self.assertRaises(IndexError, lambda: b[1]) - self.assertRaises(IndexError, lambda: b[sys.maxint]) - self.assertRaises(IndexError, lambda: b[sys.maxint+1]) + self.assertRaises(IndexError, lambda: b[sys.maxsize]) + self.assertRaises(IndexError, lambda: b[sys.maxsize+1]) self.assertRaises(IndexError, lambda: b[10**100]) self.assertRaises(IndexError, lambda: b[-1]) self.assertRaises(IndexError, lambda: b[-2]) - self.assertRaises(IndexError, lambda: b[-sys.maxint]) - self.assertRaises(IndexError, lambda: b[-sys.maxint-1]) - self.assertRaises(IndexError, lambda: b[-sys.maxint-2]) + self.assertRaises(IndexError, lambda: b[-sys.maxsize]) + self.assertRaises(IndexError, lambda: b[-sys.maxsize-1]) + self.assertRaises(IndexError, lambda: b[-sys.maxsize-2]) self.assertRaises(IndexError, lambda: b[-10**100]) def test_from_list(self): @@ -87,22 +94,21 @@ class BaseBytesTest(unittest.TestCase): self.assertRaises(TypeError, self.type2test, 0.0) class C: pass - # allowed in 2.x - #self.assertRaises(TypeError, self.type2test, ["0"]) + self.assertRaises(TypeError, self.type2test, ["0"]) self.assertRaises(TypeError, self.type2test, [0.0]) self.assertRaises(TypeError, self.type2test, [None]) self.assertRaises(TypeError, self.type2test, [C()]) def test_constructor_value_errors(self): self.assertRaises(ValueError, self.type2test, [-1]) - self.assertRaises(ValueError, self.type2test, [-sys.maxint]) - self.assertRaises(ValueError, self.type2test, [-sys.maxint-1]) - self.assertRaises(ValueError, self.type2test, [-sys.maxint-2]) + self.assertRaises(ValueError, self.type2test, [-sys.maxsize]) + self.assertRaises(ValueError, self.type2test, [-sys.maxsize-1]) + self.assertRaises(ValueError, self.type2test, [-sys.maxsize-2]) self.assertRaises(ValueError, self.type2test, [-10**100]) self.assertRaises(ValueError, self.type2test, [256]) self.assertRaises(ValueError, self.type2test, [257]) - self.assertRaises(ValueError, self.type2test, [sys.maxint]) - self.assertRaises(ValueError, self.type2test, [sys.maxint+1]) + self.assertRaises(ValueError, self.type2test, [sys.maxsize]) + self.assertRaises(ValueError, self.type2test, [sys.maxsize+1]) self.assertRaises(ValueError, self.type2test, [10**100]) def test_compare(self): @@ -131,13 +137,16 @@ class BaseBytesTest(unittest.TestCase): @check_bytes_warnings def test_compare_to_str(self): # Byte comparisons with unicode should always fail! - # Test this for all expected byte orders and Unicode character sizes - self.assertEqual(self.type2test(b"\0a\0b\0c") == u"abc", False) - self.assertEqual(self.type2test(b"\0\0\0a\0\0\0b\0\0\0c") == u"abc", False) - self.assertEqual(self.type2test(b"a\0b\0c\0") == u"abc", False) - self.assertEqual(self.type2test(b"a\0\0\0b\0\0\0c\0\0\0") == u"abc", False) - self.assertEqual(self.type2test() == unicode(), False) - self.assertEqual(self.type2test() != unicode(), True) + # Test this for all expected byte orders and Unicode character + # sizes. + self.assertEqual(self.type2test(b"\0a\0b\0c") == "abc", False) + self.assertEqual(self.type2test(b"\0\0\0a\0\0\0b\0\0\0c") == "abc", + False) + self.assertEqual(self.type2test(b"a\0b\0c\0") == "abc", False) + self.assertEqual(self.type2test(b"a\0\0\0b\0\0\0c\0\0\0") == "abc", + False) + self.assertEqual(self.type2test() == str(), False) + self.assertEqual(self.type2test() != str(), True) def test_reversed(self): input = list(map(ord, "Hello")) @@ -178,20 +187,20 @@ class BaseBytesTest(unittest.TestCase): self.assertEqual(b[start:stop:step], self.type2test(L[start:stop:step])) def test_encoding(self): - sample = u"Hello world\n\u1234\u5678\u9abc\udef0" + sample = "Hello world\n\u1234\u5678\u9abc" for enc in ("utf8", "utf16"): b = self.type2test(sample, enc) self.assertEqual(b, self.type2test(sample.encode(enc))) self.assertRaises(UnicodeEncodeError, self.type2test, sample, "latin1") b = self.type2test(sample, "latin1", "ignore") - self.assertEqual(b, self.type2test(sample[:-4], "utf-8")) + self.assertEqual(b, self.type2test(sample[:-3], "utf-8")) def test_decode(self): - sample = u"Hello world\n\u1234\u5678\u9abc\def0\def0" + sample = "Hello world\n\u1234\u5678\u9abc\def0\def0" for enc in ("utf8", "utf16"): b = self.type2test(sample, enc) self.assertEqual(b.decode(enc), sample) - sample = u"Hello world\n\x80\x81\xfe\xff" + sample = "Hello world\n\x80\x81\xfe\xff" b = self.type2test(sample, "latin1") self.assertRaises(UnicodeDecodeError, b.decode, "utf8") self.assertEqual(b.decode("utf8", "ignore"), "Hello world\n") @@ -212,8 +221,8 @@ class BaseBytesTest(unittest.TestCase): 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 + u"def") - self.assertRaises(TypeError, lambda: u"abc" + b2) + self.assertRaises(TypeError, lambda: b1 + "def") + self.assertRaises(TypeError, lambda: "abc" + b2) def test_repeat(self): for b in b"abc", self.type2test(b"abc"): @@ -223,8 +232,10 @@ class BaseBytesTest(unittest.TestCase): self.assertRaises(TypeError, lambda: b * 3.14) self.assertRaises(TypeError, lambda: 3.14 * b) # XXX Shouldn't bytes and bytearray agree on what to raise? - self.assertRaises((OverflowError, MemoryError), - lambda: b * sys.maxsize) + with self.assertRaises((OverflowError, MemoryError)): + c = b * sys.maxsize + with self.assertRaises((OverflowError, MemoryError)): + b *= sys.maxsize def test_repeat_1char(self): self.assertEqual(self.type2test(b'x')*100, self.type2test([ord('x')]*100)) @@ -238,7 +249,7 @@ class BaseBytesTest(unittest.TestCase): 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: u"a" in b) + self.assertRaises(TypeError, lambda: "a" in b) for f in bytes, bytearray: self.assertIn(f(b""), b) self.assertIn(f(b"a"), b) @@ -255,16 +266,17 @@ class BaseBytesTest(unittest.TestCase): def test_fromhex(self): self.assertRaises(TypeError, self.type2test.fromhex) self.assertRaises(TypeError, self.type2test.fromhex, 1) - self.assertEqual(self.type2test.fromhex(u''), self.type2test()) + self.assertEqual(self.type2test.fromhex(''), self.type2test()) b = bytearray([0x1a, 0x2b, 0x30]) - self.assertEqual(self.type2test.fromhex(u'1a2B30'), b) - self.assertEqual(self.type2test.fromhex(u' 1A 2B 30 '), b) - self.assertEqual(self.type2test.fromhex(u'0000'), b'\0\0') - self.assertRaises(ValueError, self.type2test.fromhex, u'a') - self.assertRaises(ValueError, self.type2test.fromhex, u'rt') - self.assertRaises(ValueError, self.type2test.fromhex, u'1a b cd') - self.assertRaises(ValueError, self.type2test.fromhex, u'\x00') - self.assertRaises(ValueError, self.type2test.fromhex, u'12 \x00 34') + self.assertEqual(self.type2test.fromhex('1a2B30'), b) + self.assertEqual(self.type2test.fromhex(' 1A 2B 30 '), b) + self.assertEqual(self.type2test.fromhex('0000'), b'\0\0') + self.assertRaises(TypeError, self.type2test.fromhex, b'1B') + self.assertRaises(ValueError, self.type2test.fromhex, 'a') + self.assertRaises(ValueError, self.type2test.fromhex, 'rt') + self.assertRaises(ValueError, self.type2test.fromhex, '1a b cd') + self.assertRaises(ValueError, self.type2test.fromhex, '\x00') + self.assertRaises(ValueError, self.type2test.fromhex, '12 \x00 34') def test_join(self): self.assertEqual(self.type2test(b"").join([]), b"") @@ -291,6 +303,11 @@ class BaseBytesTest(unittest.TestCase): self.assertTrue(b.startswith(b"h")) self.assertFalse(b.startswith(b"hellow")) self.assertFalse(b.startswith(b"ha")) + with self.assertRaises(TypeError) as cm: + b.startswith([b'h']) + exc = str(cm.exception) + self.assertIn('bytes', exc) + self.assertIn('tuple', exc) def test_endswith(self): b = self.type2test(b'hello') @@ -300,6 +317,11 @@ class BaseBytesTest(unittest.TestCase): self.assertTrue(b.endswith(b"o")) self.assertFalse(b.endswith(b"whello")) self.assertFalse(b.endswith(b"no")) + with self.assertRaises(TypeError) as cm: + b.endswith([b'o']) + exc = str(cm.exception) + self.assertIn('bytes', exc) + self.assertIn('tuple', exc) def test_find(self): b = self.type2test(b'mississippi') @@ -360,7 +382,7 @@ class BaseBytesTest(unittest.TestCase): self.assertEqual(self.type2test(b' a bb c ').split(None, 3), [b'a', b'bb', b'c']) def test_split_string_error(self): - self.assertRaises(TypeError, self.type2test(b'a b').split, u' ') + self.assertRaises(TypeError, self.type2test(b'a b').split, ' ') def test_split_unicodewhitespace(self): b = self.type2test(b"\x09\x0A\x0B\x0C\x0D\x1C\x1D\x1E\x1F") @@ -385,7 +407,7 @@ class BaseBytesTest(unittest.TestCase): self.assertEqual(self.type2test(b' a bb c ').rsplit(None, 3), [b'a', b'bb', b'c']) def test_rsplit_string_error(self): - self.assertRaises(TypeError, self.type2test(b'a b').rsplit, u' ') + self.assertRaises(TypeError, self.type2test(b'a b').rsplit, ' ') def test_rsplit_unicodewhitespace(self): b = self.type2test(b"\x09\x0A\x0B\x0C\x0D\x1C\x1D\x1E\x1F") @@ -447,15 +469,23 @@ class BaseBytesTest(unittest.TestCase): self.assertEqual(self.type2test(b'abc').rstrip(memoryview(b'ac')), b'ab') def test_strip_string_error(self): - self.assertRaises(TypeError, self.type2test(b'abc').strip, u'b') - self.assertRaises(TypeError, self.type2test(b'abc').lstrip, u'b') - self.assertRaises(TypeError, self.type2test(b'abc').rstrip, u'b') + self.assertRaises(TypeError, self.type2test(b'abc').strip, 'b') + self.assertRaises(TypeError, self.type2test(b'abc').lstrip, 'b') + self.assertRaises(TypeError, self.type2test(b'abc').rstrip, 'b') def test_ord(self): b = self.type2test(b'\0A\x7f\x80\xff') self.assertEqual([ord(b[i:i+1]) for i in range(len(b))], [0, 65, 127, 128, 255]) + def test_maketrans(self): + transtable = b'\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`xyzdefghijklmnopqrstuvwxyz{|}~\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377' + self.assertEqual(self.type2test.maketrans(b'abc', b'xyz'), transtable) + transtable = b'\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374xyz' + self.assertEqual(self.type2test.maketrans(b'\375\376\377', b'xyz'), transtable) + self.assertRaises(ValueError, self.type2test.maketrans, b'abc', b'xyzq') + self.assertRaises(TypeError, self.type2test.maketrans, 'abc', 'def') + def test_none_arguments(self): # issue 11828 b = self.type2test(b'hello') @@ -503,22 +533,64 @@ class BaseBytesTest(unittest.TestCase): # issue 11828 b = self.type2test(b'hello') x = self.type2test(b'x') - self.assertRaisesRegexp(TypeError, r'\bfind\b', b.find, + self.assertRaisesRegex(TypeError, r'\bfind\b', b.find, x, None, None, None) - self.assertRaisesRegexp(TypeError, r'\brfind\b', b.rfind, + self.assertRaisesRegex(TypeError, r'\brfind\b', b.rfind, x, None, None, None) - self.assertRaisesRegexp(TypeError, r'\bindex\b', b.index, + self.assertRaisesRegex(TypeError, r'\bindex\b', b.index, x, None, None, None) - self.assertRaisesRegexp(TypeError, r'\brindex\b', b.rindex, + self.assertRaisesRegex(TypeError, r'\brindex\b', b.rindex, x, None, None, None) - self.assertRaisesRegexp(TypeError, r'\bcount\b', b.count, + self.assertRaisesRegex(TypeError, r'\bcount\b', b.count, x, None, None, None) - self.assertRaisesRegexp(TypeError, r'\bstartswith\b', b.startswith, + self.assertRaisesRegex(TypeError, r'\bstartswith\b', b.startswith, x, None, None, None) - self.assertRaisesRegexp(TypeError, r'\bendswith\b', b.endswith, + self.assertRaisesRegex(TypeError, r'\bendswith\b', b.endswith, x, None, None, None) +class BytesTest(BaseBytesTest): + type2test = bytes + + def test_buffer_is_readonly(self): + fd = os.dup(sys.stdin.fileno()) + with open(fd, "rb", buffering=0) as f: + self.assertRaises(TypeError, f.readinto, b"") + + def test_custom(self): + class A: + def __bytes__(self): + return b'abc' + self.assertEqual(bytes(A()), b'abc') + class A: pass + self.assertRaises(TypeError, bytes, A()) + class A: + def __bytes__(self): + return None + self.assertRaises(TypeError, bytes, A()) + + # Test PyBytes_FromFormat() + def test_from_format(self): + test.support.import_module('ctypes') + from ctypes import pythonapi, py_object, c_int, c_char_p + PyBytes_FromFormat = pythonapi.PyBytes_FromFormat + PyBytes_FromFormat.restype = py_object + + self.assertEqual(PyBytes_FromFormat(b'format'), + b'format') + + self.assertEqual(PyBytes_FromFormat(b'%'), b'%') + self.assertEqual(PyBytes_FromFormat(b'%%'), b'%') + self.assertEqual(PyBytes_FromFormat(b'%%s'), b'%s') + self.assertEqual(PyBytes_FromFormat(b'[%%]'), b'[%]') + self.assertEqual(PyBytes_FromFormat(b'%%%c', c_int(ord('_'))), b'%_') + + self.assertEqual(PyBytes_FromFormat(b'c:%c', c_int(255)), + b'c:\xff') + self.assertEqual(PyBytes_FromFormat(b's:%s', c_char_p(b'cstr')), + b's:cstr') + + class ByteArrayTest(BaseBytesTest): type2test = bytearray @@ -538,9 +610,7 @@ class ByteArrayTest(BaseBytesTest): b = bytearray(20) n = f.readinto(b) self.assertEqual(n, len(short_sample)) - # Python 2.x - b_sample = (ord(s) for s in sample) - self.assertEqual(list(b), list(b_sample)) + self.assertEqual(list(b), list(sample)) # Test writing in binary mode with open(tfn, "wb") as f: f.write(b) @@ -568,7 +638,7 @@ class ByteArrayTest(BaseBytesTest): def by(s): return bytearray(map(ord, s)) b = by("Hello, world") - self.assertEqual(re.findall(r"\w+", b), [by("Hello"), by("world")]) + self.assertEqual(re.findall(br"\w+", b), [by("Hello"), by("world")]) def test_setitem(self): b = bytearray([1, 2, 3]) @@ -644,10 +714,8 @@ class ByteArrayTest(BaseBytesTest): b[3:4] = [] self.assertEqual(b, bytearray([102, 111, 111, 111, 111])) - b[1:] = list(b'uuuu') # this works only on Python2 - self.assertEqual(b, bytearray([102, 117, 117, 117, 117])) - - for elem in [5, -5, 0, long(10e20), u'str', 2.3, [u'a', u'b'], [[]]]: + for elem in [5, -5, 0, int(10e20), 'str', 2.3, + ['a', 'b'], [b'a', b'b'], [[]]]: with self.assertRaises(TypeError): b[3:4] = elem @@ -692,7 +760,7 @@ class ByteArrayTest(BaseBytesTest): b += b"xyz" self.assertEqual(b, b"abcdefxyz") try: - b += u"" + b += "" except TypeError: pass else: @@ -734,16 +802,16 @@ class ByteArrayTest(BaseBytesTest): self.assertEqual(a[5:], orig) a = bytearray(b'') # Test iterators that don't have a __length_hint__ - a.extend(map(ord, orig * 25)) - a.extend(ord(x) for x in orig * 25) + a.extend(map(int, orig * 25)) + a.extend(int(x) for x in orig * 25) self.assertEqual(a, orig * 50) self.assertEqual(a[-5:], orig) a = bytearray(b'') - a.extend(iter(map(ord, orig * 50))) + a.extend(iter(map(int, orig * 50))) self.assertEqual(a, orig * 50) self.assertEqual(a[-5:], orig) a = bytearray(b'') - a.extend(list(map(ord, orig * 50))) + a.extend(list(map(int, orig * 50))) self.assertEqual(a, orig * 50) self.assertEqual(a[-5:], orig) a = bytearray(b'') @@ -762,12 +830,12 @@ class ByteArrayTest(BaseBytesTest): self.assertEqual(b, b'heo') self.assertRaises(ValueError, lambda: b.remove(ord('l'))) self.assertRaises(ValueError, lambda: b.remove(400)) - self.assertRaises(TypeError, lambda: b.remove(u'e')) + self.assertRaises(TypeError, lambda: b.remove('e')) # remove first and last b.remove(ord('o')) b.remove(ord('h')) self.assertEqual(b, b'e') - self.assertRaises(TypeError, lambda: b.remove(u'e')) + self.assertRaises(TypeError, lambda: b.remove(b'e')) b.remove(Indexable(ord('e'))) self.assertEqual(b, b'') @@ -792,7 +860,7 @@ class ByteArrayTest(BaseBytesTest): b = bytearray() b.append(ord('A')) self.assertEqual(len(b), 1) - self.assertRaises(TypeError, lambda: b.append(u'o')) + self.assertRaises(TypeError, lambda: b.append(b'o')) b = bytearray() b.append(Indexable(ord('A'))) self.assertEqual(b, b'A') @@ -804,8 +872,7 @@ class ByteArrayTest(BaseBytesTest): b.insert(-2, ord('i')) b.insert(1000, ord('i')) self.assertEqual(b, b'mississippi') - # allowed in 2.x - #self.assertRaises(TypeError, lambda: b.insert(0, b'1')) + self.assertRaises(TypeError, lambda: b.insert(0, b'1')) b = bytearray() b.insert(0, Indexable(ord('A'))) self.assertEqual(b, b'A') @@ -873,12 +940,6 @@ class ByteArrayTest(BaseBytesTest): self.assertRaises(BufferError, delslice) self.assertEqual(b, orig) - def test_empty_bytearray(self): - # Issue #7561: operations on empty bytearrays could crash in many - # situations, due to a fragile implementation of the - # PyByteArray_AS_STRING() C macro. - self.assertRaises(ValueError, int, bytearray(b'')) - class AssortedBytesTest(unittest.TestCase): # @@ -983,6 +1044,26 @@ class AssortedBytesTest(unittest.TestCase): def test_rsplit_bytearray(self): self.assertEqual(b'a b'.rsplit(memoryview(b' ')), [b'a', b'b']) + def test_return_self(self): + # bytearray.replace must always return a new bytearray + b = bytearray() + self.assertFalse(b.replace(b'', b'') is b) + + def test_compare(self): + if sys.flags.bytes_warning: + def bytes_warning(): + return test.support.check_warnings(('', BytesWarning)) + with bytes_warning(): + b'' == '' + with bytes_warning(): + b'' != '' + with bytes_warning(): + bytearray(b'') == '' + with bytes_warning(): + bytearray(b'') != '' + else: + self.skipTest("BytesWarning is needed for this test: use -bb option") + # Optimizations: # __iter__? (optimization) # __reversed__? (optimization) @@ -1014,8 +1095,8 @@ class BytearrayPEP3137Test(unittest.TestCase, self.assertTrue(val is not newval, methname+' returned self on a mutable object') for expr in ('val.split()[0]', 'val.rsplit()[0]', - 'val.partition(".")[0]', 'val.rpartition(".")[2]', - 'val.splitlines()[0]', 'val.replace("", "")'): + 'val.partition(b".")[0]', 'val.rpartition(b".")[2]', + 'val.splitlines()[0]', 'val.replace(b"", b"")'): newval = eval(expr) self.assertEqual(val, newval) self.assertTrue(val is not newval, @@ -1026,7 +1107,7 @@ class FixedStringTest(test.string_tests.BaseTest): def fixtype(self, obj): if isinstance(obj, str): return obj.encode("utf-8") - return super(FixedStringTest, self).fixtype(obj) + return super().fixtype(obj) # Currently the bytes containment testing uses a single integer # value. This may not be the final design, but until then the @@ -1039,26 +1120,22 @@ class FixedStringTest(test.string_tests.BaseTest): pass def test_lower(self): pass - def test_hash(self): - # XXX check this out - pass - class ByteArrayAsStringTest(FixedStringTest): type2test = bytearray +class BytesAsStringTest(FixedStringTest): + type2test = bytes -class ByteArraySubclass(bytearray): - pass -class ByteArraySubclassTest(unittest.TestCase): +class SubclassTest(unittest.TestCase): def test_basic(self): - self.assertTrue(issubclass(ByteArraySubclass, bytearray)) - self.assertIsInstance(ByteArraySubclass(), bytearray) + self.assertTrue(issubclass(self.subclass2test, self.type2test)) + self.assertIsInstance(self.subclass2test(), self.type2test) a, b = b"abcd", b"efgh" - _a, _b = ByteArraySubclass(a), ByteArraySubclass(b) + _a, _b = self.subclass2test(a), self.subclass2test(b) # test comparison operators with subclass instances self.assertTrue(_a == _a) @@ -1081,19 +1158,19 @@ class ByteArraySubclassTest(unittest.TestCase): # Make sure join returns a NEW object for single item sequences # involving a subclass. # Make sure that it is of the appropriate type. - s1 = ByteArraySubclass(b"abcd") - s2 = bytearray().join([s1]) + s1 = self.subclass2test(b"abcd") + s2 = self.type2test().join([s1]) self.assertTrue(s1 is not s2) - self.assertTrue(type(s2) is bytearray, type(s2)) + self.assertTrue(type(s2) is self.type2test, type(s2)) # Test reverse, calling join on subclass s3 = s1.join([b"abcd"]) - self.assertTrue(type(s3) is bytearray) + self.assertTrue(type(s3) is self.type2test) def test_pickle(self): - a = ByteArraySubclass(b"abcd") + a = self.subclass2test(b"abcd") a.x = 10 - a.y = ByteArraySubclass(b"efgh") + a.y = self.subclass2test(b"efgh") for proto in range(pickle.HIGHEST_PROTOCOL + 1): b = pickle.loads(pickle.dumps(a, proto)) self.assertNotEqual(id(a), id(b)) @@ -1104,9 +1181,9 @@ class ByteArraySubclassTest(unittest.TestCase): self.assertEqual(type(a.y), type(b.y)) def test_copy(self): - a = ByteArraySubclass(b"abcd") + a = self.subclass2test(b"abcd") a.x = 10 - a.y = ByteArraySubclass(b"efgh") + a.y = self.subclass2test(b"efgh") for copy_method in (copy.copy, copy.deepcopy): b = copy_method(a) self.assertNotEqual(id(a), id(b)) @@ -1116,24 +1193,38 @@ class ByteArraySubclassTest(unittest.TestCase): self.assertEqual(type(a), type(b)) self.assertEqual(type(a.y), type(b.y)) + +class ByteArraySubclass(bytearray): + pass + +class BytesSubclass(bytes): + pass + +class ByteArraySubclassTest(SubclassTest): + type2test = bytearray + subclass2test = ByteArraySubclass + def test_init_override(self): class subclass(bytearray): - def __init__(self, newarg=1, *args, **kwargs): - bytearray.__init__(self, *args, **kwargs) + def __init__(me, newarg=1, *args, **kwargs): + bytearray.__init__(me, *args, **kwargs) + x = subclass(4, b"abcd") x = subclass(4, source=b"abcd") self.assertEqual(x, b"abcd") x = subclass(newarg=4, source=b"abcd") self.assertEqual(x, b"abcd") + +class BytesSubclassTest(SubclassTest): + type2test = bytes + subclass2test = BytesSubclass + + def test_main(): - #test.test_support.run_unittest(BytesTest) - #test.test_support.run_unittest(AssortedBytesTest) - #test.test_support.run_unittest(BytesAsStringTest) - test.test_support.run_unittest( - ByteArrayTest, - ByteArrayAsStringTest, - ByteArraySubclassTest, - BytearrayPEP3137Test) + test.support.run_unittest( + BytesTest, AssortedBytesTest, BytesAsStringTest, + ByteArrayTest, ByteArrayAsStringTest, BytesSubclassTest, + ByteArraySubclassTest, BytearrayPEP3137Test) if __name__ == "__main__": test_main() |