1"""Unit tests for the bytes and bytearray types.
2
3XXX This is a mess.  Common tests should be moved to buffer_tests.py,
4which itself ought to be unified with string_tests.py (and the latter
5should be modernized).
6"""
7
8import os
9import re
10import sys
11import copy
12import functools
13import pickle
14import tempfile
15import unittest
16import test.test_support
17import test.string_tests
18import test.buffer_tests
19
20
21if sys.flags.bytes_warning:
22    def check_bytes_warnings(func):
23        @functools.wraps(func)
24        def wrapper(*args, **kw):
25            with test.test_support.check_warnings(('', BytesWarning)):
26                return func(*args, **kw)
27        return wrapper
28else:
29    # no-op
30    def check_bytes_warnings(func):
31        return func
32
33
34class Indexable:
35    def __init__(self, value=0):
36        self.value = value
37    def __index__(self):
38        return self.value
39
40
41class BaseBytesTest(unittest.TestCase):
42
43    def test_basics(self):
44        b = self.type2test()
45        self.assertEqual(type(b), self.type2test)
46        self.assertEqual(b.__class__, self.type2test)
47
48    def test_empty_sequence(self):
49        b = self.type2test()
50        self.assertEqual(len(b), 0)
51        self.assertRaises(IndexError, lambda: b[0])
52        self.assertRaises(IndexError, lambda: b[1])
53        self.assertRaises(IndexError, lambda: b[sys.maxint])
54        self.assertRaises(IndexError, lambda: b[sys.maxint+1])
55        self.assertRaises(IndexError, lambda: b[10**100])
56        self.assertRaises(IndexError, lambda: b[-1])
57        self.assertRaises(IndexError, lambda: b[-2])
58        self.assertRaises(IndexError, lambda: b[-sys.maxint])
59        self.assertRaises(IndexError, lambda: b[-sys.maxint-1])
60        self.assertRaises(IndexError, lambda: b[-sys.maxint-2])
61        self.assertRaises(IndexError, lambda: b[-10**100])
62
63    def test_from_list(self):
64        ints = list(range(256))
65        b = self.type2test(i for i in ints)
66        self.assertEqual(len(b), 256)
67        self.assertEqual(list(b), ints)
68
69    def test_from_index(self):
70        b = self.type2test([Indexable(), Indexable(1), Indexable(254),
71                            Indexable(255)])
72        self.assertEqual(list(b), [0, 1, 254, 255])
73        self.assertRaises(ValueError, self.type2test, [Indexable(-1)])
74        self.assertRaises(ValueError, self.type2test, [Indexable(256)])
75
76    def test_from_ssize(self):
77        self.assertEqual(self.type2test(0), b'')
78        self.assertEqual(self.type2test(1), b'\x00')
79        self.assertEqual(self.type2test(5), b'\x00\x00\x00\x00\x00')
80        self.assertRaises(ValueError, self.type2test, -1)
81
82        self.assertEqual(self.type2test('0', 'ascii'), b'0')
83        self.assertEqual(self.type2test(b'0'), b'0')
84        self.assertRaises(OverflowError, self.type2test, sys.maxsize + 1)
85
86    def test_constructor_type_errors(self):
87        self.assertRaises(TypeError, self.type2test, 0.0)
88        class C:
89            pass
90        # allowed in 2.x
91        #self.assertRaises(TypeError, self.type2test, ["0"])
92        self.assertRaises(TypeError, self.type2test, [0.0])
93        self.assertRaises(TypeError, self.type2test, [None])
94        self.assertRaises(TypeError, self.type2test, [C()])
95
96    def test_constructor_value_errors(self):
97        self.assertRaises(ValueError, self.type2test, [-1])
98        self.assertRaises(ValueError, self.type2test, [-sys.maxint])
99        self.assertRaises(ValueError, self.type2test, [-sys.maxint-1])
100        self.assertRaises(ValueError, self.type2test, [-sys.maxint-2])
101        self.assertRaises(ValueError, self.type2test, [-10**100])
102        self.assertRaises(ValueError, self.type2test, [256])
103        self.assertRaises(ValueError, self.type2test, [257])
104        self.assertRaises(ValueError, self.type2test, [sys.maxint])
105        self.assertRaises(ValueError, self.type2test, [sys.maxint+1])
106        self.assertRaises(ValueError, self.type2test, [10**100])
107
108    def test_compare(self):
109        b1 = self.type2test([1, 2, 3])
110        b2 = self.type2test([1, 2, 3])
111        b3 = self.type2test([1, 3])
112
113        self.assertEqual(b1, b2)
114        self.assertTrue(b2 != b3)
115        self.assertTrue(b1 <= b2)
116        self.assertTrue(b1 <= b3)
117        self.assertTrue(b1 <  b3)
118        self.assertTrue(b1 >= b2)
119        self.assertTrue(b3 >= b2)
120        self.assertTrue(b3 >  b2)
121
122        self.assertFalse(b1 != b2)
123        self.assertFalse(b2 == b3)
124        self.assertFalse(b1 >  b2)
125        self.assertFalse(b1 >  b3)
126        self.assertFalse(b1 >= b3)
127        self.assertFalse(b1 <  b2)
128        self.assertFalse(b3 <  b2)
129        self.assertFalse(b3 <= b2)
130
131    @check_bytes_warnings
132    def test_compare_to_str(self):
133        # Byte comparisons with unicode should always fail!
134        # Test this for all expected byte orders and Unicode character sizes
135        self.assertEqual(self.type2test(b"\0a\0b\0c") == u"abc", False)
136        self.assertEqual(self.type2test(b"\0\0\0a\0\0\0b\0\0\0c") == u"abc", False)
137        self.assertEqual(self.type2test(b"a\0b\0c\0") == u"abc", False)
138        self.assertEqual(self.type2test(b"a\0\0\0b\0\0\0c\0\0\0") == u"abc", False)
139        self.assertEqual(self.type2test() == unicode(), False)
140        self.assertEqual(self.type2test() != unicode(), True)
141
142    def test_reversed(self):
143        input = list(map(ord, "Hello"))
144        b = self.type2test(input)
145        output = list(reversed(b))
146        input.reverse()
147        self.assertEqual(output, input)
148
149    def test_getslice(self):
150        def by(s):
151            return self.type2test(map(ord, s))
152        b = by("Hello, world")
153
154        self.assertEqual(b[:5], by("Hello"))
155        self.assertEqual(b[1:5], by("ello"))
156        self.assertEqual(b[5:7], by(", "))
157        self.assertEqual(b[7:], by("world"))
158        self.assertEqual(b[7:12], by("world"))
159        self.assertEqual(b[7:100], by("world"))
160
161        self.assertEqual(b[:-7], by("Hello"))
162        self.assertEqual(b[-11:-7], by("ello"))
163        self.assertEqual(b[-7:-5], by(", "))
164        self.assertEqual(b[-5:], by("world"))
165        self.assertEqual(b[-5:12], by("world"))
166        self.assertEqual(b[-5:100], by("world"))
167        self.assertEqual(b[-100:5], by("Hello"))
168
169    def test_extended_getslice(self):
170        # Test extended slicing by comparing with list slicing.
171        L = list(range(255))
172        b = self.type2test(L)
173        indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100)
174        for start in indices:
175            for stop in indices:
176                # Skip step 0 (invalid)
177                for step in indices[1:]:
178                    self.assertEqual(b[start:stop:step], self.type2test(L[start:stop:step]))
179
180    def test_encoding(self):
181        sample = u"Hello world\n\u1234\u5678\u9abc\udef0"
182        for enc in ("utf8", "utf16"):
183            b = self.type2test(sample, enc)
184            self.assertEqual(b, self.type2test(sample.encode(enc)))
185        self.assertRaises(UnicodeEncodeError, self.type2test, sample, "latin1")
186        b = self.type2test(sample, "latin1", "ignore")
187        self.assertEqual(b, self.type2test(sample[:-4], "utf-8"))
188
189    def test_decode(self):
190        sample = u"Hello world\n\u1234\u5678\u9abc\def0\def0"
191        for enc in ("utf8", "utf16"):
192            b = self.type2test(sample, enc)
193            self.assertEqual(b.decode(enc), sample)
194        sample = u"Hello world\n\x80\x81\xfe\xff"
195        b = self.type2test(sample, "latin1")
196        self.assertRaises(UnicodeDecodeError, b.decode, "utf8")
197        self.assertEqual(b.decode("utf8", "ignore"), "Hello world\n")
198        self.assertEqual(b.decode(errors="ignore", encoding="utf8"),
199                         "Hello world\n")
200
201    def test_from_int(self):
202        b = self.type2test(0)
203        self.assertEqual(b, self.type2test())
204        b = self.type2test(10)
205        self.assertEqual(b, self.type2test([0]*10))
206        b = self.type2test(10000)
207        self.assertEqual(b, self.type2test([0]*10000))
208
209    def test_concat(self):
210        b1 = self.type2test(b"abc")
211        b2 = self.type2test(b"def")
212        self.assertEqual(b1 + b2, b"abcdef")
213        self.assertEqual(b1 + bytes(b"def"), b"abcdef")
214        self.assertEqual(bytes(b"def") + b1, b"defabc")
215        self.assertRaises(TypeError, lambda: b1 + u"def")
216        self.assertRaises(TypeError, lambda: u"abc" + b2)
217
218    def test_repeat(self):
219        for b in b"abc", self.type2test(b"abc"):
220            self.assertEqual(b * 3, b"abcabcabc")
221            self.assertEqual(b * 0, b"")
222            self.assertEqual(b * -1, b"")
223            self.assertRaises(TypeError, lambda: b * 3.14)
224            self.assertRaises(TypeError, lambda: 3.14 * b)
225            # XXX Shouldn't bytes and bytearray agree on what to raise?
226            self.assertRaises((OverflowError, MemoryError),
227                              lambda: b * sys.maxsize)
228
229    def test_repeat_1char(self):
230        self.assertEqual(self.type2test(b'x')*100, self.type2test([ord('x')]*100))
231
232    def test_contains(self):
233        b = self.type2test(b"abc")
234        self.assertIn(ord('a'), b)
235        self.assertIn(int(ord('a')), b)
236        self.assertNotIn(200, b)
237        self.assertRaises(ValueError, lambda: 300 in b)
238        self.assertRaises(ValueError, lambda: -1 in b)
239        self.assertRaises(TypeError, lambda: None in b)
240        self.assertRaises(TypeError, lambda: float(ord('a')) in b)
241        self.assertRaises(TypeError, lambda: u"a" in b)
242        for f in bytes, bytearray:
243            self.assertIn(f(b""), b)
244            self.assertIn(f(b"a"), b)
245            self.assertIn(f(b"b"), b)
246            self.assertIn(f(b"c"), b)
247            self.assertIn(f(b"ab"), b)
248            self.assertIn(f(b"bc"), b)
249            self.assertIn(f(b"abc"), b)
250            self.assertNotIn(f(b"ac"), b)
251            self.assertNotIn(f(b"d"), b)
252            self.assertNotIn(f(b"dab"), b)
253            self.assertNotIn(f(b"abd"), b)
254
255    def test_fromhex(self):
256        self.assertRaises(TypeError, self.type2test.fromhex)
257        self.assertRaises(TypeError, self.type2test.fromhex, 1)
258        self.assertEqual(self.type2test.fromhex(u''), self.type2test())
259        b = bytearray([0x1a, 0x2b, 0x30])
260        self.assertEqual(self.type2test.fromhex(u'1a2B30'), b)
261        self.assertEqual(self.type2test.fromhex(u'  1A 2B  30   '), b)
262        self.assertEqual(self.type2test.fromhex(u'0000'), b'\0\0')
263        self.assertRaises(ValueError, self.type2test.fromhex, u'a')
264        self.assertRaises(ValueError, self.type2test.fromhex, u'rt')
265        self.assertRaises(ValueError, self.type2test.fromhex, u'1a b cd')
266        self.assertRaises(ValueError, self.type2test.fromhex, u'\x00')
267        self.assertRaises(ValueError, self.type2test.fromhex, u'12   \x00   34')
268
269    def test_join(self):
270        self.assertEqual(self.type2test(b"").join([]), b"")
271        self.assertEqual(self.type2test(b"").join([b""]), b"")
272        for lst in [[b"abc"], [b"a", b"bc"], [b"ab", b"c"], [b"a", b"b", b"c"]]:
273            lst = list(map(self.type2test, lst))
274            self.assertEqual(self.type2test(b"").join(lst), b"abc")
275            self.assertEqual(self.type2test(b"").join(tuple(lst)), b"abc")
276            self.assertEqual(self.type2test(b"").join(iter(lst)), b"abc")
277        self.assertEqual(self.type2test(b".").join([b"ab", b"cd"]), b"ab.cd")
278        # XXX more...
279
280    def test_count(self):
281        b = self.type2test(b'mississippi')
282        self.assertEqual(b.count(b'i'), 4)
283        self.assertEqual(b.count(b'ss'), 2)
284        self.assertEqual(b.count(b'w'), 0)
285
286    def test_startswith(self):
287        b = self.type2test(b'hello')
288        self.assertFalse(self.type2test().startswith(b"anything"))
289        self.assertTrue(b.startswith(b"hello"))
290        self.assertTrue(b.startswith(b"hel"))
291        self.assertTrue(b.startswith(b"h"))
292        self.assertFalse(b.startswith(b"hellow"))
293        self.assertFalse(b.startswith(b"ha"))
294
295    def test_endswith(self):
296        b = self.type2test(b'hello')
297        self.assertFalse(bytearray().endswith(b"anything"))
298        self.assertTrue(b.endswith(b"hello"))
299        self.assertTrue(b.endswith(b"llo"))
300        self.assertTrue(b.endswith(b"o"))
301        self.assertFalse(b.endswith(b"whello"))
302        self.assertFalse(b.endswith(b"no"))
303
304    def test_find(self):
305        b = self.type2test(b'mississippi')
306        self.assertEqual(b.find(b'ss'), 2)
307        self.assertEqual(b.find(b'ss', 3), 5)
308        self.assertEqual(b.find(b'ss', 1, 7), 2)
309        self.assertEqual(b.find(b'ss', 1, 3), -1)
310        self.assertEqual(b.find(b'w'), -1)
311        self.assertEqual(b.find(b'mississippian'), -1)
312
313    def test_rfind(self):
314        b = self.type2test(b'mississippi')
315        self.assertEqual(b.rfind(b'ss'), 5)
316        self.assertEqual(b.rfind(b'ss', 3), 5)
317        self.assertEqual(b.rfind(b'ss', 0, 6), 2)
318        self.assertEqual(b.rfind(b'w'), -1)
319        self.assertEqual(b.rfind(b'mississippian'), -1)
320
321    def test_index(self):
322        b = self.type2test(b'world')
323        self.assertEqual(b.index(b'w'), 0)
324        self.assertEqual(b.index(b'orl'), 1)
325        self.assertRaises(ValueError, b.index, b'worm')
326        self.assertRaises(ValueError, b.index, b'ldo')
327
328    def test_rindex(self):
329        # XXX could be more rigorous
330        b = self.type2test(b'world')
331        self.assertEqual(b.rindex(b'w'), 0)
332        self.assertEqual(b.rindex(b'orl'), 1)
333        self.assertRaises(ValueError, b.rindex, b'worm')
334        self.assertRaises(ValueError, b.rindex, b'ldo')
335
336    def test_replace(self):
337        b = self.type2test(b'mississippi')
338        self.assertEqual(b.replace(b'i', b'a'), b'massassappa')
339        self.assertEqual(b.replace(b'ss', b'x'), b'mixixippi')
340
341    def test_split(self):
342        b = self.type2test(b'mississippi')
343        self.assertEqual(b.split(b'i'), [b'm', b'ss', b'ss', b'pp', b''])
344        self.assertEqual(b.split(b'ss'), [b'mi', b'i', b'ippi'])
345        self.assertEqual(b.split(b'w'), [b])
346
347    def test_split_whitespace(self):
348        for b in (b'  arf  barf  ', b'arf\tbarf', b'arf\nbarf', b'arf\rbarf',
349                  b'arf\fbarf', b'arf\vbarf'):
350            b = self.type2test(b)
351            self.assertEqual(b.split(), [b'arf', b'barf'])
352            self.assertEqual(b.split(None), [b'arf', b'barf'])
353            self.assertEqual(b.split(None, 2), [b'arf', b'barf'])
354        for b in (b'a\x1Cb', b'a\x1Db', b'a\x1Eb', b'a\x1Fb'):
355            b = self.type2test(b)
356            self.assertEqual(b.split(), [b])
357        self.assertEqual(self.type2test(b'  a  bb  c  ').split(None, 0), [b'a  bb  c  '])
358        self.assertEqual(self.type2test(b'  a  bb  c  ').split(None, 1), [b'a', b'bb  c  '])
359        self.assertEqual(self.type2test(b'  a  bb  c  ').split(None, 2), [b'a', b'bb', b'c  '])
360        self.assertEqual(self.type2test(b'  a  bb  c  ').split(None, 3), [b'a', b'bb', b'c'])
361
362    def test_split_string_error(self):
363        self.assertRaises(TypeError, self.type2test(b'a b').split, u' ')
364
365    def test_split_unicodewhitespace(self):
366        b = self.type2test(b"\x09\x0A\x0B\x0C\x0D\x1C\x1D\x1E\x1F")
367        self.assertEqual(b.split(), [b'\x1c\x1d\x1e\x1f'])
368
369    def test_rsplit(self):
370        b = self.type2test(b'mississippi')
371        self.assertEqual(b.rsplit(b'i'), [b'm', b'ss', b'ss', b'pp', b''])
372        self.assertEqual(b.rsplit(b'ss'), [b'mi', b'i', b'ippi'])
373        self.assertEqual(b.rsplit(b'w'), [b])
374
375    def test_rsplit_whitespace(self):
376        for b in (b'  arf  barf  ', b'arf\tbarf', b'arf\nbarf', b'arf\rbarf',
377                  b'arf\fbarf', b'arf\vbarf'):
378            b = self.type2test(b)
379            self.assertEqual(b.rsplit(), [b'arf', b'barf'])
380            self.assertEqual(b.rsplit(None), [b'arf', b'barf'])
381            self.assertEqual(b.rsplit(None, 2), [b'arf', b'barf'])
382        self.assertEqual(self.type2test(b'  a  bb  c  ').rsplit(None, 0), [b'  a  bb  c'])
383        self.assertEqual(self.type2test(b'  a  bb  c  ').rsplit(None, 1), [b'  a  bb', b'c'])
384        self.assertEqual(self.type2test(b'  a  bb  c  ').rsplit(None, 2), [b'  a', b'bb', b'c'])
385        self.assertEqual(self.type2test(b'  a  bb  c  ').rsplit(None, 3), [b'a', b'bb', b'c'])
386
387    def test_rsplit_string_error(self):
388        self.assertRaises(TypeError, self.type2test(b'a b').rsplit, u' ')
389
390    def test_rsplit_unicodewhitespace(self):
391        b = self.type2test(b"\x09\x0A\x0B\x0C\x0D\x1C\x1D\x1E\x1F")
392        self.assertEqual(b.rsplit(), [b'\x1c\x1d\x1e\x1f'])
393
394    def test_partition(self):
395        b = self.type2test(b'mississippi')
396        self.assertEqual(b.partition(b'ss'), (b'mi', b'ss', b'issippi'))
397        self.assertEqual(b.partition(b'w'), (b'mississippi', b'', b''))
398
399    def test_rpartition(self):
400        b = self.type2test(b'mississippi')
401        self.assertEqual(b.rpartition(b'ss'), (b'missi', b'ss', b'ippi'))
402        self.assertEqual(b.rpartition(b'i'), (b'mississipp', b'i', b''))
403        self.assertEqual(b.rpartition(b'w'), (b'', b'', b'mississippi'))
404
405    def test_pickling(self):
406        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
407            for b in b"", b"a", b"abc", b"\xffab\x80", b"\0\0\377\0\0":
408                b = self.type2test(b)
409                ps = pickle.dumps(b, proto)
410                q = pickle.loads(ps)
411                self.assertEqual(b, q)
412
413    def test_strip(self):
414        b = self.type2test(b'mississippi')
415        self.assertEqual(b.strip(b'i'), b'mississipp')
416        self.assertEqual(b.strip(b'm'), b'ississippi')
417        self.assertEqual(b.strip(b'pi'), b'mississ')
418        self.assertEqual(b.strip(b'im'), b'ssissipp')
419        self.assertEqual(b.strip(b'pim'), b'ssiss')
420        self.assertEqual(b.strip(b), b'')
421
422    def test_lstrip(self):
423        b = self.type2test(b'mississippi')
424        self.assertEqual(b.lstrip(b'i'), b'mississippi')
425        self.assertEqual(b.lstrip(b'm'), b'ississippi')
426        self.assertEqual(b.lstrip(b'pi'), b'mississippi')
427        self.assertEqual(b.lstrip(b'im'), b'ssissippi')
428        self.assertEqual(b.lstrip(b'pim'), b'ssissippi')
429
430    def test_rstrip(self):
431        b = self.type2test(b'mississippi')
432        self.assertEqual(b.rstrip(b'i'), b'mississipp')
433        self.assertEqual(b.rstrip(b'm'), b'mississippi')
434        self.assertEqual(b.rstrip(b'pi'), b'mississ')
435        self.assertEqual(b.rstrip(b'im'), b'mississipp')
436        self.assertEqual(b.rstrip(b'pim'), b'mississ')
437
438    def test_strip_whitespace(self):
439        b = self.type2test(b' \t\n\r\f\vabc \t\n\r\f\v')
440        self.assertEqual(b.strip(), b'abc')
441        self.assertEqual(b.lstrip(), b'abc \t\n\r\f\v')
442        self.assertEqual(b.rstrip(), b' \t\n\r\f\vabc')
443
444    def test_strip_bytearray(self):
445        self.assertEqual(self.type2test(b'abc').strip(memoryview(b'ac')), b'b')
446        self.assertEqual(self.type2test(b'abc').lstrip(memoryview(b'ac')), b'bc')
447        self.assertEqual(self.type2test(b'abc').rstrip(memoryview(b'ac')), b'ab')
448
449    def test_strip_string_error(self):
450        self.assertRaises(TypeError, self.type2test(b'abc').strip, u'b')
451        self.assertRaises(TypeError, self.type2test(b'abc').lstrip, u'b')
452        self.assertRaises(TypeError, self.type2test(b'abc').rstrip, u'b')
453
454    def test_ord(self):
455        b = self.type2test(b'\0A\x7f\x80\xff')
456        self.assertEqual([ord(b[i:i+1]) for i in range(len(b))],
457                         [0, 65, 127, 128, 255])
458
459    def test_none_arguments(self):
460        # issue 11828
461        b = self.type2test(b'hello')
462        l = self.type2test(b'l')
463        h = self.type2test(b'h')
464        x = self.type2test(b'x')
465        o = self.type2test(b'o')
466
467        self.assertEqual(2, b.find(l, None))
468        self.assertEqual(3, b.find(l, -2, None))
469        self.assertEqual(2, b.find(l, None, -2))
470        self.assertEqual(0, b.find(h, None, None))
471
472        self.assertEqual(3, b.rfind(l, None))
473        self.assertEqual(3, b.rfind(l, -2, None))
474        self.assertEqual(2, b.rfind(l, None, -2))
475        self.assertEqual(0, b.rfind(h, None, None))
476
477        self.assertEqual(2, b.index(l, None))
478        self.assertEqual(3, b.index(l, -2, None))
479        self.assertEqual(2, b.index(l, None, -2))
480        self.assertEqual(0, b.index(h, None, None))
481
482        self.assertEqual(3, b.rindex(l, None))
483        self.assertEqual(3, b.rindex(l, -2, None))
484        self.assertEqual(2, b.rindex(l, None, -2))
485        self.assertEqual(0, b.rindex(h, None, None))
486
487        self.assertEqual(2, b.count(l, None))
488        self.assertEqual(1, b.count(l, -2, None))
489        self.assertEqual(1, b.count(l, None, -2))
490        self.assertEqual(0, b.count(x, None, None))
491
492        self.assertEqual(True, b.endswith(o, None))
493        self.assertEqual(True, b.endswith(o, -2, None))
494        self.assertEqual(True, b.endswith(l, None, -2))
495        self.assertEqual(False, b.endswith(x, None, None))
496
497        self.assertEqual(True, b.startswith(h, None))
498        self.assertEqual(True, b.startswith(l, -2, None))
499        self.assertEqual(True, b.startswith(h, None, -2))
500        self.assertEqual(False, b.startswith(x, None, None))
501
502    def test_find_etc_raise_correct_error_messages(self):
503        # issue 11828
504        b = self.type2test(b'hello')
505        x = self.type2test(b'x')
506        self.assertRaisesRegexp(TypeError, r'\bfind\b', b.find,
507                                x, None, None, None)
508        self.assertRaisesRegexp(TypeError, r'\brfind\b', b.rfind,
509                                x, None, None, None)
510        self.assertRaisesRegexp(TypeError, r'\bindex\b', b.index,
511                                x, None, None, None)
512        self.assertRaisesRegexp(TypeError, r'\brindex\b', b.rindex,
513                                x, None, None, None)
514        self.assertRaisesRegexp(TypeError, r'\bcount\b', b.count,
515                                x, None, None, None)
516        self.assertRaisesRegexp(TypeError, r'\bstartswith\b', b.startswith,
517                                x, None, None, None)
518        self.assertRaisesRegexp(TypeError, r'\bendswith\b', b.endswith,
519                                x, None, None, None)
520
521
522class ByteArrayTest(BaseBytesTest):
523    type2test = bytearray
524
525    def test_nohash(self):
526        self.assertRaises(TypeError, hash, bytearray())
527
528    def test_bytearray_api(self):
529        short_sample = b"Hello world\n"
530        sample = short_sample + b"\0"*(20 - len(short_sample))
531        tfn = tempfile.mktemp()
532        try:
533            # Prepare
534            with open(tfn, "wb") as f:
535                f.write(short_sample)
536            # Test readinto
537            with open(tfn, "rb") as f:
538                b = bytearray(20)
539                n = f.readinto(b)
540            self.assertEqual(n, len(short_sample))
541            # Python 2.x
542            b_sample = (ord(s) for s in sample)
543            self.assertEqual(list(b), list(b_sample))
544            # Test writing in binary mode
545            with open(tfn, "wb") as f:
546                f.write(b)
547            with open(tfn, "rb") as f:
548                self.assertEqual(f.read(), sample)
549            # Text mode is ambiguous; don't test
550        finally:
551            try:
552                os.remove(tfn)
553            except os.error:
554                pass
555
556    def test_reverse(self):
557        b = bytearray(b'hello')
558        self.assertEqual(b.reverse(), None)
559        self.assertEqual(b, b'olleh')
560        b = bytearray(b'hello1') # test even number of items
561        b.reverse()
562        self.assertEqual(b, b'1olleh')
563        b = bytearray()
564        b.reverse()
565        self.assertFalse(b)
566
567    def test_regexps(self):
568        def by(s):
569            return bytearray(map(ord, s))
570        b = by("Hello, world")
571        self.assertEqual(re.findall(r"\w+", b), [by("Hello"), by("world")])
572
573    def test_setitem(self):
574        b = bytearray([1, 2, 3])
575        b[1] = 100
576        self.assertEqual(b, bytearray([1, 100, 3]))
577        b[-1] = 200
578        self.assertEqual(b, bytearray([1, 100, 200]))
579        b[0] = Indexable(10)
580        self.assertEqual(b, bytearray([10, 100, 200]))
581        try:
582            b[3] = 0
583            self.fail("Didn't raise IndexError")
584        except IndexError:
585            pass
586        try:
587            b[-10] = 0
588            self.fail("Didn't raise IndexError")
589        except IndexError:
590            pass
591        try:
592            b[0] = 256
593            self.fail("Didn't raise ValueError")
594        except ValueError:
595            pass
596        try:
597            b[0] = Indexable(-1)
598            self.fail("Didn't raise ValueError")
599        except ValueError:
600            pass
601        try:
602            b[0] = None
603            self.fail("Didn't raise TypeError")
604        except TypeError:
605            pass
606
607    def test_delitem(self):
608        b = bytearray(range(10))
609        del b[0]
610        self.assertEqual(b, bytearray(range(1, 10)))
611        del b[-1]
612        self.assertEqual(b, bytearray(range(1, 9)))
613        del b[4]
614        self.assertEqual(b, bytearray([1, 2, 3, 4, 6, 7, 8]))
615
616    def test_setslice(self):
617        b = bytearray(range(10))
618        self.assertEqual(list(b), list(range(10)))
619
620        b[0:5] = bytearray([1, 1, 1, 1, 1])
621        self.assertEqual(b, bytearray([1, 1, 1, 1, 1, 5, 6, 7, 8, 9]))
622
623        del b[0:-5]
624        self.assertEqual(b, bytearray([5, 6, 7, 8, 9]))
625
626        b[0:0] = bytearray([0, 1, 2, 3, 4])
627        self.assertEqual(b, bytearray(range(10)))
628
629        b[-7:-3] = bytearray([100, 101])
630        self.assertEqual(b, bytearray([0, 1, 2, 100, 101, 7, 8, 9]))
631
632        b[3:5] = [3, 4, 5, 6]
633        self.assertEqual(b, bytearray(range(10)))
634
635        b[3:0] = [42, 42, 42]
636        self.assertEqual(b, bytearray([0, 1, 2, 42, 42, 42, 3, 4, 5, 6, 7, 8, 9]))
637
638        b[3:] = b'foo'
639        self.assertEqual(b, bytearray([0, 1, 2, 102, 111, 111]))
640
641        b[:3] = memoryview(b'foo')
642        self.assertEqual(b, bytearray([102, 111, 111, 102, 111, 111]))
643
644        b[3:4] = []
645        self.assertEqual(b, bytearray([102, 111, 111, 111, 111]))
646
647        b[1:] = list(b'uuuu')  # this works only on Python2
648        self.assertEqual(b, bytearray([102, 117, 117, 117, 117]))
649
650        for elem in [5, -5, 0, long(10e20), u'str', 2.3, [u'a', u'b'], [[]]]:
651            with self.assertRaises(TypeError):
652                b[3:4] = elem
653
654        for elem in [[254, 255, 256], [-256, 9000]]:
655            with self.assertRaises(ValueError):
656                b[3:4] = elem
657
658    def test_extended_set_del_slice(self):
659        indices = (0, None, 1, 3, 19, 300, 1<<333, -1, -2, -31, -300)
660        for start in indices:
661            for stop in indices:
662                # Skip invalid step 0
663                for step in indices[1:]:
664                    L = list(range(255))
665                    b = bytearray(L)
666                    # Make sure we have a slice of exactly the right length,
667                    # but with different data.
668                    data = L[start:stop:step]
669                    data.reverse()
670                    L[start:stop:step] = data
671                    b[start:stop:step] = data
672                    self.assertEqual(b, bytearray(L))
673
674                    del L[start:stop:step]
675                    del b[start:stop:step]
676                    self.assertEqual(b, bytearray(L))
677
678    def test_setslice_trap(self):
679        # This test verifies that we correctly handle assigning self
680        # to a slice of self (the old Lambert Meertens trap).
681        b = bytearray(range(256))
682        b[8:] = b
683        self.assertEqual(b, bytearray(list(range(8)) + list(range(256))))
684
685    def test_iconcat(self):
686        b = bytearray(b"abc")
687        b1 = b
688        b += b"def"
689        self.assertEqual(b, b"abcdef")
690        self.assertEqual(b, b1)
691        self.assertTrue(b is b1)
692        b += b"xyz"
693        self.assertEqual(b, b"abcdefxyz")
694        try:
695            b += u""
696        except TypeError:
697            pass
698        else:
699            self.fail("bytes += unicode didn't raise TypeError")
700
701    def test_irepeat(self):
702        b = bytearray(b"abc")
703        b1 = b
704        b *= 3
705        self.assertEqual(b, b"abcabcabc")
706        self.assertEqual(b, b1)
707        self.assertTrue(b is b1)
708
709    def test_irepeat_1char(self):
710        b = bytearray(b"x")
711        b1 = b
712        b *= 100
713        self.assertEqual(b, b"x"*100)
714        self.assertEqual(b, b1)
715        self.assertTrue(b is b1)
716
717    def test_alloc(self):
718        b = bytearray()
719        alloc = b.__alloc__()
720        self.assertTrue(alloc >= 0)
721        seq = [alloc]
722        for i in range(100):
723            b += b"x"
724            alloc = b.__alloc__()
725            self.assertTrue(alloc >= len(b))
726            if alloc not in seq:
727                seq.append(alloc)
728
729    def test_extend(self):
730        orig = b'hello'
731        a = bytearray(orig)
732        a.extend(a)
733        self.assertEqual(a, orig + orig)
734        self.assertEqual(a[5:], orig)
735        a = bytearray(b'')
736        # Test iterators that don't have a __length_hint__
737        a.extend(map(ord, orig * 25))
738        a.extend(ord(x) for x in orig * 25)
739        self.assertEqual(a, orig * 50)
740        self.assertEqual(a[-5:], orig)
741        a = bytearray(b'')
742        a.extend(iter(map(ord, orig * 50)))
743        self.assertEqual(a, orig * 50)
744        self.assertEqual(a[-5:], orig)
745        a = bytearray(b'')
746        a.extend(list(map(ord, orig * 50)))
747        self.assertEqual(a, orig * 50)
748        self.assertEqual(a[-5:], orig)
749        a = bytearray(b'')
750        self.assertRaises(ValueError, a.extend, [0, 1, 2, 256])
751        self.assertRaises(ValueError, a.extend, [0, 1, 2, -1])
752        self.assertEqual(len(a), 0)
753        a = bytearray(b'')
754        a.extend([Indexable(ord('a'))])
755        self.assertEqual(a, b'a')
756
757    def test_remove(self):
758        b = bytearray(b'hello')
759        b.remove(ord('l'))
760        self.assertEqual(b, b'helo')
761        b.remove(ord('l'))
762        self.assertEqual(b, b'heo')
763        self.assertRaises(ValueError, lambda: b.remove(ord('l')))
764        self.assertRaises(ValueError, lambda: b.remove(400))
765        self.assertRaises(TypeError, lambda: b.remove(u'e'))
766        # remove first and last
767        b.remove(ord('o'))
768        b.remove(ord('h'))
769        self.assertEqual(b, b'e')
770        self.assertRaises(TypeError, lambda: b.remove(u'e'))
771        b.remove(Indexable(ord('e')))
772        self.assertEqual(b, b'')
773
774    def test_pop(self):
775        b = bytearray(b'world')
776        self.assertEqual(b.pop(), ord('d'))
777        self.assertEqual(b.pop(0), ord('w'))
778        self.assertEqual(b.pop(-2), ord('r'))
779        self.assertRaises(IndexError, lambda: b.pop(10))
780        self.assertRaises(IndexError, lambda: bytearray().pop())
781        # test for issue #6846
782        self.assertEqual(bytearray(b'\xff').pop(), 0xff)
783
784    def test_nosort(self):
785        self.assertRaises(AttributeError, lambda: bytearray().sort())
786
787    def test_append(self):
788        b = bytearray(b'hell')
789        b.append(ord('o'))
790        self.assertEqual(b, b'hello')
791        self.assertEqual(b.append(100), None)
792        b = bytearray()
793        b.append(ord('A'))
794        self.assertEqual(len(b), 1)
795        self.assertRaises(TypeError, lambda: b.append(u'o'))
796        b = bytearray()
797        b.append(Indexable(ord('A')))
798        self.assertEqual(b, b'A')
799
800    def test_insert(self):
801        b = bytearray(b'msssspp')
802        b.insert(1, ord('i'))
803        b.insert(4, ord('i'))
804        b.insert(-2, ord('i'))
805        b.insert(1000, ord('i'))
806        self.assertEqual(b, b'mississippi')
807        # allowed in 2.x
808        #self.assertRaises(TypeError, lambda: b.insert(0, b'1'))
809        b = bytearray()
810        b.insert(0, Indexable(ord('A')))
811        self.assertEqual(b, b'A')
812
813    def test_copied(self):
814        # Issue 4348.  Make sure that operations that don't mutate the array
815        # copy the bytes.
816        b = bytearray(b'abc')
817        self.assertFalse(b is b.replace(b'abc', b'cde', 0))
818
819        t = bytearray([i for i in range(256)])
820        x = bytearray(b'')
821        self.assertFalse(x is x.translate(t))
822
823    def test_partition_bytearray_doesnt_share_nullstring(self):
824        a, b, c = bytearray(b"x").partition(b"y")
825        self.assertEqual(b, b"")
826        self.assertEqual(c, b"")
827        self.assertTrue(b is not c)
828        b += b"!"
829        self.assertEqual(c, b"")
830        a, b, c = bytearray(b"x").partition(b"y")
831        self.assertEqual(b, b"")
832        self.assertEqual(c, b"")
833        # Same for rpartition
834        b, c, a = bytearray(b"x").rpartition(b"y")
835        self.assertEqual(b, b"")
836        self.assertEqual(c, b"")
837        self.assertTrue(b is not c)
838        b += b"!"
839        self.assertEqual(c, b"")
840        c, b, a = bytearray(b"x").rpartition(b"y")
841        self.assertEqual(b, b"")
842        self.assertEqual(c, b"")
843
844    def test_resize_forbidden(self):
845        # #4509: can't resize a bytearray when there are buffer exports, even
846        # if it wouldn't reallocate the underlying buffer.
847        # Furthermore, no destructive changes to the buffer may be applied
848        # before raising the error.
849        b = bytearray(range(10))
850        v = memoryview(b)
851        def resize(n):
852            b[1:-1] = range(n + 1, 2*n - 1)
853        resize(10)
854        orig = b[:]
855        self.assertRaises(BufferError, resize, 11)
856        self.assertEqual(b, orig)
857        self.assertRaises(BufferError, resize, 9)
858        self.assertEqual(b, orig)
859        self.assertRaises(BufferError, resize, 0)
860        self.assertEqual(b, orig)
861        # Other operations implying resize
862        self.assertRaises(BufferError, b.pop, 0)
863        self.assertEqual(b, orig)
864        self.assertRaises(BufferError, b.remove, b[1])
865        self.assertEqual(b, orig)
866        def delitem():
867            del b[1]
868        self.assertRaises(BufferError, delitem)
869        self.assertEqual(b, orig)
870        # deleting a non-contiguous slice
871        def delslice():
872            b[1:-1:2] = b""
873        self.assertRaises(BufferError, delslice)
874        self.assertEqual(b, orig)
875
876    def test_empty_bytearray(self):
877        # Issue #7561: operations on empty bytearrays could crash in many
878        # situations, due to a fragile implementation of the
879        # PyByteArray_AS_STRING() C macro.
880        self.assertRaises(ValueError, int, bytearray(b''))
881
882
883class AssortedBytesTest(unittest.TestCase):
884    #
885    # Test various combinations of bytes and bytearray
886    #
887
888    @check_bytes_warnings
889    def test_repr_str(self):
890        for f in str, repr:
891            self.assertEqual(f(bytearray()), "bytearray(b'')")
892            self.assertEqual(f(bytearray([0])), "bytearray(b'\\x00')")
893            self.assertEqual(f(bytearray([0, 1, 254, 255])),
894                             "bytearray(b'\\x00\\x01\\xfe\\xff')")
895            self.assertEqual(f(b"abc"), "b'abc'")
896            self.assertEqual(f(b"'"), '''b"'"''') # '''
897            self.assertEqual(f(b"'\""), r"""b'\'"'""") # '
898
899    def test_compare_bytes_to_bytearray(self):
900        self.assertEqual(b"abc" == bytes(b"abc"), True)
901        self.assertEqual(b"ab" != bytes(b"abc"), True)
902        self.assertEqual(b"ab" <= bytes(b"abc"), True)
903        self.assertEqual(b"ab" < bytes(b"abc"), True)
904        self.assertEqual(b"abc" >= bytes(b"ab"), True)
905        self.assertEqual(b"abc" > bytes(b"ab"), True)
906
907        self.assertEqual(b"abc" != bytes(b"abc"), False)
908        self.assertEqual(b"ab" == bytes(b"abc"), False)
909        self.assertEqual(b"ab" > bytes(b"abc"), False)
910        self.assertEqual(b"ab" >= bytes(b"abc"), False)
911        self.assertEqual(b"abc" < bytes(b"ab"), False)
912        self.assertEqual(b"abc" <= bytes(b"ab"), False)
913
914        self.assertEqual(bytes(b"abc") == b"abc", True)
915        self.assertEqual(bytes(b"ab") != b"abc", True)
916        self.assertEqual(bytes(b"ab") <= b"abc", True)
917        self.assertEqual(bytes(b"ab") < b"abc", True)
918        self.assertEqual(bytes(b"abc") >= b"ab", True)
919        self.assertEqual(bytes(b"abc") > b"ab", True)
920
921        self.assertEqual(bytes(b"abc") != b"abc", False)
922        self.assertEqual(bytes(b"ab") == b"abc", False)
923        self.assertEqual(bytes(b"ab") > b"abc", False)
924        self.assertEqual(bytes(b"ab") >= b"abc", False)
925        self.assertEqual(bytes(b"abc") < b"ab", False)
926        self.assertEqual(bytes(b"abc") <= b"ab", False)
927
928    @test.test_support.requires_docstrings
929    def test_doc(self):
930        self.assertIsNotNone(bytearray.__doc__)
931        self.assertTrue(bytearray.__doc__.startswith("bytearray("), bytearray.__doc__)
932        self.assertIsNotNone(bytes.__doc__)
933        self.assertTrue(bytes.__doc__.startswith("bytes("), bytes.__doc__)
934
935    def test_from_bytearray(self):
936        sample = bytes(b"Hello world\n\x80\x81\xfe\xff")
937        buf = memoryview(sample)
938        b = bytearray(buf)
939        self.assertEqual(b, bytearray(sample))
940
941    @check_bytes_warnings
942    def test_to_str(self):
943        self.assertEqual(str(b''), "b''")
944        self.assertEqual(str(b'x'), "b'x'")
945        self.assertEqual(str(b'\x80'), "b'\\x80'")
946        self.assertEqual(str(bytearray(b'')), "bytearray(b'')")
947        self.assertEqual(str(bytearray(b'x')), "bytearray(b'x')")
948        self.assertEqual(str(bytearray(b'\x80')), "bytearray(b'\\x80')")
949
950    def test_literal(self):
951        tests =  [
952            (b"Wonderful spam", "Wonderful spam"),
953            (br"Wonderful spam too", "Wonderful spam too"),
954            (b"\xaa\x00\000\200", "\xaa\x00\000\200"),
955            (br"\xaa\x00\000\200", r"\xaa\x00\000\200"),
956        ]
957        for b, s in tests:
958            self.assertEqual(b, bytearray(s, 'latin-1'))
959        for c in range(128, 256):
960            self.assertRaises(SyntaxError, eval,
961                              'b"%s"' % chr(c))
962
963    def test_translate(self):
964        b = b'hello'
965        ba = bytearray(b)
966        rosetta = bytearray(range(0, 256))
967        rosetta[ord('o')] = ord('e')
968        c = b.translate(rosetta, b'l')
969        self.assertEqual(b, b'hello')
970        self.assertEqual(c, b'hee')
971        c = ba.translate(rosetta, b'l')
972        self.assertEqual(ba, b'hello')
973        self.assertEqual(c, b'hee')
974        c = b.translate(None, b'e')
975        self.assertEqual(c, b'hllo')
976        c = ba.translate(None, b'e')
977        self.assertEqual(c, b'hllo')
978        self.assertRaises(TypeError, b.translate, None, None)
979        self.assertRaises(TypeError, ba.translate, None, None)
980
981    def test_split_bytearray(self):
982        self.assertEqual(b'a b'.split(memoryview(b' ')), [b'a', b'b'])
983
984    def test_rsplit_bytearray(self):
985        self.assertEqual(b'a b'.rsplit(memoryview(b' ')), [b'a', b'b'])
986
987    # Optimizations:
988    # __iter__? (optimization)
989    # __reversed__? (optimization)
990
991    # XXX More string methods?  (Those that don't use character properties)
992
993    # There are tests in string_tests.py that are more
994    # comprehensive for things like split, partition, etc.
995    # Unfortunately they are all bundled with tests that
996    # are not appropriate for bytes
997
998    # I've started porting some of those into bytearray_tests.py, we should port
999    # the rest that make sense (the code can be cleaned up to use modern
1000    # unittest methods at the same time).
1001
1002class BytearrayPEP3137Test(unittest.TestCase,
1003                       test.buffer_tests.MixinBytesBufferCommonTests):
1004    def marshal(self, x):
1005        return bytearray(x)
1006
1007    def test_returns_new_copy(self):
1008        val = self.marshal(b'1234')
1009        # On immutable types these MAY return a reference to themselves
1010        # but on mutable types like bytearray they MUST return a new copy.
1011        for methname in ('zfill', 'rjust', 'ljust', 'center'):
1012            method = getattr(val, methname)
1013            newval = method(3)
1014            self.assertEqual(val, newval)
1015            self.assertTrue(val is not newval,
1016                            methname+' returned self on a mutable object')
1017        for expr in ('val.split()[0]', 'val.rsplit()[0]',
1018                     'val.partition(".")[0]', 'val.rpartition(".")[2]',
1019                     'val.splitlines()[0]', 'val.replace("", "")'):
1020            newval = eval(expr)
1021            self.assertEqual(val, newval)
1022            self.assertTrue(val is not newval,
1023                            expr+' returned val on a mutable object')
1024
1025class FixedStringTest(test.string_tests.BaseTest):
1026
1027    def fixtype(self, obj):
1028        if isinstance(obj, str):
1029            return obj.encode("utf-8")
1030        return super(FixedStringTest, self).fixtype(obj)
1031
1032    # Currently the bytes containment testing uses a single integer
1033    # value. This may not be the final design, but until then the
1034    # bytes section with in a bytes containment not valid
1035    def test_contains(self):
1036        pass
1037    def test_expandtabs(self):
1038        pass
1039    def test_upper(self):
1040        pass
1041    def test_lower(self):
1042        pass
1043    def test_hash(self):
1044        # XXX check this out
1045        pass
1046
1047
1048class ByteArrayAsStringTest(FixedStringTest):
1049    type2test = bytearray
1050
1051
1052class ByteArraySubclass(bytearray):
1053    pass
1054
1055class ByteArraySubclassTest(unittest.TestCase):
1056
1057    def test_basic(self):
1058        self.assertTrue(issubclass(ByteArraySubclass, bytearray))
1059        self.assertIsInstance(ByteArraySubclass(), bytearray)
1060
1061        a, b = b"abcd", b"efgh"
1062        _a, _b = ByteArraySubclass(a), ByteArraySubclass(b)
1063
1064        # test comparison operators with subclass instances
1065        self.assertTrue(_a == _a)
1066        self.assertTrue(_a != _b)
1067        self.assertTrue(_a < _b)
1068        self.assertTrue(_a <= _b)
1069        self.assertTrue(_b >= _a)
1070        self.assertTrue(_b > _a)
1071        self.assertTrue(_a is not a)
1072
1073        # test concat of subclass instances
1074        self.assertEqual(a + b, _a + _b)
1075        self.assertEqual(a + b, a + _b)
1076        self.assertEqual(a + b, _a + b)
1077
1078        # test repeat
1079        self.assertTrue(a*5 == _a*5)
1080
1081    def test_join(self):
1082        # Make sure join returns a NEW object for single item sequences
1083        # involving a subclass.
1084        # Make sure that it is of the appropriate type.
1085        s1 = ByteArraySubclass(b"abcd")
1086        s2 = bytearray().join([s1])
1087        self.assertTrue(s1 is not s2)
1088        self.assertTrue(type(s2) is bytearray, type(s2))
1089
1090        # Test reverse, calling join on subclass
1091        s3 = s1.join([b"abcd"])
1092        self.assertTrue(type(s3) is bytearray)
1093
1094    def test_pickle(self):
1095        a = ByteArraySubclass(b"abcd")
1096        a.x = 10
1097        a.y = ByteArraySubclass(b"efgh")
1098        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1099            b = pickle.loads(pickle.dumps(a, proto))
1100            self.assertNotEqual(id(a), id(b))
1101            self.assertEqual(a, b)
1102            self.assertEqual(a.x, b.x)
1103            self.assertEqual(a.y, b.y)
1104            self.assertEqual(type(a), type(b))
1105            self.assertEqual(type(a.y), type(b.y))
1106
1107    def test_copy(self):
1108        a = ByteArraySubclass(b"abcd")
1109        a.x = 10
1110        a.y = ByteArraySubclass(b"efgh")
1111        for copy_method in (copy.copy, copy.deepcopy):
1112            b = copy_method(a)
1113            self.assertNotEqual(id(a), id(b))
1114            self.assertEqual(a, b)
1115            self.assertEqual(a.x, b.x)
1116            self.assertEqual(a.y, b.y)
1117            self.assertEqual(type(a), type(b))
1118            self.assertEqual(type(a.y), type(b.y))
1119
1120    def test_init_override(self):
1121        class subclass(bytearray):
1122            def __init__(self, newarg=1, *args, **kwargs):
1123                bytearray.__init__(self, *args, **kwargs)
1124        x = subclass(4, source=b"abcd")
1125        self.assertEqual(x, b"abcd")
1126        x = subclass(newarg=4, source=b"abcd")
1127        self.assertEqual(x, b"abcd")
1128
1129def test_main():
1130    #test.test_support.run_unittest(BytesTest)
1131    #test.test_support.run_unittest(AssortedBytesTest)
1132    #test.test_support.run_unittest(BytesAsStringTest)
1133    test.test_support.run_unittest(
1134        ByteArrayTest,
1135        ByteArrayAsStringTest,
1136        ByteArraySubclassTest,
1137        BytearrayPEP3137Test)
1138
1139if __name__ == "__main__":
1140    test_main()
1141