Lines Matching refs:self
41 def __init__(self, value=0):
42 self.value = value
43 def __index__(self):
44 return self.value
49 def test_basics(self):
50 b = self.type2test()
51 self.assertEqual(type(b), self.type2test)
52 self.assertEqual(b.__class__, self.type2test)
54 def test_copy(self):
55 a = self.type2test(b"abcd")
58 self.assertEqual(a, b)
59 self.assertEqual(type(a), type(b))
61 def test_empty_sequence(self):
62 b = self.type2test()
63 self.assertEqual(len(b), 0)
64 self.assertRaises(IndexError, lambda: b[0])
65 self.assertRaises(IndexError, lambda: b[1])
66 self.assertRaises(IndexError, lambda: b[sys.maxsize])
67 self.assertRaises(IndexError, lambda: b[sys.maxsize+1])
68 self.assertRaises(IndexError, lambda: b[10**100])
69 self.assertRaises(IndexError, lambda: b[-1])
70 self.assertRaises(IndexError, lambda: b[-2])
71 self.assertRaises(IndexError, lambda: b[-sys.maxsize])
72 self.assertRaises(IndexError, lambda: b[-sys.maxsize-1])
73 self.assertRaises(IndexError, lambda: b[-sys.maxsize-2])
74 self.assertRaises(IndexError, lambda: b[-10**100])
76 def test_from_iterable(self):
77 b = self.type2test(range(256))
78 self.assertEqual(len(b), 256)
79 self.assertEqual(list(b), list(range(256)))
82 b = self.type2test({42})
83 self.assertEqual(b, b"*")
84 b = self.type2test({43, 45})
85 self.assertIn(tuple(b), {(43, 45), (45, 43)})
88 b = self.type2test(iter(range(256)))
89 self.assertEqual(len(b), 256)
90 self.assertEqual(list(b), list(range(256)))
93 b = self.type2test(i for i in range(256) if i % 2)
94 self.assertEqual(len(b), 128)
95 self.assertEqual(list(b), list(range(256))[1::2])
99 def __getitem__(self, i):
101 b = self.type2test(S())
102 self.assertEqual(b, b"\x01\x02\x03")
104 def test_from_tuple(self):
106 b = self.type2test(tuple(range(256)))
107 self.assertEqual(len(b), 256)
108 self.assertEqual(list(b), list(range(256)))
109 b = self.type2test((1, 2, 3))
110 self.assertEqual(b, b"\x01\x02\x03")
112 def test_from_list(self):
114 b = self.type2test(list(range(256)))
115 self.assertEqual(len(b), 256)
116 self.assertEqual(list(b), list(range(256)))
117 b = self.type2test([1, 2, 3])
118 self.assertEqual(b, b"\x01\x02\x03")
120 def test_from_mutating_list(self):
123 def __index__(self):
127 self.assertEqual(bytes(a), b'*')
130 def __index__(self):
132 a.append(self)
135 self.assertEqual(bytes(a), b'*' * 1000) # should not crash
137 def test_from_index(self):
138 b = self.type2test([Indexable(), Indexable(1), Indexable(254),
140 self.assertEqual(list(b), [0, 1, 254, 255])
141 self.assertRaises(ValueError, self.type2test, [Indexable(-1)])
142 self.assertRaises(ValueError, self.type2test, [Indexable(256)])
144 def test_from_buffer(self):
145 a = self.type2test(array.array('B', [1, 2, 3]))
146 self.assertEqual(a, b"\x01\x02\x03")
147 a = self.type2test(b"\x01\x02\x03")
148 self.assertEqual(a, b"\x01\x02\x03")
153 def __index__(self):
156 self.assertEqual(self.type2test(B(b"foobar")), b"foobar")
158 def test_from_ssize(self):
159 self.assertEqual(self.type2test(0), b'')
160 self.assertEqual(self.type2test(1), b'\x00')
161 self.assertEqual(self.type2test(5), b'\x00\x00\x00\x00\x00')
162 self.assertRaises(ValueError, self.type2test, -1)
164 self.assertEqual(self.type2test('0', 'ascii'), b'0')
165 self.assertEqual(self.type2test(b'0'), b'0')
166 self.assertRaises(OverflowError, self.type2test, sys.maxsize + 1)
168 def test_constructor_type_errors(self):
169 self.assertRaises(TypeError, self.type2test, 0.0)
172 self.assertRaises(TypeError, self.type2test, ["0"])
173 self.assertRaises(TypeError, self.type2test, [0.0])
174 self.assertRaises(TypeError, self.type2test, [None])
175 self.assertRaises(TypeError, self.type2test, [C()])
176 self.assertRaises(TypeError, self.type2test, encoding='ascii')
177 self.assertRaises(TypeError, self.type2test, errors='ignore')
178 self.assertRaises(TypeError, self.type2test, 0, 'ascii')
179 self.assertRaises(TypeError, self.type2test, b'', 'ascii')
180 self.assertRaises(TypeError, self.type2test, 0, errors='ignore')
181 self.assertRaises(TypeError, self.type2test, b'', errors='ignore')
182 self.assertRaises(TypeError, self.type2test, '')
183 self.assertRaises(TypeError, self.type2test, '', errors='ignore')
184 self.assertRaises(TypeError, self.type2test, '', b'ascii')
185 self.assertRaises(TypeError, self.type2test, '', 'ascii', b'ignore')
187 def test_constructor_value_errors(self):
188 self.assertRaises(ValueError, self.type2test, [-1])
189 self.assertRaises(ValueError, self.type2test, [-sys.maxsize])
190 self.assertRaises(ValueError, self.type2test, [-sys.maxsize-1])
191 self.assertRaises(ValueError, self.type2test, [-sys.maxsize-2])
192 self.assertRaises(ValueError, self.type2test, [-10**100])
193 self.assertRaises(ValueError, self.type2test, [256])
194 self.assertRaises(ValueError, self.type2test, [257])
195 self.assertRaises(ValueError, self.type2test, [sys.maxsize])
196 self.assertRaises(ValueError, self.type2test, [sys.maxsize+1])
197 self.assertRaises(ValueError, self.type2test, [10**100])
200 def test_constructor_overflow(self):
202 self.assertRaises((OverflowError, MemoryError), self.type2test, size)
210 def test_constructor_exceptions(self):
214 def __index__(self):
216 self.assertRaises(ZeroDivisionError, self.type2test, BadInt())
217 self.assertRaises(ZeroDivisionError, self.type2test, [BadInt()])
220 def __iter__(self):
222 self.assertRaises(ZeroDivisionError, self.type2test, BadIterable())
224 def test_compare(self):
225 b1 = self.type2test([1, 2, 3])
226 b2 = self.type2test([1, 2, 3])
227 b3 = self.type2test([1, 3])
229 self.assertEqual(b1, b2)
230 self.assertTrue(b2 != b3)
231 self.assertTrue(b1 <= b2)
232 self.assertTrue(b1 <= b3)
233 self.assertTrue(b1 < b3)
234 self.assertTrue(b1 >= b2)
235 self.assertTrue(b3 >= b2)
236 self.assertTrue(b3 > b2)
238 self.assertFalse(b1 != b2)
239 self.assertFalse(b2 == b3)
240 self.assertFalse(b1 > b2)
241 self.assertFalse(b1 > b3)
242 self.assertFalse(b1 >= b3)
243 self.assertFalse(b1 < b2)
244 self.assertFalse(b3 < b2)
245 self.assertFalse(b3 <= b2)
248 def test_compare_to_str(self):
252 self.assertEqual(self.type2test(b"\0a\0b\0c") == "abc", False)
253 self.assertEqual(self.type2test(b"\0\0\0a\0\0\0b\0\0\0c") == "abc",
255 self.assertEqual(self.type2test(b"a\0b\0c\0") == "abc", False)
256 self.assertEqual(self.type2test(b"a\0\0\0b\0\0\0c\0\0\0") == "abc",
258 self.assertEqual(self.type2test() == str(), False)
259 self.assertEqual(self.type2test() != str(), True)
261 def test_reversed(self):
263 b = self.type2test(input)
266 self.assertEqual(output, input)
268 def test_getslice(self):
270 return self.type2test(map(ord, s))
273 self.assertEqual(b[:5], by("Hello"))
274 self.assertEqual(b[1:5], by("ello"))
275 self.assertEqual(b[5:7], by(", "))
276 self.assertEqual(b[7:], by("world"))
277 self.assertEqual(b[7:12], by("world"))
278 self.assertEqual(b[7:100], by("world"))
280 self.assertEqual(b[:-7], by("Hello"))
281 self.assertEqual(b[-11:-7], by("ello"))
282 self.assertEqual(b[-7:-5], by(", "))
283 self.assertEqual(b[-5:], by("world"))
284 self.assertEqual(b[-5:12], by("world"))
285 self.assertEqual(b[-5:100], by("world"))
286 self.assertEqual(b[-100:5], by("Hello"))
288 def test_extended_getslice(self):
291 b = self.type2test(L)
297 self.assertEqual(b[start:stop:step], self.type2test(L[start:stop:step]))
299 def test_encoding(self):
302 b = self.type2test(sample, enc)
303 self.assertEqual(b, self.type2test(sample.encode(enc)))
304 self.assertRaises(UnicodeEncodeError, self.type2test, sample, "latin-1")
305 b = self.type2test(sample, "latin-1", "ignore")
306 self.assertEqual(b, self.type2test(sample[:-3], "utf-8"))
308 def test_decode(self):
311 b = self.type2test(sample, enc)
312 self.assertEqual(b.decode(enc), sample)
314 b = self.type2test(sample, "latin-1")
315 self.assertRaises(UnicodeDecodeError, b.decode, "utf-8")
316 self.assertEqual(b.decode("utf-8", "ignore"), "Hello world\n")
317 self.assertEqual(b.decode(errors="ignore", encoding="utf-8"),
320 self.assertEqual(self.type2test(b'\xe2\x98\x83').decode(), '\u2603')
322 def test_check_encoding_errors(self):
329 type2test = {self.type2test.__name__}
376 self.assertEqual(proc.rc, 10, proc)
378 def test_from_int(self):
379 b = self.type2test(0)
380 self.assertEqual(b, self.type2test())
381 b = self.type2test(10)
382 self.assertEqual(b, self.type2test([0]*10))
383 b = self.type2test(10000)
384 self.assertEqual(b, self.type2test([0]*10000))
386 def test_concat(self):
387 b1 = self.type2test(b"abc")
388 b2 = self.type2test(b"def")
389 self.assertEqual(b1 + b2, b"abcdef")
390 self.assertEqual(b1 + bytes(b"def"), b"abcdef")
391 self.assertEqual(bytes(b"def") + b1, b"defabc")
392 self.assertRaises(TypeError, lambda: b1 + "def")
393 self.assertRaises(TypeError, lambda: "abc" + b2)
395 def test_repeat(self):
396 for b in b"abc", self.type2test(b"abc"):
397 self.assertEqual(b * 3, b"abcabcabc")
398 self.assertEqual(b * 0, b"")
399 self.assertEqual(b * -1, b"")
400 self.assertRaises(TypeError, lambda: b * 3.14)
401 self.assertRaises(TypeError, lambda: 3.14 * b)
403 with self.assertRaises((OverflowError, MemoryError)):
405 with self.assertRaises((OverflowError, MemoryError)):
408 def test_repeat_1char(self):
409 self.assertEqual(self.type2test(b'x')*100, self.type2test([ord('x')]*100))
411 def test_contains(self):
412 b = self.type2test(b"abc")
413 self.assertIn(ord('a'), b)
414 self.assertIn(int(ord('a')), b)
415 self.assertNotIn(200, b)
416 self.assertRaises(ValueError, lambda: 300 in b)
417 self.assertRaises(ValueError, lambda: -1 in b)
418 self.assertRaises(ValueError, lambda: sys.maxsize+1 in b)
419 self.assertRaises(TypeError, lambda: None in b)
420 self.assertRaises(TypeError, lambda: float(ord('a')) in b)
421 self.assertRaises(TypeError, lambda: "a" in b)
423 self.assertIn(f(b""), b)
424 self.assertIn(f(b"a"), b)
425 self.assertIn(f(b"b"), b)
426 self.assertIn(f(b"c"), b)
427 self.assertIn(f(b"ab"), b)
428 self.assertIn(f(b"bc"), b)
429 self.assertIn(f(b"abc"), b)
430 self.assertNotIn(f(b"ac"), b)
431 self.assertNotIn(f(b"d"), b)
432 self.assertNotIn(f(b"dab"), b)
433 self.assertNotIn(f(b"abd"), b)
435 def test_fromhex(self):
436 self.assertRaises(TypeError, self.type2test.fromhex)
437 self.assertRaises(TypeError, self.type2test.fromhex, 1)
438 self.assertEqual(self.type2test.fromhex(''), self.type2test())
440 self.assertEqual(self.type2test.fromhex('1a2B30'), b)
441 self.assertEqual(self.type2test.fromhex(' 1A 2B 30 '), b)
444 self.assertEqual(self.type2test.fromhex(' 1A\n2B\t30\v'), b)
446 self.assertEqual(self.type2test.fromhex(c), self.type2test())
448 self.assertRaises(ValueError, self.type2test.fromhex, c)
450 self.assertEqual(self.type2test.fromhex('0000'), b'\0\0')
451 self.assertRaises(TypeError, self.type2test.fromhex, b'1B')
452 self.assertRaises(ValueError, self.type2test.fromhex, 'a')
453 self.assertRaises(ValueError, self.type2test.fromhex, 'rt')
454 self.assertRaises(ValueError, self.type2test.fromhex, '1a b cd')
455 self.assertRaises(ValueError, self.type2test.fromhex, '\x00')
456 self.assertRaises(ValueError, self.type2test.fromhex, '12 \x00 34')
468 with self.assertRaises(ValueError) as cm:
469 self.type2test.fromhex(data)
470 self.assertIn('at position %s' % pos, str(cm.exception))
472 def test_hex(self):
473 self.assertRaises(TypeError, self.type2test.hex)
474 self.assertRaises(TypeError, self.type2test.hex, 1)
475 self.assertEqual(self.type2test(b"").hex(), "")
476 self.assertEqual(bytearray([0x1a, 0x2b, 0x30]).hex(), '1a2b30')
477 self.assertEqual(self.type2test(b"\x1a\x2b\x30").hex(), '1a2b30')
478 self.assertEqual(memoryview(b"\x1a\x2b\x30").hex(), '1a2b30')
480 def test_hex_separator_basics(self):
481 three_bytes = self.type2test(b'\xb9\x01\xef')
482 self.assertEqual(three_bytes.hex(), 'b901ef')
483 with self.assertRaises(ValueError):
485 with self.assertRaises(ValueError):
487 self.assertEqual(three_bytes.hex(':', 0), 'b901ef')
488 with self.assertRaises(TypeError):
490 with self.assertRaises(ValueError):
492 with self.assertRaises(ValueError):
494 with self.assertRaises(ValueError):
496 with self.assertRaises(ValueError):
498 self.assertEqual(three_bytes.hex(':', 0), 'b901ef')
499 self.assertEqual(three_bytes.hex(b'\x00'), 'b9\x0001\x00ef')
500 self.assertEqual(three_bytes.hex('\x00'), 'b9\x0001\x00ef')
501 self.assertEqual(three_bytes.hex(b'\x7f'), 'b9\x7f01\x7fef')
502 self.assertEqual(three_bytes.hex('\x7f'), 'b9\x7f01\x7fef')
503 self.assertEqual(three_bytes.hex(':', 3), 'b901ef')
504 self.assertEqual(three_bytes.hex(':', 4), 'b901ef')
505 self.assertEqual(three_bytes.hex(':', -4), 'b901ef')
506 self.assertEqual(three_bytes.hex(':'), 'b9:01:ef')
507 self.assertEqual(three_bytes.hex(b'$'), 'b9$01$ef')
508 self.assertEqual(three_bytes.hex(':', 1), 'b9:01:ef')
509 self.assertEqual(three_bytes.hex(':', -1), 'b9:01:ef')
510 self.assertEqual(three_bytes.hex(':', 2), 'b9:01ef')
511 self.assertEqual(three_bytes.hex(':', 1), 'b9:01:ef')
512 self.assertEqual(three_bytes.hex('*', -2), 'b901*ef')
515 self.assertEqual(value.hex('.', 8), '7b7305000000776f.726c646902000000.730500000068656c.6c6f690100000030')
517 def test_hex_separator_five_bytes(self):
518 five_bytes = self.type2test(range(90,95))
519 self.assertEqual(five_bytes.hex(), '5a5b5c5d5e')
521 def test_hex_separator_six_bytes(self):
522 six_bytes = self.type2test(x*3 for x in range(1, 7))
523 self.assertEqual(six_bytes.hex(), '0306090c0f12')
524 self.assertEqual(six_bytes.hex('.', 1), '03.06.09.0c.0f.12')
525 self.assertEqual(six_bytes.hex(' ', 2), '0306 090c 0f12')
526 self.assertEqual(six_bytes.hex('-', 3), '030609-0c0f12')
527 self.assertEqual(six_bytes.hex(':', 4), '0306:090c0f12')
528 self.assertEqual(six_bytes.hex(':', 5), '03:06090c0f12')
529 self.assertEqual(six_bytes.hex(':', 6), '0306090c0f12')
530 self.assertEqual(six_bytes.hex(':', 95), '0306090c0f12')
531 self.assertEqual(six_bytes.hex('_', -3), '030609_0c0f12')
532 self.assertEqual(six_bytes.hex(':', -4), '0306090c:0f12')
533 self.assertEqual(six_bytes.hex(b'@', -5), '0306090c0f@12')
534 self.assertEqual(six_bytes.hex(':', -6), '0306090c0f12')
535 self.assertEqual(six_bytes.hex(' ', -95), '0306090c0f12')
537 def test_join(self):
538 self.assertEqual(self.type2test(b"").join([]), b"")
539 self.assertEqual(self.type2test(b"").join([b""]), b"")
541 lst = list(map(self.type2test, lst))
542 self.assertEqual(self.type2test(b"").join(lst), b"abc")
543 self.assertEqual(self.type2test(b"").join(tuple(lst)), b"abc")
544 self.assertEqual(self.type2test(b"").join(iter(lst)), b"abc")
545 dot_join = self.type2test(b".:").join
546 self.assertEqual(dot_join([b"ab", b"cd"]), b"ab.:cd")
547 self.assertEqual(dot_join([memoryview(b"ab"), b"cd"]), b"ab.:cd")
548 self.assertEqual(dot_join([b"ab", memoryview(b"cd")]), b"ab.:cd")
549 self.assertEqual(dot_join([bytearray(b"ab"), b"cd"]), b"ab.:cd")
550 self.assertEqual(dot_join([b"ab", bytearray(b"cd")]), b"ab.:cd")
554 self.assertEqual(dot_join(seq), expected)
558 self.assertEqual(self.type2test(b"").join(seq), expected)
559 self.assertRaises(TypeError, self.type2test(b" ").join, None)
562 with self.assertRaises(TypeError):
564 with self.assertRaises(TypeError):
567 def test_count(self):
568 b = self.type2test(b'mississippi')
573 self.assertEqual(b.count(b'i'), 4)
574 self.assertEqual(b.count(b'ss'), 2)
575 self.assertEqual(b.count(b'w'), 0)
577 self.assertEqual(b.count(i), 4)
578 self.assertEqual(b.count(w), 0)
580 self.assertEqual(b.count(b'i', 6), 2)
581 self.assertEqual(b.count(b'p', 6), 2)
582 self.assertEqual(b.count(b'i', 1, 3), 1)
583 self.assertEqual(b.count(b'p', 7, 9), 1)
585 self.assertEqual(b.count(i, 6), 2)
586 self.assertEqual(b.count(p, 6), 2)
587 self.assertEqual(b.count(i, 1, 3), 1)
588 self.assertEqual(b.count(p, 7, 9), 1)
590 def test_startswith(self):
591 b = self.type2test(b'hello')
592 self.assertFalse(self.type2test().startswith(b"anything"))
593 self.assertTrue(b.startswith(b"hello"))
594 self.assertTrue(b.startswith(b"hel"))
595 self.assertTrue(b.startswith(b"h"))
596 self.assertFalse(b.startswith(b"hellow"))
597 self.assertFalse(b.startswith(b"ha"))
598 with self.assertRaises(TypeError) as cm:
601 self.assertIn('bytes', exc)
602 self.assertIn('tuple', exc)
604 def test_endswith(self):
605 b = self.type2test(b'hello')
606 self.assertFalse(bytearray().endswith(b"anything"))
607 self.assertTrue(b.endswith(b"hello"))
608 self.assertTrue(b.endswith(b"llo"))
609 self.assertTrue(b.endswith(b"o"))
610 self.assertFalse(b.endswith(b"whello"))
611 self.assertFalse(b.endswith(b"no"))
612 with self.assertRaises(TypeError) as cm:
615 self.assertIn('bytes', exc)
616 self.assertIn('tuple', exc)
618 def test_find(self):
619 b = self.type2test(b'mississippi')
623 self.assertEqual(b.find(b'ss'), 2)
624 self.assertEqual(b.find(b'w'), -1)
625 self.assertEqual(b.find(b'mississippian'), -1)
627 self.assertEqual(b.find(i), 1)
628 self.assertEqual(b.find(w), -1)
630 self.assertEqual(b.find(b'ss', 3), 5)
631 self.assertEqual(b.find(b'ss', 1, 7), 2)
632 self.assertEqual(b.find(b'ss', 1, 3), -1)
634 self.assertEqual(b.find(i, 6), 7)
635 self.assertEqual(b.find(i, 1, 3), 1)
636 self.assertEqual(b.find(w, 1, 3), -1)
639 self.assertRaisesRegex(
643 def test_rfind(self):
644 b = self.type2test(b'mississippi')
648 self.assertEqual(b.rfind(b'ss'), 5)
649 self.assertEqual(b.rfind(b'w'), -1)
650 self.assertEqual(b.rfind(b'mississippian'), -1)
652 self.assertEqual(b.rfind(i), 10)
653 self.assertEqual(b.rfind(w), -1)
655 self.assertEqual(b.rfind(b'ss', 3), 5)
656 self.assertEqual(b.rfind(b'ss', 0, 6), 2)
658 self.assertEqual(b.rfind(i, 1, 3), 1)
659 self.assertEqual(b.rfind(i, 3, 9), 7)
660 self.assertEqual(b.rfind(w, 1, 3), -1)
662 def test_index(self):
663 b = self.type2test(b'mississippi')
667 self.assertEqual(b.index(b'ss'), 2)
668 self.assertRaises(ValueError, b.index, b'w')
669 self.assertRaises(ValueError, b.index, b'mississippian')
671 self.assertEqual(b.index(i), 1)
672 self.assertRaises(ValueError, b.index, w)
674 self.assertEqual(b.index(b'ss', 3), 5)
675 self.assertEqual(b.index(b'ss', 1, 7), 2)
676 self.assertRaises(ValueError, b.index, b'ss', 1, 3)
678 self.assertEqual(b.index(i, 6), 7)
679 self.assertEqual(b.index(i, 1, 3), 1)
680 self.assertRaises(ValueError, b.index, w, 1, 3)
682 def test_rindex(self):
683 b = self.type2test(b'mississippi')
687 self.assertEqual(b.rindex(b'ss'), 5)
688 self.assertRaises(ValueError, b.rindex, b'w')
689 self.assertRaises(ValueError, b.rindex, b'mississippian')
691 self.assertEqual(b.rindex(i), 10)
692 self.assertRaises(ValueError, b.rindex, w)
694 self.assertEqual(b.rindex(b'ss', 3), 5)
695 self.assertEqual(b.rindex(b'ss', 0, 6), 2)
697 self.assertEqual(b.rindex(i, 1, 3), 1)
698 self.assertEqual(b.rindex(i, 3, 9), 7)
699 self.assertRaises(ValueError, b.rindex, w, 1, 3)
701 def test_mod(self):
702 b = self.type2test(b'hello, %b!')
705 self.assertEqual(b, b'hello, world!')
706 self.assertEqual(orig, b'hello, %b!')
707 self.assertFalse(b is orig)
708 b = self.type2test(b'%s / 100 = %d%%')
710 self.assertEqual(a, b'seventy-nine / 100 = 79%')
711 self.assertIs(type(a), self.type2test)
713 b = self.type2test(b'hello,\x00%b!')
715 self.assertEqual(b, b'hello,\x00world!')
716 self.assertIs(type(b), self.type2test)
719 b = self.type2test(fmt)
721 self.assertEqual(b, result)
722 self.assertIs(type(b), self.type2test)
736 def test_imod(self):
737 b = self.type2test(b'hello, %b!')
740 self.assertEqual(b, b'hello, world!')
741 self.assertEqual(orig, b'hello, %b!')
742 self.assertFalse(b is orig)
743 b = self.type2test(b'%s / 100 = %d%%')
745 self.assertEqual(b, b'seventy-nine / 100 = 79%')
746 self.assertIs(type(b), self.type2test)
748 b = self.type2test(b'hello,\x00%b!')
750 self.assertEqual(b, b'hello,\x00world!')
751 self.assertIs(type(b), self.type2test)
753 def test_rmod(self):
754 with self.assertRaises(TypeError):
755 object() % self.type2test(b'abc')
756 self.assertIs(self.type2test(b'abc').__rmod__('%r'), NotImplemented)
758 def test_replace(self):
759 b = self.type2test(b'mississippi')
760 self.assertEqual(b.replace(b'i', b'a'), b'massassappa')
761 self.assertEqual(b.replace(b'ss', b'x'), b'mixixippi')
763 def test_replace_int_error(self):
764 self.assertRaises(TypeError, self.type2test(b'a b').replace, 32, b'')
766 def test_split_string_error(self):
767 self.assertRaises(TypeError, self.type2test(b'a b').split, ' ')
768 self.assertRaises(TypeError, self.type2test(b'a b').rsplit, ' ')
770 def test_split_int_error(self):
771 self.assertRaises(TypeError, self.type2test(b'a b').split, 32)
772 self.assertRaises(TypeError, self.type2test(b'a b').rsplit, 32)
774 def test_split_unicodewhitespace(self):
776 b = self.type2test(b)
777 self.assertEqual(b.split(), [b])
778 b = self.type2test(b"\x09\x0A\x0B\x0C\x0D\x1C\x1D\x1E\x1F")
779 self.assertEqual(b.split(), [b'\x1c\x1d\x1e\x1f'])
781 def test_rsplit_unicodewhitespace(self):
782 b = self.type2test(b"\x09\x0A\x0B\x0C\x0D\x1C\x1D\x1E\x1F")
783 self.assertEqual(b.rsplit(), [b'\x1c\x1d\x1e\x1f'])
785 def test_partition(self):
786 b = self.type2test(b'mississippi')
787 self.assertEqual(b.partition(b'ss'), (b'mi', b'ss', b'issippi'))
788 self.assertEqual(b.partition(b'w'), (b'mississippi', b'', b''))
790 def test_rpartition(self):
791 b = self.type2test(b'mississippi')
792 self.assertEqual(b.rpartition(b'ss'), (b'missi', b'ss', b'ippi'))
793 self.assertEqual(b.rpartition(b'i'), (b'mississipp', b'i', b''))
794 self.assertEqual(b.rpartition(b'w'), (b'', b'', b'mississippi'))
796 def test_partition_string_error(self):
797 self.assertRaises(TypeError, self.type2test(b'a b').partition, ' ')
798 self.assertRaises(TypeError, self.type2test(b'a b').rpartition, ' ')
800 def test_partition_int_error(self):
801 self.assertRaises(TypeError, self.type2test(b'a b').partition, 32)
802 self.assertRaises(TypeError, self.type2test(b'a b').rpartition, 32)
804 def test_pickling(self):
807 b = self.type2test(b)
810 self.assertEqual(b, q)
812 def test_iterator_pickling(self):
815 it = itorg = iter(self.type2test(b))
816 data = list(self.type2test(b))
819 self.assertEqual(type(itorg), type(it))
820 self.assertEqual(list(it), data)
828 self.assertEqual(list(it), data[1:])
830 def test_strip_bytearray(self):
831 self.assertEqual(self.type2test(b'abc').strip(memoryview(b'ac')), b'b')
832 self.assertEqual(self.type2test(b'abc').lstrip(memoryview(b'ac')), b'bc')
833 self.assertEqual(self.type2test(b'abc').rstrip(memoryview(b'ac')), b'ab')
835 def test_strip_string_error(self):
836 self.assertRaises(TypeError, self.type2test(b'abc').strip, 'ac')
837 self.assertRaises(TypeError, self.type2test(b'abc').lstrip, 'ac')
838 self.assertRaises(TypeError, self.type2test(b'abc').rstrip, 'ac')
840 def test_strip_int_error(self):
841 self.assertRaises(TypeError, self.type2test(b' abc ').strip, 32)
842 self.assertRaises(TypeError, self.type2test(b' abc ').lstrip, 32)
843 self.assertRaises(TypeError, self.type2test(b' abc ').rstrip, 32)
845 def test_center(self):
847 b = self.type2test(b'abc')
849 self.assertEqual(b.center(7, fill_type(b'-')),
850 self.type2test(b'--abc--'))
852 def test_ljust(self):
854 b = self.type2test(b'abc')
856 self.assertEqual(b.ljust(7, fill_type(b'-')),
857 self.type2test(b'abc----'))
859 def test_rjust(self):
861 b = self.type2test(b'abc')
863 self.assertEqual(b.rjust(7, fill_type(b'-')),
864 self.type2test(b'----abc'))
866 def test_xjust_int_error(self):
867 self.assertRaises(TypeError, self.type2test(b'abc').center, 7, 32)
868 self.assertRaises(TypeError, self.type2test(b'abc').ljust, 7, 32)
869 self.assertRaises(TypeError, self.type2test(b'abc').rjust, 7, 32)
871 def test_ord(self):
872 b = self.type2test(b'\0A\x7f\x80\xff')
873 self.assertEqual([ord(b[i:i+1]) for i in range(len(b))],
876 def test_maketrans(self):
878 self.assertEqual(self.type2test.maketrans(b'abc', b'xyz'), transtable)
880 self.assertEqual(self.type2test.maketrans(b'\375\376\377', b'xyz'), transtable)
881 self.assertRaises(ValueError, self.type2test.maketrans, b'abc', b'xyzq')
882 self.assertRaises(TypeError, self.type2test.maketrans, 'abc', 'def')
884 def test_none_arguments(self):
886 b = self.type2test(b'hello')
887 l = self.type2test(b'l')
888 h = self.type2test(b'h')
889 x = self.type2test(b'x')
890 o = self.type2test(b'o')
892 self.assertEqual(2, b.find(l, None))
893 self.assertEqual(3, b.find(l, -2, None))
894 self.assertEqual(2, b.find(l, None, -2))
895 self.assertEqual(0, b.find(h, None, None))
897 self.assertEqual(3, b.rfind(l, None))
898 self.assertEqual(3, b.rfind(l, -2, None))
899 self.assertEqual(2, b.rfind(l, None, -2))
900 self.assertEqual(0, b.rfind(h, None, None))
902 self.assertEqual(2, b.index(l, None))
903 self.assertEqual(3, b.index(l, -2, None))
904 self.assertEqual(2, b.index(l, None, -2))
905 self.assertEqual(0, b.index(h, None, None))
907 self.assertEqual(3, b.rindex(l, None))
908 self.assertEqual(3, b.rindex(l, -2, None))
909 self.assertEqual(2, b.rindex(l, None, -2))
910 self.assertEqual(0, b.rindex(h, None, None))
912 self.assertEqual(2, b.count(l, None))
913 self.assertEqual(1, b.count(l, -2, None))
914 self.assertEqual(1, b.count(l, None, -2))
915 self.assertEqual(0, b.count(x, None, None))
917 self.assertEqual(True, b.endswith(o, None))
918 self.assertEqual(True, b.endswith(o, -2, None))
919 self.assertEqual(True, b.endswith(l, None, -2))
920 self.assertEqual(False, b.endswith(x, None, None))
922 self.assertEqual(True, b.startswith(h, None))
923 self.assertEqual(True, b.startswith(l, -2, None))
924 self.assertEqual(True, b.startswith(h, None, -2))
925 self.assertEqual(False, b.startswith(x, None, None))
927 def test_integer_arguments_out_of_byte_range(self):
928 b = self.type2test(b'hello')
931 self.assertRaises(ValueError, method, -1)
932 self.assertRaises(ValueError, method, 256)
933 self.assertRaises(ValueError, method, 9999)
935 def test_find_etc_raise_correct_error_messages(self):
937 b = self.type2test(b'hello')
938 x = self.type2test(b'x')
939 self.assertRaisesRegex(TypeError, r'\bfind\b', b.find,
941 self.assertRaisesRegex(TypeError, r'\brfind\b', b.rfind,
943 self.assertRaisesRegex(TypeError, r'\bindex\b', b.index,
945 self.assertRaisesRegex(TypeError, r'\brindex\b', b.rindex,
947 self.assertRaisesRegex(TypeError, r'\bcount\b', b.count,
949 self.assertRaisesRegex(TypeError, r'\bstartswith\b', b.startswith,
951 self.assertRaisesRegex(TypeError, r'\bendswith\b', b.endswith,
954 def test_free_after_iterating(self):
955 test.support.check_free_after_iterating(self, iter, self.type2test)
956 test.support.check_free_after_iterating(self, reversed, self.type2test)
958 def test_translate(self):
959 b = self.type2test(b'hello')
963 self.assertRaises(TypeError, b.translate)
964 self.assertRaises(TypeError, b.translate, None, None)
965 self.assertRaises(ValueError, b.translate, bytes(range(255)))
968 self.assertEqual(b, b'hello')
969 self.assertIsInstance(c, self.type2test)
973 self.assertEqual(c, d)
974 self.assertEqual(c, b'helle')
977 self.assertEqual(c, b'hee')
979 self.assertEqual(c, b'hllo')
983 self.assertEqual(c, b'helle')
985 self.assertEqual(c, b'hee')
987 self.assertEqual(c, b'hllo')
989 def test_sq_item(self):
991 obj = self.type2test((42,))
992 with self.assertRaises(IndexError):
994 with self.assertRaises(IndexError):
996 self.assertEqual(_testcapi.sequence_getitem(obj, 0), 42)
1002 def test__bytes__(self):
1004 self.assertEqual(foo.__bytes__(), foo)
1005 self.assertEqual(type(foo.__bytes__()), self.type2test)
1011 self.assertEqual(bar.__bytes__(), bar)
1012 self.assertEqual(type(bar.__bytes__()), self.type2test)
1014 def test_getitem_error(self):
1017 with self.assertRaisesRegex(TypeError, msg):
1020 def test_buffer_is_readonly(self):
1023 self.assertRaises(TypeError, f.readinto, b"")
1025 def test_custom(self):
1027 def __bytes__(self):
1029 self.assertEqual(bytes(A()), b'abc')
1031 self.assertRaises(TypeError, bytes, A())
1033 def __bytes__(self):
1035 self.assertRaises(TypeError, bytes, A())
1037 def __bytes__(self):
1039 def __index__(self):
1041 self.assertEqual(bytes(A()), b'a')
1044 def __bytes__(self):
1046 self.assertEqual(bytes(A('\u20ac')), b'abc')
1047 self.assertEqual(bytes(A('\u20ac'), 'iso8859-15'), b'\xa4')
1050 def __bytes__(self):
1052 self.assertEqual(bytes(A()), b'abc')
1053 self.assertIs(type(bytes(A())), OtherBytesSubclass)
1054 self.assertEqual(BytesSubclass(A()), b'abc')
1055 self.assertIs(type(BytesSubclass(A())), BytesSubclass)
1058 def test_from_format(self):
1073 self.assertEqual(PyBytes_FromFormat(b'format'),
1075 self.assertEqual(PyBytes_FromFormat(b'Hello %s !', b'world'),
1079 self.assertEqual(PyBytes_FromFormat(b'c=%c', c_int(0)),
1081 self.assertEqual(PyBytes_FromFormat(b'c=%c', c_int(ord('@'))),
1083 self.assertEqual(PyBytes_FromFormat(b'c=%c', c_int(255)),
1085 self.assertEqual(PyBytes_FromFormat(b'd=%d ld=%ld zd=%zd',
1089 self.assertEqual(PyBytes_FromFormat(b'd=%d ld=%ld zd=%zd',
1093 self.assertEqual(PyBytes_FromFormat(b'u=%u lu=%lu zu=%zu',
1097 self.assertEqual(PyBytes_FromFormat(b'i=%i', c_int(123)),
1099 self.assertEqual(PyBytes_FromFormat(b'i=%i', c_int(-123)),
1101 self.assertEqual(PyBytes_FromFormat(b'x=%x', c_int(0xabc)),
1117 self.assertEqual(PyBytes_FromFormat(b'ptr=%p', c_char_p(ptr)),
1119 self.assertEqual(PyBytes_FromFormat(b's=%s', c_char_p(b'cstr')),
1135 self.assertEqual(PyBytes_FromFormat(formatstr, ctypes_type(value)),
1139 self.assertEqual(PyBytes_FromFormat(b'%5s', b'a'),
1141 self.assertEqual(PyBytes_FromFormat(b'%.3s', b'abcdef'),
1145 self.assertEqual(PyBytes_FromFormat(b'%%'),
1147 self.assertEqual(PyBytes_FromFormat(b'[%%]'),
1149 self.assertEqual(PyBytes_FromFormat(b'%%%c', c_int(ord('_'))),
1151 self.assertEqual(PyBytes_FromFormat(b'%%s'),
1155 self.assertEqual(PyBytes_FromFormat(b'%'), b'%')
1156 self.assertEqual(PyBytes_FromFormat(b'x=%i y=%', c_int(2), c_int(3)),
1161 self.assertRaises(OverflowError,
1163 self.assertRaises(OverflowError,
1167 self.assertEqual(PyBytes_FromFormat(b''),
1169 self.assertEqual(PyBytes_FromFormat(b'%s', b''),
1172 def test_bytes_blocking(self):
1176 self.assertEqual(bytes(i), b'\x00\x01\x02\x03')
1177 self.assertRaises(TypeError, bytes, IterationBlocked(i))
1184 self.assertEqual(bytes(3), b'\0\0\0')
1185 self.assertRaises(TypeError, bytes, IntBlocked(3))
1193 self.assertEqual(bytes(b'ab'), b'ab')
1194 self.assertRaises(TypeError, bytes, BytesSubclassBlocked(b'ab'))
1199 self.assertEqual(bytes(ba), b'ab')
1200 self.assertRaises(TypeError, bytes, bb)
1202 def test_repeat_id_preserving(self):
1205 self.assertEqual(id(a), id(a))
1206 self.assertNotEqual(id(a), id(b))
1207 self.assertNotEqual(id(a), id(a * -4))
1208 self.assertNotEqual(id(a), id(a * 0))
1209 self.assertEqual(id(a), id(a * 1))
1210 self.assertEqual(id(a), id(1 * a))
1211 self.assertNotEqual(id(a), id(a * 2))
1217 self.assertEqual(id(s), id(s))
1218 self.assertNotEqual(id(s), id(s * -4))
1219 self.assertNotEqual(id(s), id(s * 0))
1220 self.assertNotEqual(id(s), id(s * 1))
1221 self.assertNotEqual(id(s), id(1 * s))
1222 self.assertNotEqual(id(s), id(s * 2))
1228 def test_getitem_error(self):
1231 with self.assertRaisesRegex(TypeError, msg):
1234 def test_setitem_error(self):
1237 with self.assertRaisesRegex(TypeError, msg):
1240 def test_nohash(self):
1241 self.assertRaises(TypeError, hash, bytearray())
1243 def test_bytearray_api(self):
1255 self.assertEqual(n, len(short_sample))
1256 self.assertEqual(list(b), list(sample))
1261 self.assertEqual(f.read(), sample)
1269 def test_reverse(self):
1271 self.assertEqual(b.reverse(), None)
1272 self.assertEqual(b, b'olleh')
1275 self.assertEqual(b, b'1olleh')
1278 self.assertFalse(b)
1280 def test_clear(self):
1283 self.assertEqual(b, b'')
1287 self.assertEqual(b, b'')
1293 self.assertEqual(b, b'p')
1295 def test_copy(self):
1298 self.assertEqual(bb, b'abc')
1302 self.assertEqual(bb, b'')
1307 self.assertEqual(b, bb)
1308 self.assertIsNot(b, bb)
1310 self.assertEqual(bb, b'abcd')
1311 self.assertEqual(b, b'abc')
1313 def test_regexps(self):
1317 self.assertEqual(re.findall(br"\w+", b), [by("Hello"), by("world")])
1319 def test_setitem(self):
1322 self.assertEqual(b, bytearray([1, 100, 3]))
1324 self.assertEqual(b, bytearray([1, 100, 200]))
1326 self.assertEqual(b, bytearray([10, 100, 200]))
1329 self.fail("Didn't raise IndexError")
1334 self.fail("Didn't raise IndexError")
1339 self.fail("Didn't raise ValueError")
1344 self.fail("Didn't raise ValueError")
1349 self.fail("Didn't raise TypeError")
1353 def test_delitem(self):
1356 self.assertEqual(b, bytearray(range(1, 10)))
1358 self.assertEqual(b, bytearray(range(1, 9)))
1360 self.assertEqual(b, bytearray([1, 2, 3, 4, 6, 7, 8]))
1362 def test_setslice(self):
1364 self.assertEqual(list(b), list(range(10)))
1367 self.assertEqual(b, bytearray([1, 1, 1, 1, 1, 5, 6, 7, 8, 9]))
1370 self.assertEqual(b, bytearray([5, 6, 7, 8, 9]))
1373 self.assertEqual(b, bytearray(range(10)))
1376 self.assertEqual(b, bytearray([0, 1, 2, 100, 101, 7, 8, 9]))
1379 self.assertEqual(b, bytearray(range(10)))
1382 self.assertEqual(b, bytearray([0, 1, 2, 42, 42, 42, 3, 4, 5, 6, 7, 8, 9]))
1385 self.assertEqual(b, bytearray([0, 1, 2, 102, 111, 111]))
1388 self.assertEqual(b, bytearray([102, 111, 111, 102, 111, 111]))
1391 self.assertEqual(b, bytearray([102, 111, 111, 111, 111]))
1395 with self.assertRaises(TypeError):
1399 with self.assertRaises(ValueError):
1402 def test_setslice_extend(self):
1405 self.assertEqual(list(b), list(range(100)))
1407 self.assertEqual(list(b), list(range(10, 100)))
1409 self.assertEqual(list(b), list(range(10, 110)))
1411 def test_fifo_overrun(self):
1420 def test_del_expand(self):
1425 self.assertLessEqual(sys.getsizeof(b), size)
1427 def test_extended_set_del_slice(self):
1442 self.assertEqual(b, bytearray(L))
1446 self.assertEqual(b, bytearray(L))
1448 def test_setslice_trap(self):
1449 # This test verifies that we correctly handle assigning self
1450 # to a slice of self (the old Lambert Meertens trap).
1453 self.assertEqual(b, bytearray(list(range(8)) + list(range(256))))
1455 def test_iconcat(self):
1459 self.assertEqual(b, b"abcdef")
1460 self.assertEqual(b, b1)
1461 self.assertIs(b, b1)
1463 self.assertEqual(b, b"abcdefxyz")
1469 self.fail("bytes += unicode didn't raise TypeError")
1471 def test_irepeat(self):
1475 self.assertEqual(b, b"abcabcabc")
1476 self.assertEqual(b, b1)
1477 self.assertIs(b, b1)
1479 def test_irepeat_1char(self):
1483 self.assertEqual(b, b"x"*100)
1484 self.assertEqual(b, b1)
1485 self.assertIs(b, b1)
1487 def test_alloc(self):
1490 self.assertGreaterEqual(alloc, 0)
1495 self.assertGreater(alloc, len(b)) # including trailing null byte
1499 def test_init_alloc(self):
1505 self.assertEqual(a, list(range(1, len(a)+1)))
1506 self.assertEqual(len(b), len(a))
1507 self.assertLessEqual(len(b), i)
1509 self.assertGreater(alloc, len(b)) # including trailing null byte
1511 self.assertEqual(list(b), list(range(1, 100)))
1512 self.assertEqual(len(b), 99)
1514 self.assertGreater(alloc, len(b))
1516 def test_extend(self):
1520 self.assertEqual(a, orig + orig)
1521 self.assertEqual(a[5:], orig)
1526 self.assertEqual(a, orig * 50)
1527 self.assertEqual(a[-5:], orig)
1530 self.assertEqual(a, orig * 50)
1531 self.assertEqual(a[-5:], orig)
1534 self.assertEqual(a, orig * 50)
1535 self.assertEqual(a[-5:], orig)
1537 self.assertRaises(ValueError, a.extend, [0, 1, 2, 256])
1538 self.assertRaises(ValueError, a.extend, [0, 1, 2, -1])
1539 self.assertEqual(len(a), 0)
1542 self.assertEqual(a, b'a')
1544 def test_remove(self):
1547 self.assertEqual(b, b'helo')
1549 self.assertEqual(b, b'heo')
1550 self.assertRaises(ValueError, lambda: b.remove(ord('l')))
1551 self.assertRaises(ValueError, lambda: b.remove(400))
1552 self.assertRaises(TypeError, lambda: b.remove('e'))
1556 self.assertEqual(b, b'e')
1557 self.assertRaises(TypeError, lambda: b.remove(b'e'))
1559 self.assertEqual(b, b'')
1564 self.assertEqual(c, bytes([126, 128, 129]))
1566 self.assertEqual(c, bytes([126, 128]))
1568 def test_pop(self):
1570 self.assertEqual(b.pop(), ord('d'))
1571 self.assertEqual(b.pop(0), ord('w'))
1572 self.assertEqual(b.pop(-2), ord('r'))
1573 self.assertRaises(IndexError, lambda: b.pop(10))
1574 self.assertRaises(IndexError, lambda: bytearray().pop())
1576 self.assertEqual(bytearray(b'\xff').pop(), 0xff)
1578 def test_nosort(self):
1579 self.assertRaises(AttributeError, lambda: bytearray().sort())
1581 def test_append(self):
1584 self.assertEqual(b, b'hello')
1585 self.assertEqual(b.append(100), None)
1588 self.assertEqual(len(b), 1)
1589 self.assertRaises(TypeError, lambda: b.append(b'o'))
1592 self.assertEqual(b, b'A')
1594 def test_insert(self):
1600 self.assertEqual(b, b'mississippi')
1601 self.assertRaises(TypeError, lambda: b.insert(0, b'1'))
1604 self.assertEqual(b, b'A')
1606 def test_copied(self):
1610 self.assertIsNot(b, b.replace(b'abc', b'cde', 0))
1614 self.assertIsNot(x, x.translate(t))
1616 def test_partition_bytearray_doesnt_share_nullstring(self):
1618 self.assertEqual(b, b"")
1619 self.assertEqual(c, b"")
1620 self.assertIsNot(b, c)
1622 self.assertEqual(c, b"")
1624 self.assertEqual(b, b"")
1625 self.assertEqual(c, b"")
1628 self.assertEqual(b, b"")
1629 self.assertEqual(c, b"")
1630 self.assertIsNot(b, c)
1632 self.assertEqual(c, b"")
1634 self.assertEqual(b, b"")
1635 self.assertEqual(c, b"")
1637 def test_resize_forbidden(self):
1648 self.assertRaises(BufferError, resize, 11)
1649 self.assertEqual(b, orig)
1650 self.assertRaises(BufferError, resize, 9)
1651 self.assertEqual(b, orig)
1652 self.assertRaises(BufferError, resize, 0)
1653 self.assertEqual(b, orig)
1655 self.assertRaises(BufferError, b.pop, 0)
1656 self.assertEqual(b, orig)
1657 self.assertRaises(BufferError, b.remove, b[1])
1658 self.assertEqual(b, orig)
1661 self.assertRaises(BufferError, delitem)
1662 self.assertEqual(b, orig)
1666 self.assertRaises(BufferError, delslice)
1667 self.assertEqual(b, orig)
1670 def test_obsolete_write_lock(self):
1672 self.assertRaises(BufferError, _testcapi.getbuffer_with_null_view, bytearray())
1674 def test_iterator_pickling2(self):
1683 self.assertEqual(type(it), type(itorig))
1684 self.assertEqual(list(it), data)
1691 self.assertEqual(type(it), type(itorig))
1692 self.assertEqual(list(it), data[1:])
1700 self.assertEqual(type(it), type(itorig))
1701 self.assertEqual(list(it), data[len(orig):])
1704 self.assertRaises(StopIteration, next, itorig)
1708 self.assertEqual(list(it), [])
1712 def test_iterator_length_hint(self):
1719 self.assertEqual(list(it), [])
1721 def test_repeat_after_setslice(self):
1727 self.assertEqual(b1, b'xc')
1728 self.assertEqual(b1, b)
1729 self.assertEqual(b3, b'xcxcxc')
1731 def test_mutating_index(self):
1733 def __index__(self):
1737 with self.subTest("tp_as_mapping"):
1739 with self.assertRaises(IndexError):
1742 with self.subTest("tp_as_sequence"):
1745 with self.assertRaises(IndexError):
1755 def test_repr_str(self):
1757 self.assertEqual(f(bytearray()), "bytearray(b'')")
1758 self.assertEqual(f(bytearray([0])), "bytearray(b'\\x00')")
1759 self.assertEqual(f(bytearray([0, 1, 254, 255])),
1761 self.assertEqual(f(b"abc"), "b'abc'")
1762 self.assertEqual(f(b"'"), '''b"'"''') # '''
1763 self.assertEqual(f(b"'\""), r"""b'\'"'""") # '
1766 def test_format(self):
1768 self.assertEqual(format(b), str(b))
1769 self.assertEqual(format(b, ''), str(b))
1770 with self.assertRaisesRegex(TypeError,
1774 def test_compare_bytes_to_bytearray(self):
1775 self.assertEqual(b"abc" == bytes(b"abc"), True)
1776 self.assertEqual(b"ab" != bytes(b"abc"), True)
1777 self.assertEqual(b"ab" <= bytes(b"abc"), True)
1778 self.assertEqual(b"ab" < bytes(b"abc"), True)
1779 self.assertEqual(b"abc" >= bytes(b"ab"), True)
1780 self.assertEqual(b"abc" > bytes(b"ab"), True)
1782 self.assertEqual(b"abc" != bytes(b"abc"), False)
1783 self.assertEqual(b"ab" == bytes(b"abc"), False)
1784 self.assertEqual(b"ab" > bytes(b"abc"), False)
1785 self.assertEqual(b"ab" >= bytes(b"abc"), False)
1786 self.assertEqual(b"abc" < bytes(b"ab"), False)
1787 self.assertEqual(b"abc" <= bytes(b"ab"), False)
1789 self.assertEqual(bytes(b"abc") == b"abc", True)
1790 self.assertEqual(bytes(b"ab") != b"abc", True)
1791 self.assertEqual(bytes(b"ab") <= b"abc", True)
1792 self.assertEqual(bytes(b"ab") < b"abc", True)
1793 self.assertEqual(bytes(b"abc") >= b"ab", True)
1794 self.assertEqual(bytes(b"abc") > b"ab", True)
1796 self.assertEqual(bytes(b"abc") != b"abc", False)
1797 self.assertEqual(bytes(b"ab") == b"abc", False)
1798 self.assertEqual(bytes(b"ab") > b"abc", False)
1799 self.assertEqual(bytes(b"ab") >= b"abc", False)
1800 self.assertEqual(bytes(b"abc") < b"ab", False)
1801 self.assertEqual(bytes(b"abc") <= b"ab", False)
1804 def test_doc(self):
1805 self.assertIsNotNone(bytearray.__doc__)
1806 self.assertTrue(bytearray.__doc__.startswith("bytearray("), bytearray.__doc__)
1807 self.assertIsNotNone(bytes.__doc__)
1808 self.assertTrue(bytes.__doc__.startswith("bytes("), bytes.__doc__)
1810 def test_from_bytearray(self):
1814 self.assertEqual(b, bytearray(sample))
1817 def test_to_str(self):
1818 self.assertEqual(str(b''), "b''")
1819 self.assertEqual(str(b'x'), "b'x'")
1820 self.assertEqual(str(b'\x80'), "b'\\x80'")
1821 self.assertEqual(str(bytearray(b'')), "bytearray(b'')")
1822 self.assertEqual(str(bytearray(b'x')), "bytearray(b'x')")
1823 self.assertEqual(str(bytearray(b'\x80')), "bytearray(b'\\x80')")
1825 def test_literal(self):
1833 self.assertEqual(b, bytearray(s, 'latin-1'))
1835 self.assertRaises(SyntaxError, eval,
1838 def test_split_bytearray(self):
1839 self.assertEqual(b'a b'.split(memoryview(b' ')), [b'a', b'b'])
1841 def test_rsplit_bytearray(self):
1842 self.assertEqual(b'a b'.rsplit(memoryview(b' ')), [b'a', b'b'])
1844 def test_return_self(self):
1847 self.assertIsNot(b.replace(b'', b''), b)
1851 def test_compare(self):
1895 def marshal(self, x):
1898 def test_returns_new_copy(self):
1899 val = self.marshal(b'1234')
1905 self.assertEqual(val, newval)
1906 self.assertIsNot(val, newval,
1907 methname+' returned self on a mutable object')
1912 self.assertEqual(val, newval)
1913 self.assertIsNot(val, newval,
1915 sep = self.marshal(b'')
1917 self.assertEqual(val, newval)
1918 self.assertIsNot(val, newval)
1922 def fixtype(self, obj):
1924 return self.type2test(obj.encode("utf-8"))
1938 def test_basic(self):
1939 self.assertTrue(issubclass(self.type2test, self.basetype))
1940 self.assertIsInstance(self.type2test(), self.basetype)
1943 _a, _b = self.type2test(a), self.type2test(b)
1946 self.assertTrue(_a == _a)
1947 self.assertTrue(_a != _b)
1948 self.assertTrue(_a < _b)
1949 self.assertTrue(_a <= _b)
1950 self.assertTrue(_b >= _a)
1951 self.assertTrue(_b > _a)
1952 self.assertIsNot(_a, a)
1955 self.assertEqual(a + b, _a + _b)
1956 self.assertEqual(a + b, a + _b)
1957 self.assertEqual(a + b, _a + b)
1960 self.assertTrue(a*5 == _a*5)
1962 def test_join(self):
1966 s1 = self.type2test(b"abcd")
1967 s2 = self.basetype().join([s1])
1968 self.assertIsNot(s1, s2)
1969 self.assertIs(type(s2), self.basetype, type(s2))
1973 self.assertIs(type(s3), self.basetype)
1975 def test_pickle(self):
1976 a = self.type2test(b"abcd")
1978 a.z = self.type2test(b"efgh")
1981 self.assertNotEqual(id(a), id(b))
1982 self.assertEqual(a, b)
1983 self.assertEqual(a.x, b.x)
1984 self.assertEqual(a.z, b.z)
1985 self.assertEqual(type(a), type(b))
1986 self.assertEqual(type(a.z), type(b.z))
1987 self.assertFalse(hasattr(b, 'y'))
1989 def test_copy(self):
1990 a = self.type2test(b"abcd")
1992 a.z = self.type2test(b"efgh")
1995 self.assertNotEqual(id(a), id(b))
1996 self.assertEqual(a, b)
1997 self.assertEqual(a.x, b.x)
1998 self.assertEqual(a.z, b.z)
1999 self.assertEqual(type(a), type(b))
2000 self.assertEqual(type(a.z), type(b.z))
2001 self.assertFalse(hasattr(b, 'y'))
2003 def test_fromhex(self):
2004 b = self.type2test.fromhex('1a2B30')
2005 self.assertEqual(b, b'\x1a\x2b\x30')
2006 self.assertIs(type(b), self.type2test)
2008 class B1(self.basetype):
2010 me = self.basetype.__new__(cls, value)
2015 self.assertEqual(b, b'\x1a\x2b\x30')
2016 self.assertIs(type(b), B1)
2017 self.assertEqual(b.foo, 'bar')
2019 class B2(self.basetype):
2021 if self.basetype is not bytes:
2022 self.basetype.__init__(me, *args, **kwargs)
2026 self.assertEqual(b, b'\x1a\x2b\x30')
2027 self.assertIs(type(b), B2)
2028 self.assertEqual(b.foo, 'bar')
2047 def test_init_override(self):
2053 self.assertEqual(x, b"abcd")
2055 self.assertEqual(x, b"abcd")