1"""Unit tests for the bytes and bytearray types. 2 3XXX This is a mess. Common tests should be unified with string_tests.py (and 4the latter should be modernized). 5""" 6 7import array 8import os 9import re 10import sys 11import copy 12import functools 13import pickle 14import tempfile 15import unittest 16 17import test.support 18import test.string_tests 19import test.list_tests 20from test.support import bigaddrspacetest, MAX_Py_ssize_t 21 22 23if sys.flags.bytes_warning: 24 def check_bytes_warnings(func): 25 @functools.wraps(func) 26 def wrapper(*args, **kw): 27 with test.support.check_warnings(('', BytesWarning)): 28 return func(*args, **kw) 29 return wrapper 30else: 31 # no-op 32 def check_bytes_warnings(func): 33 return func 34 35 36class Indexable: 37 def __init__(self, value=0): 38 self.value = value 39 def __index__(self): 40 return self.value 41 42 43class BaseBytesTest: 44 45 def test_basics(self): 46 b = self.type2test() 47 self.assertEqual(type(b), self.type2test) 48 self.assertEqual(b.__class__, self.type2test) 49 50 def test_copy(self): 51 a = self.type2test(b"abcd") 52 for copy_method in (copy.copy, copy.deepcopy): 53 b = copy_method(a) 54 self.assertEqual(a, b) 55 self.assertEqual(type(a), type(b)) 56 57 def test_empty_sequence(self): 58 b = self.type2test() 59 self.assertEqual(len(b), 0) 60 self.assertRaises(IndexError, lambda: b[0]) 61 self.assertRaises(IndexError, lambda: b[1]) 62 self.assertRaises(IndexError, lambda: b[sys.maxsize]) 63 self.assertRaises(IndexError, lambda: b[sys.maxsize+1]) 64 self.assertRaises(IndexError, lambda: b[10**100]) 65 self.assertRaises(IndexError, lambda: b[-1]) 66 self.assertRaises(IndexError, lambda: b[-2]) 67 self.assertRaises(IndexError, lambda: b[-sys.maxsize]) 68 self.assertRaises(IndexError, lambda: b[-sys.maxsize-1]) 69 self.assertRaises(IndexError, lambda: b[-sys.maxsize-2]) 70 self.assertRaises(IndexError, lambda: b[-10**100]) 71 72 def test_from_list(self): 73 ints = list(range(256)) 74 b = self.type2test(i for i in ints) 75 self.assertEqual(len(b), 256) 76 self.assertEqual(list(b), ints) 77 78 def test_from_index(self): 79 b = self.type2test([Indexable(), Indexable(1), Indexable(254), 80 Indexable(255)]) 81 self.assertEqual(list(b), [0, 1, 254, 255]) 82 self.assertRaises(ValueError, self.type2test, [Indexable(-1)]) 83 self.assertRaises(ValueError, self.type2test, [Indexable(256)]) 84 85 def test_from_buffer(self): 86 a = self.type2test(array.array('B', [1, 2, 3])) 87 self.assertEqual(a, b"\x01\x02\x03") 88 89 # http://bugs.python.org/issue29159 90 # Fallback when __index__ raises exception other than OverflowError 91 class B(bytes): 92 def __index__(self): 93 raise TypeError 94 95 self.assertEqual(self.type2test(B(b"foobar")), b"foobar") 96 97 def test_from_ssize(self): 98 self.assertEqual(self.type2test(0), b'') 99 self.assertEqual(self.type2test(1), b'\x00') 100 self.assertEqual(self.type2test(5), b'\x00\x00\x00\x00\x00') 101 self.assertRaises(ValueError, self.type2test, -1) 102 103 self.assertEqual(self.type2test('0', 'ascii'), b'0') 104 self.assertEqual(self.type2test(b'0'), b'0') 105 self.assertRaises(OverflowError, self.type2test, sys.maxsize + 1) 106 107 def test_constructor_type_errors(self): 108 self.assertRaises(TypeError, self.type2test, 0.0) 109 class C: 110 pass 111 self.assertRaises(TypeError, self.type2test, ["0"]) 112 self.assertRaises(TypeError, self.type2test, [0.0]) 113 self.assertRaises(TypeError, self.type2test, [None]) 114 self.assertRaises(TypeError, self.type2test, [C()]) 115 self.assertRaises(TypeError, self.type2test, 0, 'ascii') 116 self.assertRaises(TypeError, self.type2test, b'', 'ascii') 117 self.assertRaises(TypeError, self.type2test, 0, errors='ignore') 118 self.assertRaises(TypeError, self.type2test, b'', errors='ignore') 119 self.assertRaises(TypeError, self.type2test, '') 120 self.assertRaises(TypeError, self.type2test, '', errors='ignore') 121 self.assertRaises(TypeError, self.type2test, '', b'ascii') 122 self.assertRaises(TypeError, self.type2test, '', 'ascii', b'ignore') 123 124 def test_constructor_value_errors(self): 125 self.assertRaises(ValueError, self.type2test, [-1]) 126 self.assertRaises(ValueError, self.type2test, [-sys.maxsize]) 127 self.assertRaises(ValueError, self.type2test, [-sys.maxsize-1]) 128 self.assertRaises(ValueError, self.type2test, [-sys.maxsize-2]) 129 self.assertRaises(ValueError, self.type2test, [-10**100]) 130 self.assertRaises(ValueError, self.type2test, [256]) 131 self.assertRaises(ValueError, self.type2test, [257]) 132 self.assertRaises(ValueError, self.type2test, [sys.maxsize]) 133 self.assertRaises(ValueError, self.type2test, [sys.maxsize+1]) 134 self.assertRaises(ValueError, self.type2test, [10**100]) 135 136 @bigaddrspacetest 137 def test_constructor_overflow(self): 138 size = MAX_Py_ssize_t 139 self.assertRaises((OverflowError, MemoryError), self.type2test, size) 140 try: 141 # Should either pass or raise an error (e.g. on debug builds with 142 # additional malloc() overhead), but shouldn't crash. 143 bytearray(size - 4) 144 except (OverflowError, MemoryError): 145 pass 146 147 def test_compare(self): 148 b1 = self.type2test([1, 2, 3]) 149 b2 = self.type2test([1, 2, 3]) 150 b3 = self.type2test([1, 3]) 151 152 self.assertEqual(b1, b2) 153 self.assertTrue(b2 != b3) 154 self.assertTrue(b1 <= b2) 155 self.assertTrue(b1 <= b3) 156 self.assertTrue(b1 < b3) 157 self.assertTrue(b1 >= b2) 158 self.assertTrue(b3 >= b2) 159 self.assertTrue(b3 > b2) 160 161 self.assertFalse(b1 != b2) 162 self.assertFalse(b2 == b3) 163 self.assertFalse(b1 > b2) 164 self.assertFalse(b1 > b3) 165 self.assertFalse(b1 >= b3) 166 self.assertFalse(b1 < b2) 167 self.assertFalse(b3 < b2) 168 self.assertFalse(b3 <= b2) 169 170 @check_bytes_warnings 171 def test_compare_to_str(self): 172 # Byte comparisons with unicode should always fail! 173 # Test this for all expected byte orders and Unicode character 174 # sizes. 175 self.assertEqual(self.type2test(b"\0a\0b\0c") == "abc", False) 176 self.assertEqual(self.type2test(b"\0\0\0a\0\0\0b\0\0\0c") == "abc", 177 False) 178 self.assertEqual(self.type2test(b"a\0b\0c\0") == "abc", False) 179 self.assertEqual(self.type2test(b"a\0\0\0b\0\0\0c\0\0\0") == "abc", 180 False) 181 self.assertEqual(self.type2test() == str(), False) 182 self.assertEqual(self.type2test() != str(), True) 183 184 def test_reversed(self): 185 input = list(map(ord, "Hello")) 186 b = self.type2test(input) 187 output = list(reversed(b)) 188 input.reverse() 189 self.assertEqual(output, input) 190 191 def test_getslice(self): 192 def by(s): 193 return self.type2test(map(ord, s)) 194 b = by("Hello, world") 195 196 self.assertEqual(b[:5], by("Hello")) 197 self.assertEqual(b[1:5], by("ello")) 198 self.assertEqual(b[5:7], by(", ")) 199 self.assertEqual(b[7:], by("world")) 200 self.assertEqual(b[7:12], by("world")) 201 self.assertEqual(b[7:100], by("world")) 202 203 self.assertEqual(b[:-7], by("Hello")) 204 self.assertEqual(b[-11:-7], by("ello")) 205 self.assertEqual(b[-7:-5], by(", ")) 206 self.assertEqual(b[-5:], by("world")) 207 self.assertEqual(b[-5:12], by("world")) 208 self.assertEqual(b[-5:100], by("world")) 209 self.assertEqual(b[-100:5], by("Hello")) 210 211 def test_extended_getslice(self): 212 # Test extended slicing by comparing with list slicing. 213 L = list(range(255)) 214 b = self.type2test(L) 215 indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100) 216 for start in indices: 217 for stop in indices: 218 # Skip step 0 (invalid) 219 for step in indices[1:]: 220 self.assertEqual(b[start:stop:step], self.type2test(L[start:stop:step])) 221 222 def test_encoding(self): 223 sample = "Hello world\n\u1234\u5678\u9abc" 224 for enc in ("utf-8", "utf-16"): 225 b = self.type2test(sample, enc) 226 self.assertEqual(b, self.type2test(sample.encode(enc))) 227 self.assertRaises(UnicodeEncodeError, self.type2test, sample, "latin-1") 228 b = self.type2test(sample, "latin-1", "ignore") 229 self.assertEqual(b, self.type2test(sample[:-3], "utf-8")) 230 231 def test_decode(self): 232 sample = "Hello world\n\u1234\u5678\u9abc" 233 for enc in ("utf-8", "utf-16"): 234 b = self.type2test(sample, enc) 235 self.assertEqual(b.decode(enc), sample) 236 sample = "Hello world\n\x80\x81\xfe\xff" 237 b = self.type2test(sample, "latin-1") 238 self.assertRaises(UnicodeDecodeError, b.decode, "utf-8") 239 self.assertEqual(b.decode("utf-8", "ignore"), "Hello world\n") 240 self.assertEqual(b.decode(errors="ignore", encoding="utf-8"), 241 "Hello world\n") 242 # Default encoding is utf-8 243 self.assertEqual(self.type2test(b'\xe2\x98\x83').decode(), '\u2603') 244 245 def test_from_int(self): 246 b = self.type2test(0) 247 self.assertEqual(b, self.type2test()) 248 b = self.type2test(10) 249 self.assertEqual(b, self.type2test([0]*10)) 250 b = self.type2test(10000) 251 self.assertEqual(b, self.type2test([0]*10000)) 252 253 def test_concat(self): 254 b1 = self.type2test(b"abc") 255 b2 = self.type2test(b"def") 256 self.assertEqual(b1 + b2, b"abcdef") 257 self.assertEqual(b1 + bytes(b"def"), b"abcdef") 258 self.assertEqual(bytes(b"def") + b1, b"defabc") 259 self.assertRaises(TypeError, lambda: b1 + "def") 260 self.assertRaises(TypeError, lambda: "abc" + b2) 261 262 def test_repeat(self): 263 for b in b"abc", self.type2test(b"abc"): 264 self.assertEqual(b * 3, b"abcabcabc") 265 self.assertEqual(b * 0, b"") 266 self.assertEqual(b * -1, b"") 267 self.assertRaises(TypeError, lambda: b * 3.14) 268 self.assertRaises(TypeError, lambda: 3.14 * b) 269 # XXX Shouldn't bytes and bytearray agree on what to raise? 270 with self.assertRaises((OverflowError, MemoryError)): 271 c = b * sys.maxsize 272 with self.assertRaises((OverflowError, MemoryError)): 273 b *= sys.maxsize 274 275 def test_repeat_1char(self): 276 self.assertEqual(self.type2test(b'x')*100, self.type2test([ord('x')]*100)) 277 278 def test_contains(self): 279 b = self.type2test(b"abc") 280 self.assertIn(ord('a'), b) 281 self.assertIn(int(ord('a')), b) 282 self.assertNotIn(200, b) 283 self.assertRaises(ValueError, lambda: 300 in b) 284 self.assertRaises(ValueError, lambda: -1 in b) 285 self.assertRaises(ValueError, lambda: sys.maxsize+1 in b) 286 self.assertRaises(TypeError, lambda: None in b) 287 self.assertRaises(TypeError, lambda: float(ord('a')) in b) 288 self.assertRaises(TypeError, lambda: "a" in b) 289 for f in bytes, bytearray: 290 self.assertIn(f(b""), b) 291 self.assertIn(f(b"a"), b) 292 self.assertIn(f(b"b"), b) 293 self.assertIn(f(b"c"), b) 294 self.assertIn(f(b"ab"), b) 295 self.assertIn(f(b"bc"), b) 296 self.assertIn(f(b"abc"), b) 297 self.assertNotIn(f(b"ac"), b) 298 self.assertNotIn(f(b"d"), b) 299 self.assertNotIn(f(b"dab"), b) 300 self.assertNotIn(f(b"abd"), b) 301 302 def test_fromhex(self): 303 self.assertRaises(TypeError, self.type2test.fromhex) 304 self.assertRaises(TypeError, self.type2test.fromhex, 1) 305 self.assertEqual(self.type2test.fromhex(''), self.type2test()) 306 b = bytearray([0x1a, 0x2b, 0x30]) 307 self.assertEqual(self.type2test.fromhex('1a2B30'), b) 308 self.assertEqual(self.type2test.fromhex(' 1A 2B 30 '), b) 309 self.assertEqual(self.type2test.fromhex('0000'), b'\0\0') 310 self.assertRaises(TypeError, self.type2test.fromhex, b'1B') 311 self.assertRaises(ValueError, self.type2test.fromhex, 'a') 312 self.assertRaises(ValueError, self.type2test.fromhex, 'rt') 313 self.assertRaises(ValueError, self.type2test.fromhex, '1a b cd') 314 self.assertRaises(ValueError, self.type2test.fromhex, '\x00') 315 self.assertRaises(ValueError, self.type2test.fromhex, '12 \x00 34') 316 317 for data, pos in ( 318 # invalid first hexadecimal character 319 ('12 x4 56', 3), 320 # invalid second hexadecimal character 321 ('12 3x 56', 4), 322 # two invalid hexadecimal characters 323 ('12 xy 56', 3), 324 # test non-ASCII string 325 ('12 3\xff 56', 4), 326 ): 327 with self.assertRaises(ValueError) as cm: 328 self.type2test.fromhex(data) 329 self.assertIn('at position %s' % pos, str(cm.exception)) 330 331 def test_hex(self): 332 self.assertRaises(TypeError, self.type2test.hex) 333 self.assertRaises(TypeError, self.type2test.hex, 1) 334 self.assertEqual(self.type2test(b"").hex(), "") 335 self.assertEqual(bytearray([0x1a, 0x2b, 0x30]).hex(), '1a2b30') 336 self.assertEqual(self.type2test(b"\x1a\x2b\x30").hex(), '1a2b30') 337 self.assertEqual(memoryview(b"\x1a\x2b\x30").hex(), '1a2b30') 338 339 def test_join(self): 340 self.assertEqual(self.type2test(b"").join([]), b"") 341 self.assertEqual(self.type2test(b"").join([b""]), b"") 342 for lst in [[b"abc"], [b"a", b"bc"], [b"ab", b"c"], [b"a", b"b", b"c"]]: 343 lst = list(map(self.type2test, lst)) 344 self.assertEqual(self.type2test(b"").join(lst), b"abc") 345 self.assertEqual(self.type2test(b"").join(tuple(lst)), b"abc") 346 self.assertEqual(self.type2test(b"").join(iter(lst)), b"abc") 347 dot_join = self.type2test(b".:").join 348 self.assertEqual(dot_join([b"ab", b"cd"]), b"ab.:cd") 349 self.assertEqual(dot_join([memoryview(b"ab"), b"cd"]), b"ab.:cd") 350 self.assertEqual(dot_join([b"ab", memoryview(b"cd")]), b"ab.:cd") 351 self.assertEqual(dot_join([bytearray(b"ab"), b"cd"]), b"ab.:cd") 352 self.assertEqual(dot_join([b"ab", bytearray(b"cd")]), b"ab.:cd") 353 # Stress it with many items 354 seq = [b"abc"] * 1000 355 expected = b"abc" + b".:abc" * 999 356 self.assertEqual(dot_join(seq), expected) 357 self.assertRaises(TypeError, self.type2test(b" ").join, None) 358 # Error handling and cleanup when some item in the middle of the 359 # sequence has the wrong type. 360 with self.assertRaises(TypeError): 361 dot_join([bytearray(b"ab"), "cd", b"ef"]) 362 with self.assertRaises(TypeError): 363 dot_join([memoryview(b"ab"), "cd", b"ef"]) 364 365 def test_count(self): 366 b = self.type2test(b'mississippi') 367 i = 105 368 p = 112 369 w = 119 370 371 self.assertEqual(b.count(b'i'), 4) 372 self.assertEqual(b.count(b'ss'), 2) 373 self.assertEqual(b.count(b'w'), 0) 374 375 self.assertEqual(b.count(i), 4) 376 self.assertEqual(b.count(w), 0) 377 378 self.assertEqual(b.count(b'i', 6), 2) 379 self.assertEqual(b.count(b'p', 6), 2) 380 self.assertEqual(b.count(b'i', 1, 3), 1) 381 self.assertEqual(b.count(b'p', 7, 9), 1) 382 383 self.assertEqual(b.count(i, 6), 2) 384 self.assertEqual(b.count(p, 6), 2) 385 self.assertEqual(b.count(i, 1, 3), 1) 386 self.assertEqual(b.count(p, 7, 9), 1) 387 388 def test_startswith(self): 389 b = self.type2test(b'hello') 390 self.assertFalse(self.type2test().startswith(b"anything")) 391 self.assertTrue(b.startswith(b"hello")) 392 self.assertTrue(b.startswith(b"hel")) 393 self.assertTrue(b.startswith(b"h")) 394 self.assertFalse(b.startswith(b"hellow")) 395 self.assertFalse(b.startswith(b"ha")) 396 with self.assertRaises(TypeError) as cm: 397 b.startswith([b'h']) 398 exc = str(cm.exception) 399 self.assertIn('bytes', exc) 400 self.assertIn('tuple', exc) 401 402 def test_endswith(self): 403 b = self.type2test(b'hello') 404 self.assertFalse(bytearray().endswith(b"anything")) 405 self.assertTrue(b.endswith(b"hello")) 406 self.assertTrue(b.endswith(b"llo")) 407 self.assertTrue(b.endswith(b"o")) 408 self.assertFalse(b.endswith(b"whello")) 409 self.assertFalse(b.endswith(b"no")) 410 with self.assertRaises(TypeError) as cm: 411 b.endswith([b'o']) 412 exc = str(cm.exception) 413 self.assertIn('bytes', exc) 414 self.assertIn('tuple', exc) 415 416 def test_find(self): 417 b = self.type2test(b'mississippi') 418 i = 105 419 w = 119 420 421 self.assertEqual(b.find(b'ss'), 2) 422 self.assertEqual(b.find(b'w'), -1) 423 self.assertEqual(b.find(b'mississippian'), -1) 424 425 self.assertEqual(b.find(i), 1) 426 self.assertEqual(b.find(w), -1) 427 428 self.assertEqual(b.find(b'ss', 3), 5) 429 self.assertEqual(b.find(b'ss', 1, 7), 2) 430 self.assertEqual(b.find(b'ss', 1, 3), -1) 431 432 self.assertEqual(b.find(i, 6), 7) 433 self.assertEqual(b.find(i, 1, 3), 1) 434 self.assertEqual(b.find(w, 1, 3), -1) 435 436 for index in (-1, 256, sys.maxsize + 1): 437 self.assertRaisesRegex( 438 ValueError, r'byte must be in range\(0, 256\)', 439 b.find, index) 440 441 def test_rfind(self): 442 b = self.type2test(b'mississippi') 443 i = 105 444 w = 119 445 446 self.assertEqual(b.rfind(b'ss'), 5) 447 self.assertEqual(b.rfind(b'w'), -1) 448 self.assertEqual(b.rfind(b'mississippian'), -1) 449 450 self.assertEqual(b.rfind(i), 10) 451 self.assertEqual(b.rfind(w), -1) 452 453 self.assertEqual(b.rfind(b'ss', 3), 5) 454 self.assertEqual(b.rfind(b'ss', 0, 6), 2) 455 456 self.assertEqual(b.rfind(i, 1, 3), 1) 457 self.assertEqual(b.rfind(i, 3, 9), 7) 458 self.assertEqual(b.rfind(w, 1, 3), -1) 459 460 def test_index(self): 461 b = self.type2test(b'mississippi') 462 i = 105 463 w = 119 464 465 self.assertEqual(b.index(b'ss'), 2) 466 self.assertRaises(ValueError, b.index, b'w') 467 self.assertRaises(ValueError, b.index, b'mississippian') 468 469 self.assertEqual(b.index(i), 1) 470 self.assertRaises(ValueError, b.index, w) 471 472 self.assertEqual(b.index(b'ss', 3), 5) 473 self.assertEqual(b.index(b'ss', 1, 7), 2) 474 self.assertRaises(ValueError, b.index, b'ss', 1, 3) 475 476 self.assertEqual(b.index(i, 6), 7) 477 self.assertEqual(b.index(i, 1, 3), 1) 478 self.assertRaises(ValueError, b.index, w, 1, 3) 479 480 def test_rindex(self): 481 b = self.type2test(b'mississippi') 482 i = 105 483 w = 119 484 485 self.assertEqual(b.rindex(b'ss'), 5) 486 self.assertRaises(ValueError, b.rindex, b'w') 487 self.assertRaises(ValueError, b.rindex, b'mississippian') 488 489 self.assertEqual(b.rindex(i), 10) 490 self.assertRaises(ValueError, b.rindex, w) 491 492 self.assertEqual(b.rindex(b'ss', 3), 5) 493 self.assertEqual(b.rindex(b'ss', 0, 6), 2) 494 495 self.assertEqual(b.rindex(i, 1, 3), 1) 496 self.assertEqual(b.rindex(i, 3, 9), 7) 497 self.assertRaises(ValueError, b.rindex, w, 1, 3) 498 499 def test_mod(self): 500 b = self.type2test(b'hello, %b!') 501 orig = b 502 b = b % b'world' 503 self.assertEqual(b, b'hello, world!') 504 self.assertEqual(orig, b'hello, %b!') 505 self.assertFalse(b is orig) 506 b = self.type2test(b'%s / 100 = %d%%') 507 a = b % (b'seventy-nine', 79) 508 self.assertEqual(a, b'seventy-nine / 100 = 79%') 509 self.assertIs(type(a), self.type2test) 510 511 def test_imod(self): 512 b = self.type2test(b'hello, %b!') 513 orig = b 514 b %= b'world' 515 self.assertEqual(b, b'hello, world!') 516 self.assertEqual(orig, b'hello, %b!') 517 self.assertFalse(b is orig) 518 b = self.type2test(b'%s / 100 = %d%%') 519 b %= (b'seventy-nine', 79) 520 self.assertEqual(b, b'seventy-nine / 100 = 79%') 521 self.assertIs(type(b), self.type2test) 522 523 def test_rmod(self): 524 with self.assertRaises(TypeError): 525 object() % self.type2test(b'abc') 526 self.assertIs(self.type2test(b'abc').__rmod__('%r'), NotImplemented) 527 528 def test_replace(self): 529 b = self.type2test(b'mississippi') 530 self.assertEqual(b.replace(b'i', b'a'), b'massassappa') 531 self.assertEqual(b.replace(b'ss', b'x'), b'mixixippi') 532 533 def test_split_string_error(self): 534 self.assertRaises(TypeError, self.type2test(b'a b').split, ' ') 535 536 def test_split_unicodewhitespace(self): 537 for b in (b'a\x1Cb', b'a\x1Db', b'a\x1Eb', b'a\x1Fb'): 538 b = self.type2test(b) 539 self.assertEqual(b.split(), [b]) 540 b = self.type2test(b"\x09\x0A\x0B\x0C\x0D\x1C\x1D\x1E\x1F") 541 self.assertEqual(b.split(), [b'\x1c\x1d\x1e\x1f']) 542 543 def test_rsplit_string_error(self): 544 self.assertRaises(TypeError, self.type2test(b'a b').rsplit, ' ') 545 546 def test_rsplit_unicodewhitespace(self): 547 b = self.type2test(b"\x09\x0A\x0B\x0C\x0D\x1C\x1D\x1E\x1F") 548 self.assertEqual(b.rsplit(), [b'\x1c\x1d\x1e\x1f']) 549 550 def test_partition(self): 551 b = self.type2test(b'mississippi') 552 self.assertEqual(b.partition(b'ss'), (b'mi', b'ss', b'issippi')) 553 self.assertEqual(b.partition(b'w'), (b'mississippi', b'', b'')) 554 555 def test_rpartition(self): 556 b = self.type2test(b'mississippi') 557 self.assertEqual(b.rpartition(b'ss'), (b'missi', b'ss', b'ippi')) 558 self.assertEqual(b.rpartition(b'i'), (b'mississipp', b'i', b'')) 559 self.assertEqual(b.rpartition(b'w'), (b'', b'', b'mississippi')) 560 561 def test_pickling(self): 562 for proto in range(pickle.HIGHEST_PROTOCOL + 1): 563 for b in b"", b"a", b"abc", b"\xffab\x80", b"\0\0\377\0\0": 564 b = self.type2test(b) 565 ps = pickle.dumps(b, proto) 566 q = pickle.loads(ps) 567 self.assertEqual(b, q) 568 569 def test_iterator_pickling(self): 570 for proto in range(pickle.HIGHEST_PROTOCOL + 1): 571 for b in b"", b"a", b"abc", b"\xffab\x80", b"\0\0\377\0\0": 572 it = itorg = iter(self.type2test(b)) 573 data = list(self.type2test(b)) 574 d = pickle.dumps(it, proto) 575 it = pickle.loads(d) 576 self.assertEqual(type(itorg), type(it)) 577 self.assertEqual(list(it), data) 578 579 it = pickle.loads(d) 580 if not b: 581 continue 582 next(it) 583 d = pickle.dumps(it, proto) 584 it = pickle.loads(d) 585 self.assertEqual(list(it), data[1:]) 586 587 def test_strip_bytearray(self): 588 self.assertEqual(self.type2test(b'abc').strip(memoryview(b'ac')), b'b') 589 self.assertEqual(self.type2test(b'abc').lstrip(memoryview(b'ac')), b'bc') 590 self.assertEqual(self.type2test(b'abc').rstrip(memoryview(b'ac')), b'ab') 591 592 def test_strip_string_error(self): 593 self.assertRaises(TypeError, self.type2test(b'abc').strip, 'b') 594 self.assertRaises(TypeError, self.type2test(b'abc').lstrip, 'b') 595 self.assertRaises(TypeError, self.type2test(b'abc').rstrip, 'b') 596 597 def test_center(self): 598 # Fill character can be either bytes or bytearray (issue 12380) 599 b = self.type2test(b'abc') 600 for fill_type in (bytes, bytearray): 601 self.assertEqual(b.center(7, fill_type(b'-')), 602 self.type2test(b'--abc--')) 603 604 def test_ljust(self): 605 # Fill character can be either bytes or bytearray (issue 12380) 606 b = self.type2test(b'abc') 607 for fill_type in (bytes, bytearray): 608 self.assertEqual(b.ljust(7, fill_type(b'-')), 609 self.type2test(b'abc----')) 610 611 def test_rjust(self): 612 # Fill character can be either bytes or bytearray (issue 12380) 613 b = self.type2test(b'abc') 614 for fill_type in (bytes, bytearray): 615 self.assertEqual(b.rjust(7, fill_type(b'-')), 616 self.type2test(b'----abc')) 617 618 def test_ord(self): 619 b = self.type2test(b'\0A\x7f\x80\xff') 620 self.assertEqual([ord(b[i:i+1]) for i in range(len(b))], 621 [0, 65, 127, 128, 255]) 622 623 def test_maketrans(self): 624 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' 625 self.assertEqual(self.type2test.maketrans(b'abc', b'xyz'), transtable) 626 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' 627 self.assertEqual(self.type2test.maketrans(b'\375\376\377', b'xyz'), transtable) 628 self.assertRaises(ValueError, self.type2test.maketrans, b'abc', b'xyzq') 629 self.assertRaises(TypeError, self.type2test.maketrans, 'abc', 'def') 630 631 def test_none_arguments(self): 632 # issue 11828 633 b = self.type2test(b'hello') 634 l = self.type2test(b'l') 635 h = self.type2test(b'h') 636 x = self.type2test(b'x') 637 o = self.type2test(b'o') 638 639 self.assertEqual(2, b.find(l, None)) 640 self.assertEqual(3, b.find(l, -2, None)) 641 self.assertEqual(2, b.find(l, None, -2)) 642 self.assertEqual(0, b.find(h, None, None)) 643 644 self.assertEqual(3, b.rfind(l, None)) 645 self.assertEqual(3, b.rfind(l, -2, None)) 646 self.assertEqual(2, b.rfind(l, None, -2)) 647 self.assertEqual(0, b.rfind(h, None, None)) 648 649 self.assertEqual(2, b.index(l, None)) 650 self.assertEqual(3, b.index(l, -2, None)) 651 self.assertEqual(2, b.index(l, None, -2)) 652 self.assertEqual(0, b.index(h, None, None)) 653 654 self.assertEqual(3, b.rindex(l, None)) 655 self.assertEqual(3, b.rindex(l, -2, None)) 656 self.assertEqual(2, b.rindex(l, None, -2)) 657 self.assertEqual(0, b.rindex(h, None, None)) 658 659 self.assertEqual(2, b.count(l, None)) 660 self.assertEqual(1, b.count(l, -2, None)) 661 self.assertEqual(1, b.count(l, None, -2)) 662 self.assertEqual(0, b.count(x, None, None)) 663 664 self.assertEqual(True, b.endswith(o, None)) 665 self.assertEqual(True, b.endswith(o, -2, None)) 666 self.assertEqual(True, b.endswith(l, None, -2)) 667 self.assertEqual(False, b.endswith(x, None, None)) 668 669 self.assertEqual(True, b.startswith(h, None)) 670 self.assertEqual(True, b.startswith(l, -2, None)) 671 self.assertEqual(True, b.startswith(h, None, -2)) 672 self.assertEqual(False, b.startswith(x, None, None)) 673 674 def test_integer_arguments_out_of_byte_range(self): 675 b = self.type2test(b'hello') 676 677 for method in (b.count, b.find, b.index, b.rfind, b.rindex): 678 self.assertRaises(ValueError, method, -1) 679 self.assertRaises(ValueError, method, 256) 680 self.assertRaises(ValueError, method, 9999) 681 682 def test_find_etc_raise_correct_error_messages(self): 683 # issue 11828 684 b = self.type2test(b'hello') 685 x = self.type2test(b'x') 686 self.assertRaisesRegex(TypeError, r'\bfind\b', b.find, 687 x, None, None, None) 688 self.assertRaisesRegex(TypeError, r'\brfind\b', b.rfind, 689 x, None, None, None) 690 self.assertRaisesRegex(TypeError, r'\bindex\b', b.index, 691 x, None, None, None) 692 self.assertRaisesRegex(TypeError, r'\brindex\b', b.rindex, 693 x, None, None, None) 694 self.assertRaisesRegex(TypeError, r'\bcount\b', b.count, 695 x, None, None, None) 696 self.assertRaisesRegex(TypeError, r'\bstartswith\b', b.startswith, 697 x, None, None, None) 698 self.assertRaisesRegex(TypeError, r'\bendswith\b', b.endswith, 699 x, None, None, None) 700 701 def test_free_after_iterating(self): 702 test.support.check_free_after_iterating(self, iter, self.type2test) 703 test.support.check_free_after_iterating(self, reversed, self.type2test) 704 705 def test_translate(self): 706 b = self.type2test(b'hello') 707 rosetta = bytearray(range(256)) 708 rosetta[ord('o')] = ord('e') 709 710 self.assertRaises(TypeError, b.translate) 711 self.assertRaises(TypeError, b.translate, None, None) 712 self.assertRaises(ValueError, b.translate, bytes(range(255))) 713 714 c = b.translate(rosetta, b'hello') 715 self.assertEqual(b, b'hello') 716 self.assertIsInstance(c, self.type2test) 717 718 c = b.translate(rosetta) 719 d = b.translate(rosetta, b'') 720 self.assertEqual(c, d) 721 self.assertEqual(c, b'helle') 722 723 c = b.translate(rosetta, b'l') 724 self.assertEqual(c, b'hee') 725 c = b.translate(None, b'e') 726 self.assertEqual(c, b'hllo') 727 728 # test delete as a keyword argument 729 c = b.translate(rosetta, delete=b'') 730 self.assertEqual(c, b'helle') 731 c = b.translate(rosetta, delete=b'l') 732 self.assertEqual(c, b'hee') 733 c = b.translate(None, delete=b'e') 734 self.assertEqual(c, b'hllo') 735 736 737class BytesTest(BaseBytesTest, unittest.TestCase): 738 type2test = bytes 739 740 def test_getitem_error(self): 741 msg = "byte indices must be integers or slices" 742 with self.assertRaisesRegex(TypeError, msg): 743 b'python'['a'] 744 745 def test_buffer_is_readonly(self): 746 fd = os.open(__file__, os.O_RDONLY) 747 with open(fd, "rb", buffering=0) as f: 748 self.assertRaises(TypeError, f.readinto, b"") 749 750 def test_custom(self): 751 class A: 752 def __bytes__(self): 753 return b'abc' 754 self.assertEqual(bytes(A()), b'abc') 755 class A: pass 756 self.assertRaises(TypeError, bytes, A()) 757 class A: 758 def __bytes__(self): 759 return None 760 self.assertRaises(TypeError, bytes, A()) 761 class A: 762 def __bytes__(self): 763 return b'a' 764 def __index__(self): 765 return 42 766 self.assertEqual(bytes(A()), b'a') 767 # Issue #25766 768 class A(str): 769 def __bytes__(self): 770 return b'abc' 771 self.assertEqual(bytes(A('\u20ac')), b'abc') 772 self.assertEqual(bytes(A('\u20ac'), 'iso8859-15'), b'\xa4') 773 # Issue #24731 774 class A: 775 def __bytes__(self): 776 return OtherBytesSubclass(b'abc') 777 self.assertEqual(bytes(A()), b'abc') 778 self.assertIs(type(bytes(A())), OtherBytesSubclass) 779 self.assertEqual(BytesSubclass(A()), b'abc') 780 self.assertIs(type(BytesSubclass(A())), BytesSubclass) 781 782 # Test PyBytes_FromFormat() 783 def test_from_format(self): 784 ctypes = test.support.import_module('ctypes') 785 _testcapi = test.support.import_module('_testcapi') 786 from ctypes import pythonapi, py_object 787 from ctypes import ( 788 c_int, c_uint, 789 c_long, c_ulong, 790 c_size_t, c_ssize_t, 791 c_char_p) 792 793 PyBytes_FromFormat = pythonapi.PyBytes_FromFormat 794 PyBytes_FromFormat.restype = py_object 795 796 # basic tests 797 self.assertEqual(PyBytes_FromFormat(b'format'), 798 b'format') 799 self.assertEqual(PyBytes_FromFormat(b'Hello %s !', b'world'), 800 b'Hello world !') 801 802 # test formatters 803 self.assertEqual(PyBytes_FromFormat(b'c=%c', c_int(0)), 804 b'c=\0') 805 self.assertEqual(PyBytes_FromFormat(b'c=%c', c_int(ord('@'))), 806 b'c=@') 807 self.assertEqual(PyBytes_FromFormat(b'c=%c', c_int(255)), 808 b'c=\xff') 809 self.assertEqual(PyBytes_FromFormat(b'd=%d ld=%ld zd=%zd', 810 c_int(1), c_long(2), 811 c_size_t(3)), 812 b'd=1 ld=2 zd=3') 813 self.assertEqual(PyBytes_FromFormat(b'd=%d ld=%ld zd=%zd', 814 c_int(-1), c_long(-2), 815 c_size_t(-3)), 816 b'd=-1 ld=-2 zd=-3') 817 self.assertEqual(PyBytes_FromFormat(b'u=%u lu=%lu zu=%zu', 818 c_uint(123), c_ulong(456), 819 c_size_t(789)), 820 b'u=123 lu=456 zu=789') 821 self.assertEqual(PyBytes_FromFormat(b'i=%i', c_int(123)), 822 b'i=123') 823 self.assertEqual(PyBytes_FromFormat(b'i=%i', c_int(-123)), 824 b'i=-123') 825 self.assertEqual(PyBytes_FromFormat(b'x=%x', c_int(0xabc)), 826 b'x=abc') 827 828 sizeof_ptr = ctypes.sizeof(c_char_p) 829 830 if os.name == 'nt': 831 # Windows (MSCRT) 832 ptr_format = '0x%0{}X'.format(2 * sizeof_ptr) 833 def ptr_formatter(ptr): 834 return (ptr_format % ptr) 835 else: 836 # UNIX (glibc) 837 def ptr_formatter(ptr): 838 return '%#x' % ptr 839 840 ptr = 0xabcdef 841 self.assertEqual(PyBytes_FromFormat(b'ptr=%p', c_char_p(ptr)), 842 ('ptr=' + ptr_formatter(ptr)).encode('ascii')) 843 self.assertEqual(PyBytes_FromFormat(b's=%s', c_char_p(b'cstr')), 844 b's=cstr') 845 846 # test minimum and maximum integer values 847 size_max = c_size_t(-1).value 848 for formatstr, ctypes_type, value, py_formatter in ( 849 (b'%d', c_int, _testcapi.INT_MIN, str), 850 (b'%d', c_int, _testcapi.INT_MAX, str), 851 (b'%ld', c_long, _testcapi.LONG_MIN, str), 852 (b'%ld', c_long, _testcapi.LONG_MAX, str), 853 (b'%lu', c_ulong, _testcapi.ULONG_MAX, str), 854 (b'%zd', c_ssize_t, _testcapi.PY_SSIZE_T_MIN, str), 855 (b'%zd', c_ssize_t, _testcapi.PY_SSIZE_T_MAX, str), 856 (b'%zu', c_size_t, size_max, str), 857 (b'%p', c_char_p, size_max, ptr_formatter), 858 ): 859 self.assertEqual(PyBytes_FromFormat(formatstr, ctypes_type(value)), 860 py_formatter(value).encode('ascii')), 861 862 # width and precision (width is currently ignored) 863 self.assertEqual(PyBytes_FromFormat(b'%5s', b'a'), 864 b'a') 865 self.assertEqual(PyBytes_FromFormat(b'%.3s', b'abcdef'), 866 b'abc') 867 868 # '%%' formatter 869 self.assertEqual(PyBytes_FromFormat(b'%%'), 870 b'%') 871 self.assertEqual(PyBytes_FromFormat(b'[%%]'), 872 b'[%]') 873 self.assertEqual(PyBytes_FromFormat(b'%%%c', c_int(ord('_'))), 874 b'%_') 875 self.assertEqual(PyBytes_FromFormat(b'%%s'), 876 b'%s') 877 878 # Invalid formats and partial formatting 879 self.assertEqual(PyBytes_FromFormat(b'%'), b'%') 880 self.assertEqual(PyBytes_FromFormat(b'x=%i y=%', c_int(2), c_int(3)), 881 b'x=2 y=%') 882 883 # Issue #19969: %c must raise OverflowError for values 884 # not in the range [0; 255] 885 self.assertRaises(OverflowError, 886 PyBytes_FromFormat, b'%c', c_int(-1)) 887 self.assertRaises(OverflowError, 888 PyBytes_FromFormat, b'%c', c_int(256)) 889 890 def test_bytes_blocking(self): 891 class IterationBlocked(list): 892 __bytes__ = None 893 i = [0, 1, 2, 3] 894 self.assertEqual(bytes(i), b'\x00\x01\x02\x03') 895 self.assertRaises(TypeError, bytes, IterationBlocked(i)) 896 897 # At least in CPython, because bytes.__new__ and the C API 898 # PyBytes_FromObject have different fallback rules, integer 899 # fallback is handled specially, so test separately. 900 class IntBlocked(int): 901 __bytes__ = None 902 self.assertEqual(bytes(3), b'\0\0\0') 903 self.assertRaises(TypeError, bytes, IntBlocked(3)) 904 905 # While there is no separately-defined rule for handling bytes 906 # subclasses differently from other buffer-interface classes, 907 # an implementation may well special-case them (as CPython 2.x 908 # str did), so test them separately. 909 class BytesSubclassBlocked(bytes): 910 __bytes__ = None 911 self.assertEqual(bytes(b'ab'), b'ab') 912 self.assertRaises(TypeError, bytes, BytesSubclassBlocked(b'ab')) 913 914 class BufferBlocked(bytearray): 915 __bytes__ = None 916 ba, bb = bytearray(b'ab'), BufferBlocked(b'ab') 917 self.assertEqual(bytes(ba), b'ab') 918 self.assertRaises(TypeError, bytes, bb) 919 920 921class ByteArrayTest(BaseBytesTest, unittest.TestCase): 922 type2test = bytearray 923 924 def test_getitem_error(self): 925 msg = "bytearray indices must be integers or slices" 926 with self.assertRaisesRegex(TypeError, msg): 927 bytearray(b'python')['a'] 928 929 def test_setitem_error(self): 930 msg = "bytearray indices must be integers or slices" 931 with self.assertRaisesRegex(TypeError, msg): 932 b = bytearray(b'python') 933 b['a'] = "python" 934 935 def test_nohash(self): 936 self.assertRaises(TypeError, hash, bytearray()) 937 938 def test_bytearray_api(self): 939 short_sample = b"Hello world\n" 940 sample = short_sample + b"\0"*(20 - len(short_sample)) 941 tfn = tempfile.mktemp() 942 try: 943 # Prepare 944 with open(tfn, "wb") as f: 945 f.write(short_sample) 946 # Test readinto 947 with open(tfn, "rb") as f: 948 b = bytearray(20) 949 n = f.readinto(b) 950 self.assertEqual(n, len(short_sample)) 951 self.assertEqual(list(b), list(sample)) 952 # Test writing in binary mode 953 with open(tfn, "wb") as f: 954 f.write(b) 955 with open(tfn, "rb") as f: 956 self.assertEqual(f.read(), sample) 957 # Text mode is ambiguous; don't test 958 finally: 959 try: 960 os.remove(tfn) 961 except OSError: 962 pass 963 964 def test_reverse(self): 965 b = bytearray(b'hello') 966 self.assertEqual(b.reverse(), None) 967 self.assertEqual(b, b'olleh') 968 b = bytearray(b'hello1') # test even number of items 969 b.reverse() 970 self.assertEqual(b, b'1olleh') 971 b = bytearray() 972 b.reverse() 973 self.assertFalse(b) 974 975 def test_clear(self): 976 b = bytearray(b'python') 977 b.clear() 978 self.assertEqual(b, b'') 979 980 b = bytearray(b'') 981 b.clear() 982 self.assertEqual(b, b'') 983 984 b = bytearray(b'') 985 b.append(ord('r')) 986 b.clear() 987 b.append(ord('p')) 988 self.assertEqual(b, b'p') 989 990 def test_copy(self): 991 b = bytearray(b'abc') 992 bb = b.copy() 993 self.assertEqual(bb, b'abc') 994 995 b = bytearray(b'') 996 bb = b.copy() 997 self.assertEqual(bb, b'') 998 999 # test that it's indeed a copy and not a reference 1000 b = bytearray(b'abc') 1001 bb = b.copy() 1002 self.assertEqual(b, bb) 1003 self.assertIsNot(b, bb) 1004 bb.append(ord('d')) 1005 self.assertEqual(bb, b'abcd') 1006 self.assertEqual(b, b'abc') 1007 1008 def test_regexps(self): 1009 def by(s): 1010 return bytearray(map(ord, s)) 1011 b = by("Hello, world") 1012 self.assertEqual(re.findall(br"\w+", b), [by("Hello"), by("world")]) 1013 1014 def test_setitem(self): 1015 b = bytearray([1, 2, 3]) 1016 b[1] = 100 1017 self.assertEqual(b, bytearray([1, 100, 3])) 1018 b[-1] = 200 1019 self.assertEqual(b, bytearray([1, 100, 200])) 1020 b[0] = Indexable(10) 1021 self.assertEqual(b, bytearray([10, 100, 200])) 1022 try: 1023 b[3] = 0 1024 self.fail("Didn't raise IndexError") 1025 except IndexError: 1026 pass 1027 try: 1028 b[-10] = 0 1029 self.fail("Didn't raise IndexError") 1030 except IndexError: 1031 pass 1032 try: 1033 b[0] = 256 1034 self.fail("Didn't raise ValueError") 1035 except ValueError: 1036 pass 1037 try: 1038 b[0] = Indexable(-1) 1039 self.fail("Didn't raise ValueError") 1040 except ValueError: 1041 pass 1042 try: 1043 b[0] = None 1044 self.fail("Didn't raise TypeError") 1045 except TypeError: 1046 pass 1047 1048 def test_delitem(self): 1049 b = bytearray(range(10)) 1050 del b[0] 1051 self.assertEqual(b, bytearray(range(1, 10))) 1052 del b[-1] 1053 self.assertEqual(b, bytearray(range(1, 9))) 1054 del b[4] 1055 self.assertEqual(b, bytearray([1, 2, 3, 4, 6, 7, 8])) 1056 1057 def test_setslice(self): 1058 b = bytearray(range(10)) 1059 self.assertEqual(list(b), list(range(10))) 1060 1061 b[0:5] = bytearray([1, 1, 1, 1, 1]) 1062 self.assertEqual(b, bytearray([1, 1, 1, 1, 1, 5, 6, 7, 8, 9])) 1063 1064 del b[0:-5] 1065 self.assertEqual(b, bytearray([5, 6, 7, 8, 9])) 1066 1067 b[0:0] = bytearray([0, 1, 2, 3, 4]) 1068 self.assertEqual(b, bytearray(range(10))) 1069 1070 b[-7:-3] = bytearray([100, 101]) 1071 self.assertEqual(b, bytearray([0, 1, 2, 100, 101, 7, 8, 9])) 1072 1073 b[3:5] = [3, 4, 5, 6] 1074 self.assertEqual(b, bytearray(range(10))) 1075 1076 b[3:0] = [42, 42, 42] 1077 self.assertEqual(b, bytearray([0, 1, 2, 42, 42, 42, 3, 4, 5, 6, 7, 8, 9])) 1078 1079 b[3:] = b'foo' 1080 self.assertEqual(b, bytearray([0, 1, 2, 102, 111, 111])) 1081 1082 b[:3] = memoryview(b'foo') 1083 self.assertEqual(b, bytearray([102, 111, 111, 102, 111, 111])) 1084 1085 b[3:4] = [] 1086 self.assertEqual(b, bytearray([102, 111, 111, 111, 111])) 1087 1088 for elem in [5, -5, 0, int(10e20), 'str', 2.3, 1089 ['a', 'b'], [b'a', b'b'], [[]]]: 1090 with self.assertRaises(TypeError): 1091 b[3:4] = elem 1092 1093 for elem in [[254, 255, 256], [-256, 9000]]: 1094 with self.assertRaises(ValueError): 1095 b[3:4] = elem 1096 1097 def test_setslice_extend(self): 1098 # Exercise the resizing logic (see issue #19087) 1099 b = bytearray(range(100)) 1100 self.assertEqual(list(b), list(range(100))) 1101 del b[:10] 1102 self.assertEqual(list(b), list(range(10, 100))) 1103 b.extend(range(100, 110)) 1104 self.assertEqual(list(b), list(range(10, 110))) 1105 1106 def test_fifo_overrun(self): 1107 # Test for issue #23985, a buffer overrun when implementing a FIFO 1108 # Build Python in pydebug mode for best results. 1109 b = bytearray(10) 1110 b.pop() # Defeat expanding buffer off-by-one quirk 1111 del b[:1] # Advance start pointer without reallocating 1112 b += bytes(2) # Append exactly the number of deleted bytes 1113 del b # Free memory buffer, allowing pydebug verification 1114 1115 def test_del_expand(self): 1116 # Reducing the size should not expand the buffer (issue #23985) 1117 b = bytearray(10) 1118 size = sys.getsizeof(b) 1119 del b[:1] 1120 self.assertLessEqual(sys.getsizeof(b), size) 1121 1122 def test_extended_set_del_slice(self): 1123 indices = (0, None, 1, 3, 19, 300, 1<<333, -1, -2, -31, -300) 1124 for start in indices: 1125 for stop in indices: 1126 # Skip invalid step 0 1127 for step in indices[1:]: 1128 L = list(range(255)) 1129 b = bytearray(L) 1130 # Make sure we have a slice of exactly the right length, 1131 # but with different data. 1132 data = L[start:stop:step] 1133 data.reverse() 1134 L[start:stop:step] = data 1135 b[start:stop:step] = data 1136 self.assertEqual(b, bytearray(L)) 1137 1138 del L[start:stop:step] 1139 del b[start:stop:step] 1140 self.assertEqual(b, bytearray(L)) 1141 1142 def test_setslice_trap(self): 1143 # This test verifies that we correctly handle assigning self 1144 # to a slice of self (the old Lambert Meertens trap). 1145 b = bytearray(range(256)) 1146 b[8:] = b 1147 self.assertEqual(b, bytearray(list(range(8)) + list(range(256)))) 1148 1149 def test_iconcat(self): 1150 b = bytearray(b"abc") 1151 b1 = b 1152 b += b"def" 1153 self.assertEqual(b, b"abcdef") 1154 self.assertEqual(b, b1) 1155 self.assertTrue(b is b1) 1156 b += b"xyz" 1157 self.assertEqual(b, b"abcdefxyz") 1158 try: 1159 b += "" 1160 except TypeError: 1161 pass 1162 else: 1163 self.fail("bytes += unicode didn't raise TypeError") 1164 1165 def test_irepeat(self): 1166 b = bytearray(b"abc") 1167 b1 = b 1168 b *= 3 1169 self.assertEqual(b, b"abcabcabc") 1170 self.assertEqual(b, b1) 1171 self.assertTrue(b is b1) 1172 1173 def test_irepeat_1char(self): 1174 b = bytearray(b"x") 1175 b1 = b 1176 b *= 100 1177 self.assertEqual(b, b"x"*100) 1178 self.assertEqual(b, b1) 1179 self.assertTrue(b is b1) 1180 1181 def test_alloc(self): 1182 b = bytearray() 1183 alloc = b.__alloc__() 1184 self.assertTrue(alloc >= 0) 1185 seq = [alloc] 1186 for i in range(100): 1187 b += b"x" 1188 alloc = b.__alloc__() 1189 self.assertGreater(alloc, len(b)) # including trailing null byte 1190 if alloc not in seq: 1191 seq.append(alloc) 1192 1193 def test_init_alloc(self): 1194 b = bytearray() 1195 def g(): 1196 for i in range(1, 100): 1197 yield i 1198 a = list(b) 1199 self.assertEqual(a, list(range(1, len(a)+1))) 1200 self.assertEqual(len(b), len(a)) 1201 self.assertLessEqual(len(b), i) 1202 alloc = b.__alloc__() 1203 self.assertGreater(alloc, len(b)) # including trailing null byte 1204 b.__init__(g()) 1205 self.assertEqual(list(b), list(range(1, 100))) 1206 self.assertEqual(len(b), 99) 1207 alloc = b.__alloc__() 1208 self.assertGreater(alloc, len(b)) 1209 1210 def test_extend(self): 1211 orig = b'hello' 1212 a = bytearray(orig) 1213 a.extend(a) 1214 self.assertEqual(a, orig + orig) 1215 self.assertEqual(a[5:], orig) 1216 a = bytearray(b'') 1217 # Test iterators that don't have a __length_hint__ 1218 a.extend(map(int, orig * 25)) 1219 a.extend(int(x) for x in orig * 25) 1220 self.assertEqual(a, orig * 50) 1221 self.assertEqual(a[-5:], orig) 1222 a = bytearray(b'') 1223 a.extend(iter(map(int, orig * 50))) 1224 self.assertEqual(a, orig * 50) 1225 self.assertEqual(a[-5:], orig) 1226 a = bytearray(b'') 1227 a.extend(list(map(int, orig * 50))) 1228 self.assertEqual(a, orig * 50) 1229 self.assertEqual(a[-5:], orig) 1230 a = bytearray(b'') 1231 self.assertRaises(ValueError, a.extend, [0, 1, 2, 256]) 1232 self.assertRaises(ValueError, a.extend, [0, 1, 2, -1]) 1233 self.assertEqual(len(a), 0) 1234 a = bytearray(b'') 1235 a.extend([Indexable(ord('a'))]) 1236 self.assertEqual(a, b'a') 1237 1238 def test_remove(self): 1239 b = bytearray(b'hello') 1240 b.remove(ord('l')) 1241 self.assertEqual(b, b'helo') 1242 b.remove(ord('l')) 1243 self.assertEqual(b, b'heo') 1244 self.assertRaises(ValueError, lambda: b.remove(ord('l'))) 1245 self.assertRaises(ValueError, lambda: b.remove(400)) 1246 self.assertRaises(TypeError, lambda: b.remove('e')) 1247 # remove first and last 1248 b.remove(ord('o')) 1249 b.remove(ord('h')) 1250 self.assertEqual(b, b'e') 1251 self.assertRaises(TypeError, lambda: b.remove(b'e')) 1252 b.remove(Indexable(ord('e'))) 1253 self.assertEqual(b, b'') 1254 1255 # test values outside of the ascii range: (0, 127) 1256 c = bytearray([126, 127, 128, 129]) 1257 c.remove(127) 1258 self.assertEqual(c, bytes([126, 128, 129])) 1259 c.remove(129) 1260 self.assertEqual(c, bytes([126, 128])) 1261 1262 def test_pop(self): 1263 b = bytearray(b'world') 1264 self.assertEqual(b.pop(), ord('d')) 1265 self.assertEqual(b.pop(0), ord('w')) 1266 self.assertEqual(b.pop(-2), ord('r')) 1267 self.assertRaises(IndexError, lambda: b.pop(10)) 1268 self.assertRaises(IndexError, lambda: bytearray().pop()) 1269 # test for issue #6846 1270 self.assertEqual(bytearray(b'\xff').pop(), 0xff) 1271 1272 def test_nosort(self): 1273 self.assertRaises(AttributeError, lambda: bytearray().sort()) 1274 1275 def test_append(self): 1276 b = bytearray(b'hell') 1277 b.append(ord('o')) 1278 self.assertEqual(b, b'hello') 1279 self.assertEqual(b.append(100), None) 1280 b = bytearray() 1281 b.append(ord('A')) 1282 self.assertEqual(len(b), 1) 1283 self.assertRaises(TypeError, lambda: b.append(b'o')) 1284 b = bytearray() 1285 b.append(Indexable(ord('A'))) 1286 self.assertEqual(b, b'A') 1287 1288 def test_insert(self): 1289 b = bytearray(b'msssspp') 1290 b.insert(1, ord('i')) 1291 b.insert(4, ord('i')) 1292 b.insert(-2, ord('i')) 1293 b.insert(1000, ord('i')) 1294 self.assertEqual(b, b'mississippi') 1295 self.assertRaises(TypeError, lambda: b.insert(0, b'1')) 1296 b = bytearray() 1297 b.insert(0, Indexable(ord('A'))) 1298 self.assertEqual(b, b'A') 1299 1300 def test_copied(self): 1301 # Issue 4348. Make sure that operations that don't mutate the array 1302 # copy the bytes. 1303 b = bytearray(b'abc') 1304 self.assertFalse(b is b.replace(b'abc', b'cde', 0)) 1305 1306 t = bytearray([i for i in range(256)]) 1307 x = bytearray(b'') 1308 self.assertFalse(x is x.translate(t)) 1309 1310 def test_partition_bytearray_doesnt_share_nullstring(self): 1311 a, b, c = bytearray(b"x").partition(b"y") 1312 self.assertEqual(b, b"") 1313 self.assertEqual(c, b"") 1314 self.assertTrue(b is not c) 1315 b += b"!" 1316 self.assertEqual(c, b"") 1317 a, b, c = bytearray(b"x").partition(b"y") 1318 self.assertEqual(b, b"") 1319 self.assertEqual(c, b"") 1320 # Same for rpartition 1321 b, c, a = bytearray(b"x").rpartition(b"y") 1322 self.assertEqual(b, b"") 1323 self.assertEqual(c, b"") 1324 self.assertTrue(b is not c) 1325 b += b"!" 1326 self.assertEqual(c, b"") 1327 c, b, a = bytearray(b"x").rpartition(b"y") 1328 self.assertEqual(b, b"") 1329 self.assertEqual(c, b"") 1330 1331 def test_resize_forbidden(self): 1332 # #4509: can't resize a bytearray when there are buffer exports, even 1333 # if it wouldn't reallocate the underlying buffer. 1334 # Furthermore, no destructive changes to the buffer may be applied 1335 # before raising the error. 1336 b = bytearray(range(10)) 1337 v = memoryview(b) 1338 def resize(n): 1339 b[1:-1] = range(n + 1, 2*n - 1) 1340 resize(10) 1341 orig = b[:] 1342 self.assertRaises(BufferError, resize, 11) 1343 self.assertEqual(b, orig) 1344 self.assertRaises(BufferError, resize, 9) 1345 self.assertEqual(b, orig) 1346 self.assertRaises(BufferError, resize, 0) 1347 self.assertEqual(b, orig) 1348 # Other operations implying resize 1349 self.assertRaises(BufferError, b.pop, 0) 1350 self.assertEqual(b, orig) 1351 self.assertRaises(BufferError, b.remove, b[1]) 1352 self.assertEqual(b, orig) 1353 def delitem(): 1354 del b[1] 1355 self.assertRaises(BufferError, delitem) 1356 self.assertEqual(b, orig) 1357 # deleting a non-contiguous slice 1358 def delslice(): 1359 b[1:-1:2] = b"" 1360 self.assertRaises(BufferError, delslice) 1361 self.assertEqual(b, orig) 1362 1363 @test.support.cpython_only 1364 def test_obsolete_write_lock(self): 1365 from _testcapi import getbuffer_with_null_view 1366 self.assertRaises(BufferError, getbuffer_with_null_view, bytearray()) 1367 1368 def test_iterator_pickling2(self): 1369 orig = bytearray(b'abc') 1370 data = list(b'qwerty') 1371 for proto in range(pickle.HIGHEST_PROTOCOL + 1): 1372 # initial iterator 1373 itorig = iter(orig) 1374 d = pickle.dumps((itorig, orig), proto) 1375 it, b = pickle.loads(d) 1376 b[:] = data 1377 self.assertEqual(type(it), type(itorig)) 1378 self.assertEqual(list(it), data) 1379 1380 # running iterator 1381 next(itorig) 1382 d = pickle.dumps((itorig, orig), proto) 1383 it, b = pickle.loads(d) 1384 b[:] = data 1385 self.assertEqual(type(it), type(itorig)) 1386 self.assertEqual(list(it), data[1:]) 1387 1388 # empty iterator 1389 for i in range(1, len(orig)): 1390 next(itorig) 1391 d = pickle.dumps((itorig, orig), proto) 1392 it, b = pickle.loads(d) 1393 b[:] = data 1394 self.assertEqual(type(it), type(itorig)) 1395 self.assertEqual(list(it), data[len(orig):]) 1396 1397 # exhausted iterator 1398 self.assertRaises(StopIteration, next, itorig) 1399 d = pickle.dumps((itorig, orig), proto) 1400 it, b = pickle.loads(d) 1401 b[:] = data 1402 self.assertEqual(list(it), []) 1403 1404 test_exhausted_iterator = test.list_tests.CommonTest.test_exhausted_iterator 1405 1406 def test_iterator_length_hint(self): 1407 # Issue 27443: __length_hint__ can return negative integer 1408 ba = bytearray(b'ab') 1409 it = iter(ba) 1410 next(it) 1411 ba.clear() 1412 # Shouldn't raise an error 1413 self.assertEqual(list(it), []) 1414 1415 1416class AssortedBytesTest(unittest.TestCase): 1417 # 1418 # Test various combinations of bytes and bytearray 1419 # 1420 1421 @check_bytes_warnings 1422 def test_repr_str(self): 1423 for f in str, repr: 1424 self.assertEqual(f(bytearray()), "bytearray(b'')") 1425 self.assertEqual(f(bytearray([0])), "bytearray(b'\\x00')") 1426 self.assertEqual(f(bytearray([0, 1, 254, 255])), 1427 "bytearray(b'\\x00\\x01\\xfe\\xff')") 1428 self.assertEqual(f(b"abc"), "b'abc'") 1429 self.assertEqual(f(b"'"), '''b"'"''') # ''' 1430 self.assertEqual(f(b"'\""), r"""b'\'"'""") # ' 1431 1432 @check_bytes_warnings 1433 def test_format(self): 1434 for b in b'abc', bytearray(b'abc'): 1435 self.assertEqual(format(b), str(b)) 1436 self.assertEqual(format(b, ''), str(b)) 1437 with self.assertRaisesRegex(TypeError, 1438 r'\b%s\b' % re.escape(type(b).__name__)): 1439 format(b, 's') 1440 1441 def test_compare_bytes_to_bytearray(self): 1442 self.assertEqual(b"abc" == bytes(b"abc"), True) 1443 self.assertEqual(b"ab" != bytes(b"abc"), True) 1444 self.assertEqual(b"ab" <= bytes(b"abc"), True) 1445 self.assertEqual(b"ab" < bytes(b"abc"), True) 1446 self.assertEqual(b"abc" >= bytes(b"ab"), True) 1447 self.assertEqual(b"abc" > bytes(b"ab"), True) 1448 1449 self.assertEqual(b"abc" != bytes(b"abc"), False) 1450 self.assertEqual(b"ab" == bytes(b"abc"), False) 1451 self.assertEqual(b"ab" > bytes(b"abc"), False) 1452 self.assertEqual(b"ab" >= bytes(b"abc"), False) 1453 self.assertEqual(b"abc" < bytes(b"ab"), False) 1454 self.assertEqual(b"abc" <= bytes(b"ab"), False) 1455 1456 self.assertEqual(bytes(b"abc") == b"abc", True) 1457 self.assertEqual(bytes(b"ab") != b"abc", True) 1458 self.assertEqual(bytes(b"ab") <= b"abc", True) 1459 self.assertEqual(bytes(b"ab") < b"abc", True) 1460 self.assertEqual(bytes(b"abc") >= b"ab", True) 1461 self.assertEqual(bytes(b"abc") > b"ab", True) 1462 1463 self.assertEqual(bytes(b"abc") != b"abc", False) 1464 self.assertEqual(bytes(b"ab") == b"abc", False) 1465 self.assertEqual(bytes(b"ab") > b"abc", False) 1466 self.assertEqual(bytes(b"ab") >= b"abc", False) 1467 self.assertEqual(bytes(b"abc") < b"ab", False) 1468 self.assertEqual(bytes(b"abc") <= b"ab", False) 1469 1470 @test.support.requires_docstrings 1471 def test_doc(self): 1472 self.assertIsNotNone(bytearray.__doc__) 1473 self.assertTrue(bytearray.__doc__.startswith("bytearray("), bytearray.__doc__) 1474 self.assertIsNotNone(bytes.__doc__) 1475 self.assertTrue(bytes.__doc__.startswith("bytes("), bytes.__doc__) 1476 1477 def test_from_bytearray(self): 1478 sample = bytes(b"Hello world\n\x80\x81\xfe\xff") 1479 buf = memoryview(sample) 1480 b = bytearray(buf) 1481 self.assertEqual(b, bytearray(sample)) 1482 1483 @check_bytes_warnings 1484 def test_to_str(self): 1485 self.assertEqual(str(b''), "b''") 1486 self.assertEqual(str(b'x'), "b'x'") 1487 self.assertEqual(str(b'\x80'), "b'\\x80'") 1488 self.assertEqual(str(bytearray(b'')), "bytearray(b'')") 1489 self.assertEqual(str(bytearray(b'x')), "bytearray(b'x')") 1490 self.assertEqual(str(bytearray(b'\x80')), "bytearray(b'\\x80')") 1491 1492 def test_literal(self): 1493 tests = [ 1494 (b"Wonderful spam", "Wonderful spam"), 1495 (br"Wonderful spam too", "Wonderful spam too"), 1496 (b"\xaa\x00\000\200", "\xaa\x00\000\200"), 1497 (br"\xaa\x00\000\200", r"\xaa\x00\000\200"), 1498 ] 1499 for b, s in tests: 1500 self.assertEqual(b, bytearray(s, 'latin-1')) 1501 for c in range(128, 256): 1502 self.assertRaises(SyntaxError, eval, 1503 'b"%s"' % chr(c)) 1504 1505 def test_split_bytearray(self): 1506 self.assertEqual(b'a b'.split(memoryview(b' ')), [b'a', b'b']) 1507 1508 def test_rsplit_bytearray(self): 1509 self.assertEqual(b'a b'.rsplit(memoryview(b' ')), [b'a', b'b']) 1510 1511 def test_return_self(self): 1512 # bytearray.replace must always return a new bytearray 1513 b = bytearray() 1514 self.assertFalse(b.replace(b'', b'') is b) 1515 1516 @unittest.skipUnless(sys.flags.bytes_warning, 1517 "BytesWarning is needed for this test: use -bb option") 1518 def test_compare(self): 1519 def bytes_warning(): 1520 return test.support.check_warnings(('', BytesWarning)) 1521 with bytes_warning(): 1522 b'' == '' 1523 with bytes_warning(): 1524 '' == b'' 1525 with bytes_warning(): 1526 b'' != '' 1527 with bytes_warning(): 1528 '' != b'' 1529 with bytes_warning(): 1530 bytearray(b'') == '' 1531 with bytes_warning(): 1532 '' == bytearray(b'') 1533 with bytes_warning(): 1534 bytearray(b'') != '' 1535 with bytes_warning(): 1536 '' != bytearray(b'') 1537 with bytes_warning(): 1538 b'\0' == 0 1539 with bytes_warning(): 1540 0 == b'\0' 1541 with bytes_warning(): 1542 b'\0' != 0 1543 with bytes_warning(): 1544 0 != b'\0' 1545 1546 # Optimizations: 1547 # __iter__? (optimization) 1548 # __reversed__? (optimization) 1549 1550 # XXX More string methods? (Those that don't use character properties) 1551 1552 # There are tests in string_tests.py that are more 1553 # comprehensive for things like partition, etc. 1554 # Unfortunately they are all bundled with tests that 1555 # are not appropriate for bytes 1556 1557 # I've started porting some of those into bytearray_tests.py, we should port 1558 # the rest that make sense (the code can be cleaned up to use modern 1559 # unittest methods at the same time). 1560 1561class BytearrayPEP3137Test(unittest.TestCase): 1562 def marshal(self, x): 1563 return bytearray(x) 1564 1565 def test_returns_new_copy(self): 1566 val = self.marshal(b'1234') 1567 # On immutable types these MAY return a reference to themselves 1568 # but on mutable types like bytearray they MUST return a new copy. 1569 for methname in ('zfill', 'rjust', 'ljust', 'center'): 1570 method = getattr(val, methname) 1571 newval = method(3) 1572 self.assertEqual(val, newval) 1573 self.assertTrue(val is not newval, 1574 methname+' returned self on a mutable object') 1575 for expr in ('val.split()[0]', 'val.rsplit()[0]', 1576 'val.partition(b".")[0]', 'val.rpartition(b".")[2]', 1577 'val.splitlines()[0]', 'val.replace(b"", b"")'): 1578 newval = eval(expr) 1579 self.assertEqual(val, newval) 1580 self.assertTrue(val is not newval, 1581 expr+' returned val on a mutable object') 1582 sep = self.marshal(b'') 1583 newval = sep.join([val]) 1584 self.assertEqual(val, newval) 1585 self.assertIsNot(val, newval) 1586 1587 1588class FixedStringTest(test.string_tests.BaseTest): 1589 def fixtype(self, obj): 1590 if isinstance(obj, str): 1591 return self.type2test(obj.encode("utf-8")) 1592 return super().fixtype(obj) 1593 1594 contains_bytes = True 1595 1596class ByteArrayAsStringTest(FixedStringTest, unittest.TestCase): 1597 type2test = bytearray 1598 1599class BytesAsStringTest(FixedStringTest, unittest.TestCase): 1600 type2test = bytes 1601 1602 1603class SubclassTest: 1604 1605 def test_basic(self): 1606 self.assertTrue(issubclass(self.type2test, self.basetype)) 1607 self.assertIsInstance(self.type2test(), self.basetype) 1608 1609 a, b = b"abcd", b"efgh" 1610 _a, _b = self.type2test(a), self.type2test(b) 1611 1612 # test comparison operators with subclass instances 1613 self.assertTrue(_a == _a) 1614 self.assertTrue(_a != _b) 1615 self.assertTrue(_a < _b) 1616 self.assertTrue(_a <= _b) 1617 self.assertTrue(_b >= _a) 1618 self.assertTrue(_b > _a) 1619 self.assertTrue(_a is not a) 1620 1621 # test concat of subclass instances 1622 self.assertEqual(a + b, _a + _b) 1623 self.assertEqual(a + b, a + _b) 1624 self.assertEqual(a + b, _a + b) 1625 1626 # test repeat 1627 self.assertTrue(a*5 == _a*5) 1628 1629 def test_join(self): 1630 # Make sure join returns a NEW object for single item sequences 1631 # involving a subclass. 1632 # Make sure that it is of the appropriate type. 1633 s1 = self.type2test(b"abcd") 1634 s2 = self.basetype().join([s1]) 1635 self.assertTrue(s1 is not s2) 1636 self.assertTrue(type(s2) is self.basetype, type(s2)) 1637 1638 # Test reverse, calling join on subclass 1639 s3 = s1.join([b"abcd"]) 1640 self.assertTrue(type(s3) is self.basetype) 1641 1642 def test_pickle(self): 1643 a = self.type2test(b"abcd") 1644 a.x = 10 1645 a.y = self.type2test(b"efgh") 1646 for proto in range(pickle.HIGHEST_PROTOCOL + 1): 1647 b = pickle.loads(pickle.dumps(a, proto)) 1648 self.assertNotEqual(id(a), id(b)) 1649 self.assertEqual(a, b) 1650 self.assertEqual(a.x, b.x) 1651 self.assertEqual(a.y, b.y) 1652 self.assertEqual(type(a), type(b)) 1653 self.assertEqual(type(a.y), type(b.y)) 1654 1655 def test_copy(self): 1656 a = self.type2test(b"abcd") 1657 a.x = 10 1658 a.y = self.type2test(b"efgh") 1659 for copy_method in (copy.copy, copy.deepcopy): 1660 b = copy_method(a) 1661 self.assertNotEqual(id(a), id(b)) 1662 self.assertEqual(a, b) 1663 self.assertEqual(a.x, b.x) 1664 self.assertEqual(a.y, b.y) 1665 self.assertEqual(type(a), type(b)) 1666 self.assertEqual(type(a.y), type(b.y)) 1667 1668 def test_fromhex(self): 1669 b = self.type2test.fromhex('1a2B30') 1670 self.assertEqual(b, b'\x1a\x2b\x30') 1671 self.assertIs(type(b), self.type2test) 1672 1673 class B1(self.basetype): 1674 def __new__(cls, value): 1675 me = self.basetype.__new__(cls, value) 1676 me.foo = 'bar' 1677 return me 1678 1679 b = B1.fromhex('1a2B30') 1680 self.assertEqual(b, b'\x1a\x2b\x30') 1681 self.assertIs(type(b), B1) 1682 self.assertEqual(b.foo, 'bar') 1683 1684 class B2(self.basetype): 1685 def __init__(me, *args, **kwargs): 1686 if self.basetype is not bytes: 1687 self.basetype.__init__(me, *args, **kwargs) 1688 me.foo = 'bar' 1689 1690 b = B2.fromhex('1a2B30') 1691 self.assertEqual(b, b'\x1a\x2b\x30') 1692 self.assertIs(type(b), B2) 1693 self.assertEqual(b.foo, 'bar') 1694 1695 1696class ByteArraySubclass(bytearray): 1697 pass 1698 1699class BytesSubclass(bytes): 1700 pass 1701 1702class OtherBytesSubclass(bytes): 1703 pass 1704 1705class ByteArraySubclassTest(SubclassTest, unittest.TestCase): 1706 basetype = bytearray 1707 type2test = ByteArraySubclass 1708 1709 def test_init_override(self): 1710 class subclass(bytearray): 1711 def __init__(me, newarg=1, *args, **kwargs): 1712 bytearray.__init__(me, *args, **kwargs) 1713 x = subclass(4, b"abcd") 1714 x = subclass(4, source=b"abcd") 1715 self.assertEqual(x, b"abcd") 1716 x = subclass(newarg=4, source=b"abcd") 1717 self.assertEqual(x, b"abcd") 1718 1719 1720class BytesSubclassTest(SubclassTest, unittest.TestCase): 1721 basetype = bytes 1722 type2test = BytesSubclass 1723 1724 1725if __name__ == "__main__": 1726 unittest.main() 1727