14710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm"""Unit tests for the bytes and bytearray types. 24710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 34710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmXXX This is a mess. Common tests should be moved to buffer_tests.py, 44710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmwhich itself ought to be unified with string_tests.py (and the latter 54710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmshould be modernized). 64710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm""" 74710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 84710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport os 94710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport re 104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport sys 114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport copy 124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport functools 134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport pickle 144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport tempfile 154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport unittest 164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport test.test_support 174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport test.string_tests 184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport test.buffer_tests 194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmif sys.flags.bytes_warning: 224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def check_bytes_warnings(func): 234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @functools.wraps(func) 244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def wrapper(*args, **kw): 254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with test.test_support.check_warnings(('', BytesWarning)): 264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return func(*args, **kw) 274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return wrapper 284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmelse: 294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # no-op 304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def check_bytes_warnings(func): 314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return func 324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass Indexable: 354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, value=0): 364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.value = value 374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __index__(self): 384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self.value 394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass BaseBytesTest(unittest.TestCase): 424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_basics(self): 444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test() 454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(b), self.type2test) 464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.__class__, self.type2test) 474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_empty_sequence(self): 494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test() 504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(b), 0) 514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(IndexError, lambda: b[0]) 524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(IndexError, lambda: b[1]) 534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(IndexError, lambda: b[sys.maxint]) 544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(IndexError, lambda: b[sys.maxint+1]) 554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(IndexError, lambda: b[10**100]) 564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(IndexError, lambda: b[-1]) 574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(IndexError, lambda: b[-2]) 584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(IndexError, lambda: b[-sys.maxint]) 594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(IndexError, lambda: b[-sys.maxint-1]) 604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(IndexError, lambda: b[-sys.maxint-2]) 614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(IndexError, lambda: b[-10**100]) 624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_from_list(self): 644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ints = list(range(256)) 654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(i for i in ints) 664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(b), 256) 674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(b), ints) 684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_from_index(self): 704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test([Indexable(), Indexable(1), Indexable(254), 714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Indexable(255)]) 724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(b), [0, 1, 254, 255]) 734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test, [Indexable(-1)]) 744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test, [Indexable(256)]) 754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_from_ssize(self): 774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(0), b'') 784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(1), b'\x00') 794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(5), b'\x00\x00\x00\x00\x00') 804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test, -1) 814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test('0', 'ascii'), b'0') 834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b'0'), b'0') 844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, self.type2test, sys.maxsize + 1) 854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_constructor_type_errors(self): 874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, self.type2test, 0.0) 884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class C: 894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # allowed in 2.x 914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertRaises(TypeError, self.type2test, ["0"]) 924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, self.type2test, [0.0]) 934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, self.type2test, [None]) 944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, self.type2test, [C()]) 954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_constructor_value_errors(self): 974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test, [-1]) 984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test, [-sys.maxint]) 994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test, [-sys.maxint-1]) 1004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test, [-sys.maxint-2]) 1014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test, [-10**100]) 1024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test, [256]) 1034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test, [257]) 1044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test, [sys.maxint]) 1054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test, [sys.maxint+1]) 1064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test, [10**100]) 1074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_compare(self): 1094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b1 = self.type2test([1, 2, 3]) 1104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b2 = self.type2test([1, 2, 3]) 1114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b3 = self.type2test([1, 3]) 1124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b1, b2) 1144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b2 != b3) 1154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b1 <= b2) 1164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b1 <= b3) 1174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b1 < b3) 1184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b1 >= b2) 1194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b3 >= b2) 1204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b3 > b2) 1214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(b1 != b2) 1234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(b2 == b3) 1244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(b1 > b2) 1254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(b1 > b3) 1264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(b1 >= b3) 1274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(b1 < b2) 1284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(b3 < b2) 1294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(b3 <= b2) 1304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @check_bytes_warnings 1324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_compare_to_str(self): 1334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Byte comparisons with unicode should always fail! 1344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test this for all expected byte orders and Unicode character sizes 1354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b"\0a\0b\0c") == u"abc", False) 1364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b"\0\0\0a\0\0\0b\0\0\0c") == u"abc", False) 1374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b"a\0b\0c\0") == u"abc", False) 1384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b"a\0\0\0b\0\0\0c\0\0\0") == u"abc", False) 1394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test() == unicode(), False) 1404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test() != unicode(), True) 1414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_reversed(self): 1434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm input = list(map(ord, "Hello")) 1444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(input) 1454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm output = list(reversed(b)) 1464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm input.reverse() 1474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(output, input) 1484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_getslice(self): 1504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def by(s): 1514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self.type2test(map(ord, s)) 1524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = by("Hello, world") 1534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b[:5], by("Hello")) 1554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b[1:5], by("ello")) 1564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b[5:7], by(", ")) 1574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b[7:], by("world")) 1584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b[7:12], by("world")) 1594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b[7:100], by("world")) 1604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b[:-7], by("Hello")) 1624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b[-11:-7], by("ello")) 1634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b[-7:-5], by(", ")) 1644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b[-5:], by("world")) 1654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b[-5:12], by("world")) 1664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b[-5:100], by("world")) 1674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b[-100:5], by("Hello")) 1684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_extended_getslice(self): 1704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test extended slicing by comparing with list slicing. 1714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm L = list(range(255)) 1724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(L) 1734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100) 1744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for start in indices: 1754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for stop in indices: 1764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Skip step 0 (invalid) 1774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for step in indices[1:]: 1784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b[start:stop:step], self.type2test(L[start:stop:step])) 1794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_encoding(self): 1814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sample = u"Hello world\n\u1234\u5678\u9abc\udef0" 1824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for enc in ("utf8", "utf16"): 1834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(sample, enc) 1844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, self.type2test(sample.encode(enc))) 1854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(UnicodeEncodeError, self.type2test, sample, "latin1") 1864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(sample, "latin1", "ignore") 1874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, self.type2test(sample[:-4], "utf-8")) 1884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_decode(self): 1904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sample = u"Hello world\n\u1234\u5678\u9abc\def0\def0" 1914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for enc in ("utf8", "utf16"): 1924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(sample, enc) 1934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.decode(enc), sample) 1944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sample = u"Hello world\n\x80\x81\xfe\xff" 1954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(sample, "latin1") 1964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(UnicodeDecodeError, b.decode, "utf8") 1974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.decode("utf8", "ignore"), "Hello world\n") 1984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.decode(errors="ignore", encoding="utf8"), 1994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "Hello world\n") 2004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_from_int(self): 2024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(0) 2034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, self.type2test()) 2044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(10) 2054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, self.type2test([0]*10)) 2064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(10000) 2074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, self.type2test([0]*10000)) 2084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_concat(self): 2104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b1 = self.type2test(b"abc") 2114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b2 = self.type2test(b"def") 2124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b1 + b2, b"abcdef") 2134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b1 + bytes(b"def"), b"abcdef") 2144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bytes(b"def") + b1, b"defabc") 2154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, lambda: b1 + u"def") 2164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, lambda: u"abc" + b2) 2174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_repeat(self): 2194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for b in b"abc", self.type2test(b"abc"): 2204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b * 3, b"abcabcabc") 2214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b * 0, b"") 2224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b * -1, b"") 2234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, lambda: b * 3.14) 2244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, lambda: 3.14 * b) 2254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # XXX Shouldn't bytes and bytearray agree on what to raise? 2264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises((OverflowError, MemoryError), 2274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm lambda: b * sys.maxsize) 2284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_repeat_1char(self): 2304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b'x')*100, self.type2test([ord('x')]*100)) 2314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_contains(self): 2334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b"abc") 2344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn(ord('a'), b) 2354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn(int(ord('a')), b) 2364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotIn(200, b) 2374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, lambda: 300 in b) 2384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, lambda: -1 in b) 2394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, lambda: None in b) 2404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, lambda: float(ord('a')) in b) 2414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, lambda: u"a" in b) 2424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for f in bytes, bytearray: 2434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn(f(b""), b) 2444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn(f(b"a"), b) 2454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn(f(b"b"), b) 2464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn(f(b"c"), b) 2474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn(f(b"ab"), b) 2484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn(f(b"bc"), b) 2494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn(f(b"abc"), b) 2504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotIn(f(b"ac"), b) 2514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotIn(f(b"d"), b) 2524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotIn(f(b"dab"), b) 2534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotIn(f(b"abd"), b) 2544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_fromhex(self): 2564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, self.type2test.fromhex) 2574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, self.type2test.fromhex, 1) 2584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test.fromhex(u''), self.type2test()) 2594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray([0x1a, 0x2b, 0x30]) 2604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test.fromhex(u'1a2B30'), b) 2614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test.fromhex(u' 1A 2B 30 '), b) 2624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test.fromhex(u'0000'), b'\0\0') 2634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test.fromhex, u'a') 2644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test.fromhex, u'rt') 2654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test.fromhex, u'1a b cd') 2664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test.fromhex, u'\x00') 2674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, self.type2test.fromhex, u'12 \x00 34') 2684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_join(self): 2704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b"").join([]), b"") 2714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b"").join([b""]), b"") 2724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for lst in [[b"abc"], [b"a", b"bc"], [b"ab", b"c"], [b"a", b"b", b"c"]]: 2734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm lst = list(map(self.type2test, lst)) 2744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b"").join(lst), b"abc") 2754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b"").join(tuple(lst)), b"abc") 2764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b"").join(iter(lst)), b"abc") 2774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b".").join([b"ab", b"cd"]), b"ab.cd") 2784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # XXX more... 2794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_count(self): 2814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'mississippi') 2824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.count(b'i'), 4) 2834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.count(b'ss'), 2) 2844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.count(b'w'), 0) 2854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_startswith(self): 2874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'hello') 2884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(self.type2test().startswith(b"anything")) 2894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b.startswith(b"hello")) 2904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b.startswith(b"hel")) 2914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b.startswith(b"h")) 2924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(b.startswith(b"hellow")) 2934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(b.startswith(b"ha")) 2944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_endswith(self): 2964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'hello') 2974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(bytearray().endswith(b"anything")) 2984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b.endswith(b"hello")) 2994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b.endswith(b"llo")) 3004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b.endswith(b"o")) 3014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(b.endswith(b"whello")) 3024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(b.endswith(b"no")) 3034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_find(self): 3054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'mississippi') 3064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.find(b'ss'), 2) 3074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.find(b'ss', 3), 5) 3084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.find(b'ss', 1, 7), 2) 3094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.find(b'ss', 1, 3), -1) 3104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.find(b'w'), -1) 3114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.find(b'mississippian'), -1) 3124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_rfind(self): 3144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'mississippi') 3154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rfind(b'ss'), 5) 3164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rfind(b'ss', 3), 5) 3174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rfind(b'ss', 0, 6), 2) 3184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rfind(b'w'), -1) 3194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rfind(b'mississippian'), -1) 3204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_index(self): 3224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'world') 3234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.index(b'w'), 0) 3244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.index(b'orl'), 1) 3254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, b.index, b'worm') 3264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, b.index, b'ldo') 3274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_rindex(self): 3294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # XXX could be more rigorous 3304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'world') 3314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rindex(b'w'), 0) 3324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rindex(b'orl'), 1) 3334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, b.rindex, b'worm') 3344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, b.rindex, b'ldo') 3354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_replace(self): 3374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'mississippi') 3384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.replace(b'i', b'a'), b'massassappa') 3394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.replace(b'ss', b'x'), b'mixixippi') 3404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_split(self): 3424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'mississippi') 3434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.split(b'i'), [b'm', b'ss', b'ss', b'pp', b'']) 3444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.split(b'ss'), [b'mi', b'i', b'ippi']) 3454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.split(b'w'), [b]) 3464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_split_whitespace(self): 3484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for b in (b' arf barf ', b'arf\tbarf', b'arf\nbarf', b'arf\rbarf', 3494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b'arf\fbarf', b'arf\vbarf'): 3504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b) 3514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.split(), [b'arf', b'barf']) 3524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.split(None), [b'arf', b'barf']) 3534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.split(None, 2), [b'arf', b'barf']) 3544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for b in (b'a\x1Cb', b'a\x1Db', b'a\x1Eb', b'a\x1Fb'): 3554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b) 3564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.split(), [b]) 3574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b' a bb c ').split(None, 0), [b'a bb c ']) 3584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b' a bb c ').split(None, 1), [b'a', b'bb c ']) 3594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b' a bb c ').split(None, 2), [b'a', b'bb', b'c ']) 3604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b' a bb c ').split(None, 3), [b'a', b'bb', b'c']) 3614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_split_string_error(self): 3634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, self.type2test(b'a b').split, u' ') 3644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_split_unicodewhitespace(self): 3664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b"\x09\x0A\x0B\x0C\x0D\x1C\x1D\x1E\x1F") 3674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.split(), [b'\x1c\x1d\x1e\x1f']) 3684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_rsplit(self): 3704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'mississippi') 3714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rsplit(b'i'), [b'm', b'ss', b'ss', b'pp', b'']) 3724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rsplit(b'ss'), [b'mi', b'i', b'ippi']) 3734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rsplit(b'w'), [b]) 3744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_rsplit_whitespace(self): 3764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for b in (b' arf barf ', b'arf\tbarf', b'arf\nbarf', b'arf\rbarf', 3774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b'arf\fbarf', b'arf\vbarf'): 3784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b) 3794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rsplit(), [b'arf', b'barf']) 3804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rsplit(None), [b'arf', b'barf']) 3814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rsplit(None, 2), [b'arf', b'barf']) 3824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b' a bb c ').rsplit(None, 0), [b' a bb c']) 3834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b' a bb c ').rsplit(None, 1), [b' a bb', b'c']) 3844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b' a bb c ').rsplit(None, 2), [b' a', b'bb', b'c']) 3854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b' a bb c ').rsplit(None, 3), [b'a', b'bb', b'c']) 3864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_rsplit_string_error(self): 3884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, self.type2test(b'a b').rsplit, u' ') 3894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_rsplit_unicodewhitespace(self): 3914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b"\x09\x0A\x0B\x0C\x0D\x1C\x1D\x1E\x1F") 3924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rsplit(), [b'\x1c\x1d\x1e\x1f']) 3934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_partition(self): 3954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'mississippi') 3964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.partition(b'ss'), (b'mi', b'ss', b'issippi')) 3974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.partition(b'w'), (b'mississippi', b'', b'')) 3984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_rpartition(self): 4004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'mississippi') 4014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rpartition(b'ss'), (b'missi', b'ss', b'ippi')) 4024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rpartition(b'i'), (b'mississipp', b'i', b'')) 4034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rpartition(b'w'), (b'', b'', b'mississippi')) 4044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_pickling(self): 4064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for proto in range(pickle.HIGHEST_PROTOCOL + 1): 4074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for b in b"", b"a", b"abc", b"\xffab\x80", b"\0\0\377\0\0": 4084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b) 4094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ps = pickle.dumps(b, proto) 4104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm q = pickle.loads(ps) 4114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, q) 4124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_strip(self): 4144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'mississippi') 4154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.strip(b'i'), b'mississipp') 4164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.strip(b'm'), b'ississippi') 4174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.strip(b'pi'), b'mississ') 4184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.strip(b'im'), b'ssissipp') 4194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.strip(b'pim'), b'ssiss') 4204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.strip(b), b'') 4214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_lstrip(self): 4234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'mississippi') 4244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.lstrip(b'i'), b'mississippi') 4254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.lstrip(b'm'), b'ississippi') 4264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.lstrip(b'pi'), b'mississippi') 4274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.lstrip(b'im'), b'ssissippi') 4284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.lstrip(b'pim'), b'ssissippi') 4294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_rstrip(self): 4314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'mississippi') 4324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rstrip(b'i'), b'mississipp') 4334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rstrip(b'm'), b'mississippi') 4344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rstrip(b'pi'), b'mississ') 4354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rstrip(b'im'), b'mississipp') 4364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rstrip(b'pim'), b'mississ') 4374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_strip_whitespace(self): 4394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b' \t\n\r\f\vabc \t\n\r\f\v') 4404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.strip(), b'abc') 4414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.lstrip(), b'abc \t\n\r\f\v') 4424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.rstrip(), b' \t\n\r\f\vabc') 4434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_strip_bytearray(self): 4454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b'abc').strip(memoryview(b'ac')), b'b') 4464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b'abc').lstrip(memoryview(b'ac')), b'bc') 4474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(self.type2test(b'abc').rstrip(memoryview(b'ac')), b'ab') 4484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_strip_string_error(self): 4504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, self.type2test(b'abc').strip, u'b') 4514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, self.type2test(b'abc').lstrip, u'b') 4524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, self.type2test(b'abc').rstrip, u'b') 4534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_ord(self): 4554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'\0A\x7f\x80\xff') 4564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([ord(b[i:i+1]) for i in range(len(b))], 4574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [0, 65, 127, 128, 255]) 4584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_none_arguments(self): 4604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # issue 11828 4614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'hello') 4624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm l = self.type2test(b'l') 4634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm h = self.type2test(b'h') 4644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = self.type2test(b'x') 4654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm o = self.type2test(b'o') 4664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(2, b.find(l, None)) 4684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(3, b.find(l, -2, None)) 4694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(2, b.find(l, None, -2)) 4704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(0, b.find(h, None, None)) 4714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(3, b.rfind(l, None)) 4734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(3, b.rfind(l, -2, None)) 4744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(2, b.rfind(l, None, -2)) 4754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(0, b.rfind(h, None, None)) 4764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(2, b.index(l, None)) 4784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(3, b.index(l, -2, None)) 4794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(2, b.index(l, None, -2)) 4804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(0, b.index(h, None, None)) 4814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(3, b.rindex(l, None)) 4834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(3, b.rindex(l, -2, None)) 4844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(2, b.rindex(l, None, -2)) 4854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(0, b.rindex(h, None, None)) 4864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(2, b.count(l, None)) 4884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(1, b.count(l, -2, None)) 4894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(1, b.count(l, None, -2)) 4904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(0, b.count(x, None, None)) 4914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(True, b.endswith(o, None)) 4934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(True, b.endswith(o, -2, None)) 4944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(True, b.endswith(l, None, -2)) 4954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(False, b.endswith(x, None, None)) 4964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(True, b.startswith(h, None)) 4984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(True, b.startswith(l, -2, None)) 4994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(True, b.startswith(h, None, -2)) 5004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(False, b.startswith(x, None, None)) 5014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_find_etc_raise_correct_error_messages(self): 5034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # issue 11828 5044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = self.type2test(b'hello') 5054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = self.type2test(b'x') 5064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaisesRegexp(TypeError, r'\bfind\b', b.find, 5074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x, None, None, None) 5084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaisesRegexp(TypeError, r'\brfind\b', b.rfind, 5094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x, None, None, None) 5104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaisesRegexp(TypeError, r'\bindex\b', b.index, 5114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x, None, None, None) 5124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaisesRegexp(TypeError, r'\brindex\b', b.rindex, 5134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x, None, None, None) 5144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaisesRegexp(TypeError, r'\bcount\b', b.count, 5154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x, None, None, None) 5164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaisesRegexp(TypeError, r'\bstartswith\b', b.startswith, 5174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x, None, None, None) 5184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaisesRegexp(TypeError, r'\bendswith\b', b.endswith, 5194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x, None, None, None) 5204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass ByteArrayTest(BaseBytesTest): 5234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm type2test = bytearray 5244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_nohash(self): 5264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, hash, bytearray()) 5274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_bytearray_api(self): 5294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm short_sample = b"Hello world\n" 5304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sample = short_sample + b"\0"*(20 - len(short_sample)) 5314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tfn = tempfile.mktemp() 5324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 5334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Prepare 5344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with open(tfn, "wb") as f: 5354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f.write(short_sample) 5364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test readinto 5374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with open(tfn, "rb") as f: 5384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(20) 5394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = f.readinto(b) 5404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(n, len(short_sample)) 5414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Python 2.x 5424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b_sample = (ord(s) for s in sample) 5434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(b), list(b_sample)) 5444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test writing in binary mode 5454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with open(tfn, "wb") as f: 5464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f.write(b) 5474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with open(tfn, "rb") as f: 5484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(f.read(), sample) 5494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Text mode is ambiguous; don't test 5504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm finally: 5514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 5524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm os.remove(tfn) 5534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except os.error: 5544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 5554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_reverse(self): 5574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(b'hello') 5584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.reverse(), None) 5594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b'olleh') 5604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(b'hello1') # test even number of items 5614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b.reverse() 5624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b'1olleh') 5634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray() 5644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b.reverse() 5654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(b) 5664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_regexps(self): 5684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def by(s): 5694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return bytearray(map(ord, s)) 5704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = by("Hello, world") 5714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(re.findall(r"\w+", b), [by("Hello"), by("world")]) 5724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_setitem(self): 5744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray([1, 2, 3]) 5754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[1] = 100 5764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray([1, 100, 3])) 5774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[-1] = 200 5784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray([1, 100, 200])) 5794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[0] = Indexable(10) 5804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray([10, 100, 200])) 5814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 5824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[3] = 0 5834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("Didn't raise IndexError") 5844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except IndexError: 5854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 5864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 5874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[-10] = 0 5884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("Didn't raise IndexError") 5894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except IndexError: 5904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 5914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 5924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[0] = 256 5934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("Didn't raise ValueError") 5944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except ValueError: 5954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 5964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 5974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[0] = Indexable(-1) 5984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("Didn't raise ValueError") 5994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except ValueError: 6004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 6014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 6024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[0] = None 6034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("Didn't raise TypeError") 6044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except TypeError: 6054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 6064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_delitem(self): 6084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(range(10)) 6094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del b[0] 6104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray(range(1, 10))) 6114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del b[-1] 6124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray(range(1, 9))) 6134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del b[4] 6144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray([1, 2, 3, 4, 6, 7, 8])) 6154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_setslice(self): 6174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(range(10)) 6184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(b), list(range(10))) 6194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[0:5] = bytearray([1, 1, 1, 1, 1]) 6214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray([1, 1, 1, 1, 1, 5, 6, 7, 8, 9])) 6224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del b[0:-5] 6244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray([5, 6, 7, 8, 9])) 6254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[0:0] = bytearray([0, 1, 2, 3, 4]) 6274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray(range(10))) 6284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[-7:-3] = bytearray([100, 101]) 6304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray([0, 1, 2, 100, 101, 7, 8, 9])) 6314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[3:5] = [3, 4, 5, 6] 6334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray(range(10))) 6344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[3:0] = [42, 42, 42] 6364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray([0, 1, 2, 42, 42, 42, 3, 4, 5, 6, 7, 8, 9])) 6374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_extended_set_del_slice(self): 6394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm indices = (0, None, 1, 3, 19, 300, 1<<333, -1, -2, -31, -300) 6404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for start in indices: 6414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for stop in indices: 6424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Skip invalid step 0 6434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for step in indices[1:]: 6444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm L = list(range(255)) 6454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(L) 6464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Make sure we have a slice of exactly the right length, 6474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # but with different data. 6484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm data = L[start:stop:step] 6494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm data.reverse() 6504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm L[start:stop:step] = data 6514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[start:stop:step] = data 6524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray(L)) 6534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del L[start:stop:step] 6554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del b[start:stop:step] 6564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray(L)) 6574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_setslice_trap(self): 6594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # This test verifies that we correctly handle assigning self 6604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # to a slice of self (the old Lambert Meertens trap). 6614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(range(256)) 6624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[8:] = b 6634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray(list(range(8)) + list(range(256)))) 6644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_iconcat(self): 6664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(b"abc") 6674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b1 = b 6684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b += b"def" 6694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b"abcdef") 6704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b1) 6714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b is b1) 6724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b += b"xyz" 6734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b"abcdefxyz") 6744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 6754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b += u"" 6764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except TypeError: 6774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 6784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 6794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("bytes += unicode didn't raise TypeError") 6804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_irepeat(self): 6824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(b"abc") 6834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b1 = b 6844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b *= 3 6854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b"abcabcabc") 6864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b1) 6874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b is b1) 6884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_irepeat_1char(self): 6904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(b"x") 6914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b1 = b 6924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b *= 100 6934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b"x"*100) 6944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b1) 6954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b is b1) 6964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_alloc(self): 6984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray() 6994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm alloc = b.__alloc__() 7004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(alloc >= 0) 7014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm seq = [alloc] 7024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in range(100): 7034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b += b"x" 7044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm alloc = b.__alloc__() 7054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(alloc >= len(b)) 7064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if alloc not in seq: 7074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm seq.append(alloc) 7084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_extend(self): 7104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm orig = b'hello' 7114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = bytearray(orig) 7124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a.extend(a) 7134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a, orig + orig) 7144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a[5:], orig) 7154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = bytearray(b'') 7164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test iterators that don't have a __length_hint__ 7174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a.extend(map(ord, orig * 25)) 7184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a.extend(ord(x) for x in orig * 25) 7194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a, orig * 50) 7204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a[-5:], orig) 7214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = bytearray(b'') 7224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a.extend(iter(map(ord, orig * 50))) 7234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a, orig * 50) 7244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a[-5:], orig) 7254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = bytearray(b'') 7264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a.extend(list(map(ord, orig * 50))) 7274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a, orig * 50) 7284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a[-5:], orig) 7294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = bytearray(b'') 7304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, a.extend, [0, 1, 2, 256]) 7314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, a.extend, [0, 1, 2, -1]) 7324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(a), 0) 7334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = bytearray(b'') 7344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a.extend([Indexable(ord('a'))]) 7354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a, b'a') 7364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_remove(self): 7384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(b'hello') 7394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b.remove(ord('l')) 7404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b'helo') 7414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b.remove(ord('l')) 7424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b'heo') 7434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, lambda: b.remove(ord('l'))) 7444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, lambda: b.remove(400)) 7454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, lambda: b.remove(u'e')) 7464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # remove first and last 7474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b.remove(ord('o')) 7484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b.remove(ord('h')) 7494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b'e') 7504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, lambda: b.remove(u'e')) 7514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b.remove(Indexable(ord('e'))) 7524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b'') 7534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_pop(self): 7554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(b'world') 7564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.pop(), ord('d')) 7574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.pop(0), ord('w')) 7584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.pop(-2), ord('r')) 7594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(IndexError, lambda: b.pop(10)) 7604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(IndexError, lambda: bytearray().pop()) 7614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test for issue #6846 7624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bytearray(b'\xff').pop(), 0xff) 7634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_nosort(self): 7654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(AttributeError, lambda: bytearray().sort()) 7664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_append(self): 7684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(b'hell') 7694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b.append(ord('o')) 7704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b'hello') 7714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b.append(100), None) 7724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray() 7734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b.append(ord('A')) 7744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(b), 1) 7754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, lambda: b.append(u'o')) 7764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray() 7774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b.append(Indexable(ord('A'))) 7784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b'A') 7794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_insert(self): 7814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(b'msssspp') 7824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b.insert(1, ord('i')) 7834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b.insert(4, ord('i')) 7844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b.insert(-2, ord('i')) 7854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b.insert(1000, ord('i')) 7864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b'mississippi') 7874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # allowed in 2.x 7884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertRaises(TypeError, lambda: b.insert(0, b'1')) 7894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray() 7904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b.insert(0, Indexable(ord('A'))) 7914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b'A') 7924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_copied(self): 7944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Issue 4348. Make sure that operations that don't mutate the array 7954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # copy the bytes. 7964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(b'abc') 7974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(b is b.replace(b'abc', b'cde', 0)) 7984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t = bytearray([i for i in range(256)]) 8004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = bytearray(b'') 8014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(x is x.translate(t)) 8024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_partition_bytearray_doesnt_share_nullstring(self): 8044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a, b, c = bytearray(b"x").partition(b"y") 8054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b"") 8064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(c, b"") 8074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b is not c) 8084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b += b"!" 8094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(c, b"") 8104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a, b, c = bytearray(b"x").partition(b"y") 8114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b"") 8124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(c, b"") 8134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Same for rpartition 8144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b, c, a = bytearray(b"x").rpartition(b"y") 8154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b"") 8164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(c, b"") 8174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(b is not c) 8184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b += b"!" 8194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(c, b"") 8204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c, b, a = bytearray(b"x").rpartition(b"y") 8214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b"") 8224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(c, b"") 8234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_resize_forbidden(self): 8254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # #4509: can't resize a bytearray when there are buffer exports, even 8264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # if it wouldn't reallocate the underlying buffer. 8274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Furthermore, no destructive changes to the buffer may be applied 8284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # before raising the error. 8294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(range(10)) 8304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = memoryview(b) 8314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def resize(n): 8324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[1:-1] = range(n + 1, 2*n - 1) 8334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm resize(10) 8344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm orig = b[:] 8354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(BufferError, resize, 11) 8364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, orig) 8374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(BufferError, resize, 9) 8384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, orig) 8394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(BufferError, resize, 0) 8404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, orig) 8414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Other operations implying resize 8424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(BufferError, b.pop, 0) 8434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, orig) 8444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(BufferError, b.remove, b[1]) 8454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, orig) 8464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def delitem(): 8474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del b[1] 8484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(BufferError, delitem) 8494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, orig) 8504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # deleting a non-contiguous slice 8514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def delslice(): 8524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b[1:-1:2] = b"" 8534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(BufferError, delslice) 8544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, orig) 8554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_empty_bytearray(self): 8574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Issue #7561: operations on empty bytearrays could crash in many 8584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # situations, due to a fragile implementation of the 8594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # PyByteArray_AS_STRING() C macro. 8604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, int, bytearray(b'')) 8614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass AssortedBytesTest(unittest.TestCase): 8644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 8654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test various combinations of bytes and bytearray 8664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 8674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @check_bytes_warnings 8694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_repr_str(self): 8704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for f in str, repr: 8714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(f(bytearray()), "bytearray(b'')") 8724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(f(bytearray([0])), "bytearray(b'\\x00')") 8734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(f(bytearray([0, 1, 254, 255])), 8744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "bytearray(b'\\x00\\x01\\xfe\\xff')") 8754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(f(b"abc"), "b'abc'") 8764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(f(b"'"), '''b"'"''') # ''' 8774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(f(b"'\""), r"""b'\'"'""") # ' 8784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_compare_bytes_to_bytearray(self): 8804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b"abc" == bytes(b"abc"), True) 8814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b"ab" != bytes(b"abc"), True) 8824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b"ab" <= bytes(b"abc"), True) 8834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b"ab" < bytes(b"abc"), True) 8844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b"abc" >= bytes(b"ab"), True) 8854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b"abc" > bytes(b"ab"), True) 8864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b"abc" != bytes(b"abc"), False) 8884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b"ab" == bytes(b"abc"), False) 8894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b"ab" > bytes(b"abc"), False) 8904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b"ab" >= bytes(b"abc"), False) 8914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b"abc" < bytes(b"ab"), False) 8924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b"abc" <= bytes(b"ab"), False) 8934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bytes(b"abc") == b"abc", True) 8954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bytes(b"ab") != b"abc", True) 8964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bytes(b"ab") <= b"abc", True) 8974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bytes(b"ab") < b"abc", True) 8984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bytes(b"abc") >= b"ab", True) 8994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bytes(b"abc") > b"ab", True) 9004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bytes(b"abc") != b"abc", False) 9024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bytes(b"ab") == b"abc", False) 9034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bytes(b"ab") > b"abc", False) 9044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bytes(b"ab") >= b"abc", False) 9054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bytes(b"abc") < b"ab", False) 9064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(bytes(b"abc") <= b"ab", False) 9074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_doc(self): 9094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIsNotNone(bytearray.__doc__) 9104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(bytearray.__doc__.startswith("bytearray("), bytearray.__doc__) 9114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIsNotNone(bytes.__doc__) 9124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(bytes.__doc__.startswith("bytes("), bytes.__doc__) 9134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_from_bytearray(self): 9154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sample = bytes(b"Hello world\n\x80\x81\xfe\xff") 9164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm buf = memoryview(sample) 9174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = bytearray(buf) 9184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray(sample)) 9194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @check_bytes_warnings 9214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_to_str(self): 9224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(b''), "b''") 9234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(b'x'), "b'x'") 9244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(b'\x80'), "b'\\x80'") 9254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(bytearray(b'')), "bytearray(b'')") 9264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(bytearray(b'x')), "bytearray(b'x')") 9274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(bytearray(b'\x80')), "bytearray(b'\\x80')") 9284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_literal(self): 9304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tests = [ 9314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (b"Wonderful spam", "Wonderful spam"), 9324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (br"Wonderful spam too", "Wonderful spam too"), 9334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (b"\xaa\x00\000\200", "\xaa\x00\000\200"), 9344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (br"\xaa\x00\000\200", r"\xaa\x00\000\200"), 9354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ] 9364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for b, s in tests: 9374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, bytearray(s, 'latin-1')) 9384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for c in range(128, 256): 9394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(SyntaxError, eval, 9404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'b"%s"' % chr(c)) 9414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_translate(self): 9434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = b'hello' 9444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ba = bytearray(b) 9454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rosetta = bytearray(range(0, 256)) 9464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rosetta[ord('o')] = ord('e') 9474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = b.translate(rosetta, b'l') 9484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b, b'hello') 9494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(c, b'hee') 9504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = ba.translate(rosetta, b'l') 9514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(ba, b'hello') 9524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(c, b'hee') 9534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = b.translate(None, b'e') 9544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(c, b'hllo') 9554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = ba.translate(None, b'e') 9564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(c, b'hllo') 9574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, b.translate, None, None) 9584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, ba.translate, None, None) 9594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_split_bytearray(self): 9614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b'a b'.split(memoryview(b' ')), [b'a', b'b']) 9624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_rsplit_bytearray(self): 9644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(b'a b'.rsplit(memoryview(b' ')), [b'a', b'b']) 9654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Optimizations: 9674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # __iter__? (optimization) 9684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # __reversed__? (optimization) 9694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # XXX More string methods? (Those that don't use character properties) 9714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # There are tests in string_tests.py that are more 9734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # comprehensive for things like split, partition, etc. 9744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Unfortunately they are all bundled with tests that 9754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # are not appropriate for bytes 9764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # I've started porting some of those into bytearray_tests.py, we should port 9784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # the rest that make sense (the code can be cleaned up to use modern 9794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # unittest methods at the same time). 9804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass BytearrayPEP3137Test(unittest.TestCase, 9824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test.buffer_tests.MixinBytesBufferCommonTests): 9834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def marshal(self, x): 9844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return bytearray(x) 9854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_returns_new_copy(self): 9874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm val = self.marshal(b'1234') 9884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # On immutable types these MAY return a reference to themselves 9894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # but on mutable types like bytearray they MUST return a new copy. 9904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for methname in ('zfill', 'rjust', 'ljust', 'center'): 9914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm method = getattr(val, methname) 9924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newval = method(3) 9934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(val, newval) 9944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(val is not newval, 9954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm methname+' returned self on a mutable object') 9964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for expr in ('val.split()[0]', 'val.rsplit()[0]', 9974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'val.partition(".")[0]', 'val.rpartition(".")[2]', 9984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'val.splitlines()[0]', 'val.replace("", "")'): 9994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm newval = eval(expr) 10004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(val, newval) 10014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(val is not newval, 10024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm expr+' returned val on a mutable object') 10034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass FixedStringTest(test.string_tests.BaseTest): 10054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def fixtype(self, obj): 10074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if isinstance(obj, str): 10084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return obj.encode("utf-8") 10094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return super(FixedStringTest, self).fixtype(obj) 10104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Currently the bytes containment testing uses a single integer 10124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # value. This may not be the final design, but until then the 10134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # bytes section with in a bytes containment not valid 10144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_contains(self): 10154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 10164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_expandtabs(self): 10174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 10184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_upper(self): 10194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 10204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_lower(self): 10214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 10224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_hash(self): 10234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # XXX check this out 10244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 10254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass ByteArrayAsStringTest(FixedStringTest): 10284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm type2test = bytearray 10294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass ByteArraySubclass(bytearray): 10324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 10334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass ByteArraySubclassTest(unittest.TestCase): 10354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_basic(self): 10374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(issubclass(ByteArraySubclass, bytearray)) 10384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIsInstance(ByteArraySubclass(), bytearray) 10394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a, b = b"abcd", b"efgh" 10414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm _a, _b = ByteArraySubclass(a), ByteArraySubclass(b) 10424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test comparison operators with subclass instances 10444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(_a == _a) 10454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(_a != _b) 10464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(_a < _b) 10474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(_a <= _b) 10484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(_b >= _a) 10494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(_b > _a) 10504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(_a is not a) 10514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test concat of subclass instances 10534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a + b, _a + _b) 10544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a + b, a + _b) 10554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a + b, _a + b) 10564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test repeat 10584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(a*5 == _a*5) 10594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_join(self): 10614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Make sure join returns a NEW object for single item sequences 10624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # involving a subclass. 10634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Make sure that it is of the appropriate type. 10644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s1 = ByteArraySubclass(b"abcd") 10654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s2 = bytearray().join([s1]) 10664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(s1 is not s2) 10674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(type(s2) is bytearray, type(s2)) 10684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test reverse, calling join on subclass 10704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s3 = s1.join([b"abcd"]) 10714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(type(s3) is bytearray) 10724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_pickle(self): 10744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = ByteArraySubclass(b"abcd") 10754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a.x = 10 10764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a.y = ByteArraySubclass(b"efgh") 10774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for proto in range(pickle.HIGHEST_PROTOCOL + 1): 10784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = pickle.loads(pickle.dumps(a, proto)) 10794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotEqual(id(a), id(b)) 10804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a, b) 10814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a.x, b.x) 10824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a.y, b.y) 10834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(a), type(b)) 10844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(a.y), type(b.y)) 10854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_copy(self): 10874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = ByteArraySubclass(b"abcd") 10884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a.x = 10 10894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a.y = ByteArraySubclass(b"efgh") 10904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for copy_method in (copy.copy, copy.deepcopy): 10914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = copy_method(a) 10924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotEqual(id(a), id(b)) 10934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a, b) 10944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a.x, b.x) 10954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a.y, b.y) 10964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(a), type(b)) 10974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(a.y), type(b.y)) 10984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_init_override(self): 11004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class subclass(bytearray): 11014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, newarg=1, *args, **kwargs): 11024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm bytearray.__init__(self, *args, **kwargs) 11034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = subclass(4, source=b"abcd") 11044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(x, b"abcd") 11054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = subclass(newarg=4, source=b"abcd") 11064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(x, b"abcd") 11074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef test_main(): 11094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #test.test_support.run_unittest(BytesTest) 11104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #test.test_support.run_unittest(AssortedBytesTest) 11114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #test.test_support.run_unittest(BytesAsStringTest) 11124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test.test_support.run_unittest( 11134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ByteArrayTest, 11144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ByteArrayAsStringTest, 11154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ByteArraySubclassTest, 11164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm BytearrayPEP3137Test) 11174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmif __name__ == "__main__": 11194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_main() 1120