blob: ddcf367f38fc81f29526753674e4e3978ecadfeb [file] [log] [blame]
Guido van Rossum254348e2007-11-21 19:29:53 +00001"""Unit tests for the bytes and bytearray types.
Guido van Rossum98297ee2007-11-06 21:34:58 +00002
Martin Panter152a19c2016-04-06 06:37:17 +00003XXX This is a mess. Common tests should be unified with string_tests.py (and
4the latter should be modernized).
Guido van Rossum98297ee2007-11-06 21:34:58 +00005"""
Guido van Rossum4dfe8a12006-04-22 23:28:04 +00006
INADA Naokia634e232017-01-06 17:32:01 +09007import array
Guido van Rossumd624f182006-04-24 13:47:05 +00008import os
9import re
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000010import sys
Guido van Rossuma6c04be2007-11-03 00:24:24 +000011import copy
Florent Xiclunaedf5f0d2010-09-03 20:00:37 +000012import functools
Guido van Rossum0ad08122007-04-11 04:37:43 +000013import pickle
Guido van Rossumd624f182006-04-24 13:47:05 +000014import tempfile
Victor Stinner22eb6892019-06-26 00:51:05 +020015import textwrap
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000016import unittest
Antoine Pitroucc231542014-11-02 18:40:09 +010017
Benjamin Petersonee8712c2008-05-20 21:35:26 +000018import test.support
Georg Brandlc7885542007-03-06 19:16:20 +000019import test.string_tests
Serhiy Storchaka8dc2ec12016-03-30 21:01:26 +030020import test.list_tests
Antoine Pitroucc231542014-11-02 18:40:09 +010021from test.support import bigaddrspacetest, MAX_Py_ssize_t
Victor Stinner22eb6892019-06-26 00:51:05 +020022from test.support.script_helper import assert_python_failure
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000023
Florent Xiclunaedf5f0d2010-09-03 20:00:37 +000024
25if sys.flags.bytes_warning:
26 def check_bytes_warnings(func):
27 @functools.wraps(func)
28 def wrapper(*args, **kw):
29 with test.support.check_warnings(('', BytesWarning)):
30 return func(*args, **kw)
31 return wrapper
32else:
33 # no-op
34 def check_bytes_warnings(func):
35 return func
36
37
Georg Brandl9a54d7c2008-07-16 23:15:30 +000038class Indexable:
39 def __init__(self, value=0):
40 self.value = value
41 def __index__(self):
42 return self.value
43
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000044
Ezio Melotti0dceb562013-01-10 07:43:26 +020045class BaseBytesTest:
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000046
47 def test_basics(self):
Christian Heimes510711d2008-01-30 11:57:58 +000048 b = self.type2test()
49 self.assertEqual(type(b), self.type2test)
50 self.assertEqual(b.__class__, self.type2test)
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000051
Alexandre Vassalotti41f58a72010-01-12 01:23:09 +000052 def test_copy(self):
53 a = self.type2test(b"abcd")
54 for copy_method in (copy.copy, copy.deepcopy):
55 b = copy_method(a)
56 self.assertEqual(a, b)
57 self.assertEqual(type(a), type(b))
58
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000059 def test_empty_sequence(self):
Christian Heimes510711d2008-01-30 11:57:58 +000060 b = self.type2test()
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000061 self.assertEqual(len(b), 0)
62 self.assertRaises(IndexError, lambda: b[0])
63 self.assertRaises(IndexError, lambda: b[1])
Christian Heimesa37d4c62007-12-04 23:02:19 +000064 self.assertRaises(IndexError, lambda: b[sys.maxsize])
65 self.assertRaises(IndexError, lambda: b[sys.maxsize+1])
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000066 self.assertRaises(IndexError, lambda: b[10**100])
67 self.assertRaises(IndexError, lambda: b[-1])
68 self.assertRaises(IndexError, lambda: b[-2])
Christian Heimesa37d4c62007-12-04 23:02:19 +000069 self.assertRaises(IndexError, lambda: b[-sys.maxsize])
70 self.assertRaises(IndexError, lambda: b[-sys.maxsize-1])
71 self.assertRaises(IndexError, lambda: b[-sys.maxsize-2])
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000072 self.assertRaises(IndexError, lambda: b[-10**100])
73
Serhiy Storchaka1a997eb2018-10-13 20:39:45 +030074 def test_from_iterable(self):
75 b = self.type2test(range(256))
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000076 self.assertEqual(len(b), 256)
Serhiy Storchaka1a997eb2018-10-13 20:39:45 +030077 self.assertEqual(list(b), list(range(256)))
78
79 # Non-sequence iterable.
80 b = self.type2test({42})
81 self.assertEqual(b, b"*")
82 b = self.type2test({43, 45})
83 self.assertIn(tuple(b), {(43, 45), (45, 43)})
84
85 # Iterator that has a __length_hint__.
86 b = self.type2test(iter(range(256)))
87 self.assertEqual(len(b), 256)
88 self.assertEqual(list(b), list(range(256)))
89
90 # Iterator that doesn't have a __length_hint__.
91 b = self.type2test(i for i in range(256) if i % 2)
92 self.assertEqual(len(b), 128)
93 self.assertEqual(list(b), list(range(256))[1::2])
94
95 # Sequence without __iter__.
96 class S:
97 def __getitem__(self, i):
98 return (1, 2, 3)[i]
99 b = self.type2test(S())
100 self.assertEqual(b, b"\x01\x02\x03")
101
102 def test_from_tuple(self):
103 # There is a special case for tuples.
104 b = self.type2test(tuple(range(256)))
105 self.assertEqual(len(b), 256)
106 self.assertEqual(list(b), list(range(256)))
107 b = self.type2test((1, 2, 3))
108 self.assertEqual(b, b"\x01\x02\x03")
109
110 def test_from_list(self):
111 # There is a special case for lists.
112 b = self.type2test(list(range(256)))
113 self.assertEqual(len(b), 256)
114 self.assertEqual(list(b), list(range(256)))
115 b = self.type2test([1, 2, 3])
116 self.assertEqual(b, b"\x01\x02\x03")
Guido van Rossum4dfe8a12006-04-22 23:28:04 +0000117
Serhiy Storchaka914f9a02018-10-21 15:25:53 +0300118 def test_from_mutating_list(self):
119 # Issue #34973: Crash in bytes constructor with mutating list.
120 class X:
121 def __index__(self):
122 a.clear()
123 return 42
124 a = [X(), X()]
125 self.assertEqual(bytes(a), b'*')
126
127 class Y:
128 def __index__(self):
129 if len(a) < 1000:
130 a.append(self)
131 return 42
132 a = [Y()]
133 self.assertEqual(bytes(a), b'*' * 1000) # should not crash
134
Guido van Rossum4dfe8a12006-04-22 23:28:04 +0000135 def test_from_index(self):
Georg Brandl9a54d7c2008-07-16 23:15:30 +0000136 b = self.type2test([Indexable(), Indexable(1), Indexable(254),
137 Indexable(255)])
Guido van Rossum4dfe8a12006-04-22 23:28:04 +0000138 self.assertEqual(list(b), [0, 1, 254, 255])
Benjamin Peterson4c045832010-04-16 22:35:32 +0000139 self.assertRaises(ValueError, self.type2test, [Indexable(-1)])
140 self.assertRaises(ValueError, self.type2test, [Indexable(256)])
Guido van Rossum98297ee2007-11-06 21:34:58 +0000141
INADA Naokia634e232017-01-06 17:32:01 +0900142 def test_from_buffer(self):
143 a = self.type2test(array.array('B', [1, 2, 3]))
144 self.assertEqual(a, b"\x01\x02\x03")
Serhiy Storchaka1a997eb2018-10-13 20:39:45 +0300145 a = self.type2test(b"\x01\x02\x03")
146 self.assertEqual(a, b"\x01\x02\x03")
INADA Naokia634e232017-01-06 17:32:01 +0900147
Serhiy Storchakae8904212018-10-15 00:02:57 +0300148 # Issues #29159 and #34974.
149 # Fallback when __index__ raises a TypeError
INADA Naokia634e232017-01-06 17:32:01 +0900150 class B(bytes):
151 def __index__(self):
152 raise TypeError
153
154 self.assertEqual(self.type2test(B(b"foobar")), b"foobar")
155
Guido van Rossum98297ee2007-11-06 21:34:58 +0000156 def test_from_ssize(self):
Benjamin Peterson4c045832010-04-16 22:35:32 +0000157 self.assertEqual(self.type2test(0), b'')
158 self.assertEqual(self.type2test(1), b'\x00')
159 self.assertEqual(self.type2test(5), b'\x00\x00\x00\x00\x00')
160 self.assertRaises(ValueError, self.type2test, -1)
Guido van Rossum98297ee2007-11-06 21:34:58 +0000161
Benjamin Peterson4c045832010-04-16 22:35:32 +0000162 self.assertEqual(self.type2test('0', 'ascii'), b'0')
163 self.assertEqual(self.type2test(b'0'), b'0')
Benjamin Peterson8380dd52010-04-16 22:51:37 +0000164 self.assertRaises(OverflowError, self.type2test, sys.maxsize + 1)
Guido van Rossum4dfe8a12006-04-22 23:28:04 +0000165
166 def test_constructor_type_errors(self):
Christian Heimes510711d2008-01-30 11:57:58 +0000167 self.assertRaises(TypeError, self.type2test, 0.0)
Guido van Rossum4dfe8a12006-04-22 23:28:04 +0000168 class C:
169 pass
Christian Heimes510711d2008-01-30 11:57:58 +0000170 self.assertRaises(TypeError, self.type2test, ["0"])
171 self.assertRaises(TypeError, self.type2test, [0.0])
172 self.assertRaises(TypeError, self.type2test, [None])
173 self.assertRaises(TypeError, self.type2test, [C()])
Serhiy Storchaka2c2044e2018-10-21 15:29:12 +0300174 self.assertRaises(TypeError, self.type2test, encoding='ascii')
175 self.assertRaises(TypeError, self.type2test, errors='ignore')
Serhiy Storchaka83cf99d2014-12-02 09:24:06 +0200176 self.assertRaises(TypeError, self.type2test, 0, 'ascii')
177 self.assertRaises(TypeError, self.type2test, b'', 'ascii')
178 self.assertRaises(TypeError, self.type2test, 0, errors='ignore')
179 self.assertRaises(TypeError, self.type2test, b'', errors='ignore')
180 self.assertRaises(TypeError, self.type2test, '')
181 self.assertRaises(TypeError, self.type2test, '', errors='ignore')
182 self.assertRaises(TypeError, self.type2test, '', b'ascii')
183 self.assertRaises(TypeError, self.type2test, '', 'ascii', b'ignore')
Guido van Rossum4dfe8a12006-04-22 23:28:04 +0000184
185 def test_constructor_value_errors(self):
Christian Heimes510711d2008-01-30 11:57:58 +0000186 self.assertRaises(ValueError, self.type2test, [-1])
187 self.assertRaises(ValueError, self.type2test, [-sys.maxsize])
188 self.assertRaises(ValueError, self.type2test, [-sys.maxsize-1])
189 self.assertRaises(ValueError, self.type2test, [-sys.maxsize-2])
190 self.assertRaises(ValueError, self.type2test, [-10**100])
191 self.assertRaises(ValueError, self.type2test, [256])
192 self.assertRaises(ValueError, self.type2test, [257])
193 self.assertRaises(ValueError, self.type2test, [sys.maxsize])
194 self.assertRaises(ValueError, self.type2test, [sys.maxsize+1])
195 self.assertRaises(ValueError, self.type2test, [10**100])
Guido van Rossum4dfe8a12006-04-22 23:28:04 +0000196
Antoine Pitroucc231542014-11-02 18:40:09 +0100197 @bigaddrspacetest
198 def test_constructor_overflow(self):
199 size = MAX_Py_ssize_t
200 self.assertRaises((OverflowError, MemoryError), self.type2test, size)
201 try:
202 # Should either pass or raise an error (e.g. on debug builds with
203 # additional malloc() overhead), but shouldn't crash.
204 bytearray(size - 4)
205 except (OverflowError, MemoryError):
206 pass
207
Serhiy Storchakae8904212018-10-15 00:02:57 +0300208 def test_constructor_exceptions(self):
209 # Issue #34974: bytes and bytearray constructors replace unexpected
210 # exceptions.
211 class BadInt:
212 def __index__(self):
213 1/0
214 self.assertRaises(ZeroDivisionError, self.type2test, BadInt())
215 self.assertRaises(ZeroDivisionError, self.type2test, [BadInt()])
216
217 class BadIterable:
218 def __iter__(self):
219 1/0
220 self.assertRaises(ZeroDivisionError, self.type2test, BadIterable())
221
Guido van Rossum4dfe8a12006-04-22 23:28:04 +0000222 def test_compare(self):
Christian Heimes510711d2008-01-30 11:57:58 +0000223 b1 = self.type2test([1, 2, 3])
224 b2 = self.type2test([1, 2, 3])
225 b3 = self.type2test([1, 3])
Guido van Rossum4dfe8a12006-04-22 23:28:04 +0000226
Guido van Rossume61fd5b2007-07-11 12:20:59 +0000227 self.assertEqual(b1, b2)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000228 self.assertTrue(b2 != b3)
229 self.assertTrue(b1 <= b2)
230 self.assertTrue(b1 <= b3)
231 self.assertTrue(b1 < b3)
232 self.assertTrue(b1 >= b2)
233 self.assertTrue(b3 >= b2)
234 self.assertTrue(b3 > b2)
Guido van Rossum4dfe8a12006-04-22 23:28:04 +0000235
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000236 self.assertFalse(b1 != b2)
237 self.assertFalse(b2 == b3)
238 self.assertFalse(b1 > b2)
239 self.assertFalse(b1 > b3)
240 self.assertFalse(b1 >= b3)
241 self.assertFalse(b1 < b2)
242 self.assertFalse(b3 < b2)
243 self.assertFalse(b3 <= b2)
Guido van Rossum4dfe8a12006-04-22 23:28:04 +0000244
Florent Xiclunaedf5f0d2010-09-03 20:00:37 +0000245 @check_bytes_warnings
Guido van Rossum343e97f2007-04-09 00:43:24 +0000246 def test_compare_to_str(self):
Florent Xiclunaedf5f0d2010-09-03 20:00:37 +0000247 # Byte comparisons with unicode should always fail!
248 # Test this for all expected byte orders and Unicode character
249 # sizes.
250 self.assertEqual(self.type2test(b"\0a\0b\0c") == "abc", False)
251 self.assertEqual(self.type2test(b"\0\0\0a\0\0\0b\0\0\0c") == "abc",
252 False)
253 self.assertEqual(self.type2test(b"a\0b\0c\0") == "abc", False)
254 self.assertEqual(self.type2test(b"a\0\0\0b\0\0\0c\0\0\0") == "abc",
255 False)
256 self.assertEqual(self.type2test() == str(), False)
257 self.assertEqual(self.type2test() != str(), True)
Christian Heimes510711d2008-01-30 11:57:58 +0000258
259 def test_reversed(self):
260 input = list(map(ord, "Hello"))
261 b = self.type2test(input)
262 output = list(reversed(b))
263 input.reverse()
264 self.assertEqual(output, input)
265
266 def test_getslice(self):
267 def by(s):
268 return self.type2test(map(ord, s))
269 b = by("Hello, world")
270
271 self.assertEqual(b[:5], by("Hello"))
272 self.assertEqual(b[1:5], by("ello"))
273 self.assertEqual(b[5:7], by(", "))
274 self.assertEqual(b[7:], by("world"))
275 self.assertEqual(b[7:12], by("world"))
276 self.assertEqual(b[7:100], by("world"))
277
278 self.assertEqual(b[:-7], by("Hello"))
279 self.assertEqual(b[-11:-7], by("ello"))
280 self.assertEqual(b[-7:-5], by(", "))
281 self.assertEqual(b[-5:], by("world"))
282 self.assertEqual(b[-5:12], by("world"))
283 self.assertEqual(b[-5:100], by("world"))
284 self.assertEqual(b[-100:5], by("Hello"))
285
286 def test_extended_getslice(self):
287 # Test extended slicing by comparing with list slicing.
288 L = list(range(255))
289 b = self.type2test(L)
Zackery Spytz14514d92019-05-17 01:13:03 -0600290 indices = (0, None, 1, 3, 19, 100, sys.maxsize, -1, -2, -31, -100)
Christian Heimes510711d2008-01-30 11:57:58 +0000291 for start in indices:
292 for stop in indices:
293 # Skip step 0 (invalid)
294 for step in indices[1:]:
295 self.assertEqual(b[start:stop:step], self.type2test(L[start:stop:step]))
296
297 def test_encoding(self):
Martin v. Löwisdb12d452009-05-02 18:52:14 +0000298 sample = "Hello world\n\u1234\u5678\u9abc"
Marc-André Lemburg8f36af72011-02-25 15:42:01 +0000299 for enc in ("utf-8", "utf-16"):
Christian Heimes510711d2008-01-30 11:57:58 +0000300 b = self.type2test(sample, enc)
301 self.assertEqual(b, self.type2test(sample.encode(enc)))
Marc-André Lemburg8f36af72011-02-25 15:42:01 +0000302 self.assertRaises(UnicodeEncodeError, self.type2test, sample, "latin-1")
303 b = self.type2test(sample, "latin-1", "ignore")
Martin v. Löwisdb12d452009-05-02 18:52:14 +0000304 self.assertEqual(b, self.type2test(sample[:-3], "utf-8"))
Christian Heimes510711d2008-01-30 11:57:58 +0000305
306 def test_decode(self):
Serhiy Storchakac49a5162016-09-08 15:47:27 +0300307 sample = "Hello world\n\u1234\u5678\u9abc"
Marc-André Lemburg8f36af72011-02-25 15:42:01 +0000308 for enc in ("utf-8", "utf-16"):
Christian Heimes510711d2008-01-30 11:57:58 +0000309 b = self.type2test(sample, enc)
310 self.assertEqual(b.decode(enc), sample)
311 sample = "Hello world\n\x80\x81\xfe\xff"
Marc-André Lemburg8f36af72011-02-25 15:42:01 +0000312 b = self.type2test(sample, "latin-1")
313 self.assertRaises(UnicodeDecodeError, b.decode, "utf-8")
314 self.assertEqual(b.decode("utf-8", "ignore"), "Hello world\n")
315 self.assertEqual(b.decode(errors="ignore", encoding="utf-8"),
Benjamin Peterson308d6372009-09-18 21:42:35 +0000316 "Hello world\n")
Marc-André Lemburg8f36af72011-02-25 15:42:01 +0000317 # Default encoding is utf-8
318 self.assertEqual(self.type2test(b'\xe2\x98\x83').decode(), '\u2603')
Christian Heimes510711d2008-01-30 11:57:58 +0000319
Victor Stinner22eb6892019-06-26 00:51:05 +0200320 def test_check_encoding_errors(self):
321 # bpo-37388: bytes(str) and bytes.encode() must check encoding
322 # and errors arguments in dev mode
323 invalid = 'Boom, Shaka Laka, Boom!'
324 encodings = ('ascii', 'utf8', 'latin1')
325 code = textwrap.dedent(f'''
326 import sys
327 type2test = {self.type2test.__name__}
328 encodings = {encodings!r}
329
330 for data in ('', 'short string'):
331 try:
332 type2test(data, encoding={invalid!r})
333 except LookupError:
334 pass
335 else:
336 sys.exit(21)
337
338 for encoding in encodings:
339 try:
340 type2test(data, encoding=encoding, errors={invalid!r})
341 except LookupError:
342 pass
343 else:
344 sys.exit(22)
345
346 for data in (b'', b'short string'):
347 data = type2test(data)
348 print(repr(data))
349 try:
350 data.decode(encoding={invalid!r})
351 except LookupError:
352 sys.exit(10)
353 else:
354 sys.exit(23)
355
356 try:
357 data.decode(errors={invalid!r})
358 except LookupError:
359 pass
360 else:
361 sys.exit(24)
362
363 for encoding in encodings:
364 try:
365 data.decode(encoding=encoding, errors={invalid!r})
366 except LookupError:
367 pass
368 else:
369 sys.exit(25)
370
371 sys.exit(10)
372 ''')
373 proc = assert_python_failure('-X', 'dev', '-c', code)
374 self.assertEqual(proc.rc, 10, proc)
375
Christian Heimes510711d2008-01-30 11:57:58 +0000376 def test_from_int(self):
377 b = self.type2test(0)
378 self.assertEqual(b, self.type2test())
379 b = self.type2test(10)
380 self.assertEqual(b, self.type2test([0]*10))
381 b = self.type2test(10000)
382 self.assertEqual(b, self.type2test([0]*10000))
383
384 def test_concat(self):
385 b1 = self.type2test(b"abc")
386 b2 = self.type2test(b"def")
387 self.assertEqual(b1 + b2, b"abcdef")
388 self.assertEqual(b1 + bytes(b"def"), b"abcdef")
389 self.assertEqual(bytes(b"def") + b1, b"defabc")
390 self.assertRaises(TypeError, lambda: b1 + "def")
391 self.assertRaises(TypeError, lambda: "abc" + b2)
392
393 def test_repeat(self):
394 for b in b"abc", self.type2test(b"abc"):
395 self.assertEqual(b * 3, b"abcabcabc")
396 self.assertEqual(b * 0, b"")
397 self.assertEqual(b * -1, b"")
398 self.assertRaises(TypeError, lambda: b * 3.14)
399 self.assertRaises(TypeError, lambda: 3.14 * b)
400 # XXX Shouldn't bytes and bytearray agree on what to raise?
Mark Dickinsoncf940c72010-08-10 18:35:01 +0000401 with self.assertRaises((OverflowError, MemoryError)):
402 c = b * sys.maxsize
403 with self.assertRaises((OverflowError, MemoryError)):
404 b *= sys.maxsize
Christian Heimes510711d2008-01-30 11:57:58 +0000405
406 def test_repeat_1char(self):
407 self.assertEqual(self.type2test(b'x')*100, self.type2test([ord('x')]*100))
408
409 def test_contains(self):
410 b = self.type2test(b"abc")
Benjamin Peterson577473f2010-01-19 00:09:57 +0000411 self.assertIn(ord('a'), b)
412 self.assertIn(int(ord('a')), b)
Ezio Melottib58e0bd2010-01-23 15:40:09 +0000413 self.assertNotIn(200, b)
Christian Heimes510711d2008-01-30 11:57:58 +0000414 self.assertRaises(ValueError, lambda: 300 in b)
415 self.assertRaises(ValueError, lambda: -1 in b)
Serhiy Storchakaf9efb8b2016-07-10 12:37:30 +0300416 self.assertRaises(ValueError, lambda: sys.maxsize+1 in b)
Christian Heimes510711d2008-01-30 11:57:58 +0000417 self.assertRaises(TypeError, lambda: None in b)
418 self.assertRaises(TypeError, lambda: float(ord('a')) in b)
419 self.assertRaises(TypeError, lambda: "a" in b)
420 for f in bytes, bytearray:
Benjamin Peterson577473f2010-01-19 00:09:57 +0000421 self.assertIn(f(b""), b)
422 self.assertIn(f(b"a"), b)
423 self.assertIn(f(b"b"), b)
424 self.assertIn(f(b"c"), b)
425 self.assertIn(f(b"ab"), b)
426 self.assertIn(f(b"bc"), b)
427 self.assertIn(f(b"abc"), b)
Ezio Melottib58e0bd2010-01-23 15:40:09 +0000428 self.assertNotIn(f(b"ac"), b)
429 self.assertNotIn(f(b"d"), b)
430 self.assertNotIn(f(b"dab"), b)
431 self.assertNotIn(f(b"abd"), b)
Christian Heimes510711d2008-01-30 11:57:58 +0000432
433 def test_fromhex(self):
434 self.assertRaises(TypeError, self.type2test.fromhex)
435 self.assertRaises(TypeError, self.type2test.fromhex, 1)
Ezio Melottib3aedd42010-11-20 19:04:17 +0000436 self.assertEqual(self.type2test.fromhex(''), self.type2test())
Christian Heimes510711d2008-01-30 11:57:58 +0000437 b = bytearray([0x1a, 0x2b, 0x30])
Ezio Melottib3aedd42010-11-20 19:04:17 +0000438 self.assertEqual(self.type2test.fromhex('1a2B30'), b)
439 self.assertEqual(self.type2test.fromhex(' 1A 2B 30 '), b)
Serhiy Storchakadd1da7f2016-12-19 18:51:37 +0200440
441 # check that ASCII whitespace is ignored
442 self.assertEqual(self.type2test.fromhex(' 1A\n2B\t30\v'), b)
443 for c in "\x09\x0A\x0B\x0C\x0D\x20":
444 self.assertEqual(self.type2test.fromhex(c), self.type2test())
445 for c in "\x1C\x1D\x1E\x1F\x85\xa0\u2000\u2002\u2028":
446 self.assertRaises(ValueError, self.type2test.fromhex, c)
447
Ezio Melottib3aedd42010-11-20 19:04:17 +0000448 self.assertEqual(self.type2test.fromhex('0000'), b'\0\0')
Christian Heimes510711d2008-01-30 11:57:58 +0000449 self.assertRaises(TypeError, self.type2test.fromhex, b'1B')
450 self.assertRaises(ValueError, self.type2test.fromhex, 'a')
451 self.assertRaises(ValueError, self.type2test.fromhex, 'rt')
452 self.assertRaises(ValueError, self.type2test.fromhex, '1a b cd')
453 self.assertRaises(ValueError, self.type2test.fromhex, '\x00')
454 self.assertRaises(ValueError, self.type2test.fromhex, '12 \x00 34')
455
Victor Stinner2bf89932015-10-14 11:25:33 +0200456 for data, pos in (
457 # invalid first hexadecimal character
458 ('12 x4 56', 3),
459 # invalid second hexadecimal character
460 ('12 3x 56', 4),
461 # two invalid hexadecimal characters
462 ('12 xy 56', 3),
463 # test non-ASCII string
464 ('12 3\xff 56', 4),
465 ):
466 with self.assertRaises(ValueError) as cm:
467 self.type2test.fromhex(data)
468 self.assertIn('at position %s' % pos, str(cm.exception))
469
Gregory P. Smith8cb65692015-04-25 23:22:26 +0000470 def test_hex(self):
471 self.assertRaises(TypeError, self.type2test.hex)
472 self.assertRaises(TypeError, self.type2test.hex, 1)
Gregory P. Smith32d34bc2015-04-26 05:05:53 +0000473 self.assertEqual(self.type2test(b"").hex(), "")
474 self.assertEqual(bytearray([0x1a, 0x2b, 0x30]).hex(), '1a2b30')
475 self.assertEqual(self.type2test(b"\x1a\x2b\x30").hex(), '1a2b30')
476 self.assertEqual(memoryview(b"\x1a\x2b\x30").hex(), '1a2b30')
Gregory P. Smith8cb65692015-04-25 23:22:26 +0000477
Gregory P. Smith0c2f9302019-05-29 11:46:58 -0700478 def test_hex_separator_basics(self):
479 three_bytes = self.type2test(b'\xb9\x01\xef')
480 self.assertEqual(three_bytes.hex(), 'b901ef')
481 with self.assertRaises(ValueError):
482 three_bytes.hex('')
483 with self.assertRaises(ValueError):
484 three_bytes.hex('xx')
485 self.assertEqual(three_bytes.hex(':', 0), 'b901ef')
486 with self.assertRaises(TypeError):
487 three_bytes.hex(None, 0)
488 with self.assertRaises(ValueError):
489 three_bytes.hex('\xff')
490 with self.assertRaises(ValueError):
491 three_bytes.hex(b'\xff')
492 with self.assertRaises(ValueError):
493 three_bytes.hex(b'\x80')
494 with self.assertRaises(ValueError):
495 three_bytes.hex(chr(0x100))
496 self.assertEqual(three_bytes.hex(':', 0), 'b901ef')
497 self.assertEqual(three_bytes.hex(b'\x00'), 'b9\x0001\x00ef')
498 self.assertEqual(three_bytes.hex('\x00'), 'b9\x0001\x00ef')
499 self.assertEqual(three_bytes.hex(b'\x7f'), 'b9\x7f01\x7fef')
500 self.assertEqual(three_bytes.hex('\x7f'), 'b9\x7f01\x7fef')
501 self.assertEqual(three_bytes.hex(':', 3), 'b901ef')
502 self.assertEqual(three_bytes.hex(':', 4), 'b901ef')
503 self.assertEqual(three_bytes.hex(':', -4), 'b901ef')
504 self.assertEqual(three_bytes.hex(':'), 'b9:01:ef')
505 self.assertEqual(three_bytes.hex(b'$'), 'b9$01$ef')
506 self.assertEqual(three_bytes.hex(':', 1), 'b9:01:ef')
507 self.assertEqual(three_bytes.hex(':', -1), 'b9:01:ef')
508 self.assertEqual(three_bytes.hex(':', 2), 'b9:01ef')
509 self.assertEqual(three_bytes.hex(':', 1), 'b9:01:ef')
510 self.assertEqual(three_bytes.hex('*', -2), 'b901*ef')
511
512 value = b'{s\005\000\000\000worldi\002\000\000\000s\005\000\000\000helloi\001\000\000\0000'
513 self.assertEqual(value.hex('.', 8), '7b7305000000776f.726c646902000000.730500000068656c.6c6f690100000030')
514
515 def test_hex_separator_five_bytes(self):
516 five_bytes = self.type2test(range(90,95))
517 self.assertEqual(five_bytes.hex(), '5a5b5c5d5e')
518
519 def test_hex_separator_six_bytes(self):
520 six_bytes = self.type2test(x*3 for x in range(1, 7))
521 self.assertEqual(six_bytes.hex(), '0306090c0f12')
522 self.assertEqual(six_bytes.hex('.', 1), '03.06.09.0c.0f.12')
523 self.assertEqual(six_bytes.hex(' ', 2), '0306 090c 0f12')
524 self.assertEqual(six_bytes.hex('-', 3), '030609-0c0f12')
525 self.assertEqual(six_bytes.hex(':', 4), '0306:090c0f12')
526 self.assertEqual(six_bytes.hex(':', 5), '03:06090c0f12')
527 self.assertEqual(six_bytes.hex(':', 6), '0306090c0f12')
528 self.assertEqual(six_bytes.hex(':', 95), '0306090c0f12')
529 self.assertEqual(six_bytes.hex('_', -3), '030609_0c0f12')
530 self.assertEqual(six_bytes.hex(':', -4), '0306090c:0f12')
531 self.assertEqual(six_bytes.hex(b'@', -5), '0306090c0f@12')
532 self.assertEqual(six_bytes.hex(':', -6), '0306090c0f12')
533 self.assertEqual(six_bytes.hex(' ', -95), '0306090c0f12')
534
Christian Heimes510711d2008-01-30 11:57:58 +0000535 def test_join(self):
536 self.assertEqual(self.type2test(b"").join([]), b"")
537 self.assertEqual(self.type2test(b"").join([b""]), b"")
538 for lst in [[b"abc"], [b"a", b"bc"], [b"ab", b"c"], [b"a", b"b", b"c"]]:
539 lst = list(map(self.type2test, lst))
540 self.assertEqual(self.type2test(b"").join(lst), b"abc")
541 self.assertEqual(self.type2test(b"").join(tuple(lst)), b"abc")
542 self.assertEqual(self.type2test(b"").join(iter(lst)), b"abc")
Antoine Pitroucfc22b42012-10-16 21:07:23 +0200543 dot_join = self.type2test(b".:").join
544 self.assertEqual(dot_join([b"ab", b"cd"]), b"ab.:cd")
545 self.assertEqual(dot_join([memoryview(b"ab"), b"cd"]), b"ab.:cd")
546 self.assertEqual(dot_join([b"ab", memoryview(b"cd")]), b"ab.:cd")
547 self.assertEqual(dot_join([bytearray(b"ab"), b"cd"]), b"ab.:cd")
548 self.assertEqual(dot_join([b"ab", bytearray(b"cd")]), b"ab.:cd")
549 # Stress it with many items
550 seq = [b"abc"] * 1000
551 expected = b"abc" + b".:abc" * 999
552 self.assertEqual(dot_join(seq), expected)
Benjamin Petersonc31f12d2014-09-28 12:56:42 -0400553 self.assertRaises(TypeError, self.type2test(b" ").join, None)
Antoine Pitroucfc22b42012-10-16 21:07:23 +0200554 # Error handling and cleanup when some item in the middle of the
555 # sequence has the wrong type.
556 with self.assertRaises(TypeError):
557 dot_join([bytearray(b"ab"), "cd", b"ef"])
558 with self.assertRaises(TypeError):
559 dot_join([memoryview(b"ab"), "cd", b"ef"])
Christian Heimes510711d2008-01-30 11:57:58 +0000560
Christian Heimes510711d2008-01-30 11:57:58 +0000561 def test_count(self):
562 b = self.type2test(b'mississippi')
Antoine Pitrouac65d962011-10-20 23:54:17 +0200563 i = 105
564 p = 112
565 w = 119
566
Christian Heimes510711d2008-01-30 11:57:58 +0000567 self.assertEqual(b.count(b'i'), 4)
568 self.assertEqual(b.count(b'ss'), 2)
569 self.assertEqual(b.count(b'w'), 0)
570
Antoine Pitrouac65d962011-10-20 23:54:17 +0200571 self.assertEqual(b.count(i), 4)
572 self.assertEqual(b.count(w), 0)
573
574 self.assertEqual(b.count(b'i', 6), 2)
575 self.assertEqual(b.count(b'p', 6), 2)
576 self.assertEqual(b.count(b'i', 1, 3), 1)
577 self.assertEqual(b.count(b'p', 7, 9), 1)
578
579 self.assertEqual(b.count(i, 6), 2)
580 self.assertEqual(b.count(p, 6), 2)
581 self.assertEqual(b.count(i, 1, 3), 1)
582 self.assertEqual(b.count(p, 7, 9), 1)
583
Christian Heimes510711d2008-01-30 11:57:58 +0000584 def test_startswith(self):
585 b = self.type2test(b'hello')
586 self.assertFalse(self.type2test().startswith(b"anything"))
587 self.assertTrue(b.startswith(b"hello"))
588 self.assertTrue(b.startswith(b"hel"))
589 self.assertTrue(b.startswith(b"h"))
590 self.assertFalse(b.startswith(b"hellow"))
591 self.assertFalse(b.startswith(b"ha"))
Ezio Melottif2b3f782011-04-26 06:40:59 +0300592 with self.assertRaises(TypeError) as cm:
Ezio Melottiba42fd52011-04-26 06:09:45 +0300593 b.startswith([b'h'])
Ezio Melottif2b3f782011-04-26 06:40:59 +0300594 exc = str(cm.exception)
Ezio Melottiba42fd52011-04-26 06:09:45 +0300595 self.assertIn('bytes', exc)
596 self.assertIn('tuple', exc)
Christian Heimes510711d2008-01-30 11:57:58 +0000597
598 def test_endswith(self):
599 b = self.type2test(b'hello')
600 self.assertFalse(bytearray().endswith(b"anything"))
601 self.assertTrue(b.endswith(b"hello"))
602 self.assertTrue(b.endswith(b"llo"))
603 self.assertTrue(b.endswith(b"o"))
604 self.assertFalse(b.endswith(b"whello"))
605 self.assertFalse(b.endswith(b"no"))
Ezio Melottif2b3f782011-04-26 06:40:59 +0300606 with self.assertRaises(TypeError) as cm:
Ezio Melottiba42fd52011-04-26 06:09:45 +0300607 b.endswith([b'o'])
Ezio Melottif2b3f782011-04-26 06:40:59 +0300608 exc = str(cm.exception)
Ezio Melottiba42fd52011-04-26 06:09:45 +0300609 self.assertIn('bytes', exc)
610 self.assertIn('tuple', exc)
Christian Heimes510711d2008-01-30 11:57:58 +0000611
612 def test_find(self):
613 b = self.type2test(b'mississippi')
Antoine Pitrouac65d962011-10-20 23:54:17 +0200614 i = 105
615 w = 119
616
Christian Heimes510711d2008-01-30 11:57:58 +0000617 self.assertEqual(b.find(b'ss'), 2)
Christian Heimes510711d2008-01-30 11:57:58 +0000618 self.assertEqual(b.find(b'w'), -1)
619 self.assertEqual(b.find(b'mississippian'), -1)
620
Antoine Pitrouac65d962011-10-20 23:54:17 +0200621 self.assertEqual(b.find(i), 1)
622 self.assertEqual(b.find(w), -1)
623
624 self.assertEqual(b.find(b'ss', 3), 5)
625 self.assertEqual(b.find(b'ss', 1, 7), 2)
626 self.assertEqual(b.find(b'ss', 1, 3), -1)
627
628 self.assertEqual(b.find(i, 6), 7)
629 self.assertEqual(b.find(i, 1, 3), 1)
630 self.assertEqual(b.find(w, 1, 3), -1)
631
Victor Stinnerf8eac002011-12-18 01:17:41 +0100632 for index in (-1, 256, sys.maxsize + 1):
633 self.assertRaisesRegex(
634 ValueError, r'byte must be in range\(0, 256\)',
635 b.find, index)
636
Christian Heimes510711d2008-01-30 11:57:58 +0000637 def test_rfind(self):
638 b = self.type2test(b'mississippi')
Antoine Pitrouac65d962011-10-20 23:54:17 +0200639 i = 105
640 w = 119
641
Christian Heimes510711d2008-01-30 11:57:58 +0000642 self.assertEqual(b.rfind(b'ss'), 5)
Christian Heimes510711d2008-01-30 11:57:58 +0000643 self.assertEqual(b.rfind(b'w'), -1)
644 self.assertEqual(b.rfind(b'mississippian'), -1)
645
Antoine Pitrouac65d962011-10-20 23:54:17 +0200646 self.assertEqual(b.rfind(i), 10)
647 self.assertEqual(b.rfind(w), -1)
648
649 self.assertEqual(b.rfind(b'ss', 3), 5)
650 self.assertEqual(b.rfind(b'ss', 0, 6), 2)
651
652 self.assertEqual(b.rfind(i, 1, 3), 1)
653 self.assertEqual(b.rfind(i, 3, 9), 7)
654 self.assertEqual(b.rfind(w, 1, 3), -1)
655
Christian Heimes510711d2008-01-30 11:57:58 +0000656 def test_index(self):
Antoine Pitrouac65d962011-10-20 23:54:17 +0200657 b = self.type2test(b'mississippi')
658 i = 105
659 w = 119
660
661 self.assertEqual(b.index(b'ss'), 2)
662 self.assertRaises(ValueError, b.index, b'w')
663 self.assertRaises(ValueError, b.index, b'mississippian')
664
665 self.assertEqual(b.index(i), 1)
666 self.assertRaises(ValueError, b.index, w)
667
668 self.assertEqual(b.index(b'ss', 3), 5)
669 self.assertEqual(b.index(b'ss', 1, 7), 2)
670 self.assertRaises(ValueError, b.index, b'ss', 1, 3)
671
672 self.assertEqual(b.index(i, 6), 7)
673 self.assertEqual(b.index(i, 1, 3), 1)
674 self.assertRaises(ValueError, b.index, w, 1, 3)
Christian Heimes510711d2008-01-30 11:57:58 +0000675
676 def test_rindex(self):
Antoine Pitrouac65d962011-10-20 23:54:17 +0200677 b = self.type2test(b'mississippi')
678 i = 105
679 w = 119
680
681 self.assertEqual(b.rindex(b'ss'), 5)
682 self.assertRaises(ValueError, b.rindex, b'w')
683 self.assertRaises(ValueError, b.rindex, b'mississippian')
684
685 self.assertEqual(b.rindex(i), 10)
686 self.assertRaises(ValueError, b.rindex, w)
687
688 self.assertEqual(b.rindex(b'ss', 3), 5)
689 self.assertEqual(b.rindex(b'ss', 0, 6), 2)
690
691 self.assertEqual(b.rindex(i, 1, 3), 1)
692 self.assertEqual(b.rindex(i, 3, 9), 7)
693 self.assertRaises(ValueError, b.rindex, w, 1, 3)
Christian Heimes510711d2008-01-30 11:57:58 +0000694
Ethan Furmanb95b5612015-01-23 20:05:18 -0800695 def test_mod(self):
Serhiy Storchakac9a59e62016-04-15 14:11:10 +0300696 b = self.type2test(b'hello, %b!')
Ethan Furmanb95b5612015-01-23 20:05:18 -0800697 orig = b
698 b = b % b'world'
699 self.assertEqual(b, b'hello, world!')
700 self.assertEqual(orig, b'hello, %b!')
701 self.assertFalse(b is orig)
Serhiy Storchakac9a59e62016-04-15 14:11:10 +0300702 b = self.type2test(b'%s / 100 = %d%%')
Ethan Furmanb95b5612015-01-23 20:05:18 -0800703 a = b % (b'seventy-nine', 79)
Serhiy Storchaka4e1942b2015-01-26 09:28:11 +0200704 self.assertEqual(a, b'seventy-nine / 100 = 79%')
Victor Stinnere914d412016-04-15 17:52:27 +0200705 self.assertIs(type(a), self.type2test)
Xiang Zhangb76ad512017-03-06 17:17:05 +0800706 # issue 29714
707 b = self.type2test(b'hello,\x00%b!')
708 b = b % b'world'
709 self.assertEqual(b, b'hello,\x00world!')
710 self.assertIs(type(b), self.type2test)
Ethan Furmanb95b5612015-01-23 20:05:18 -0800711
712 def test_imod(self):
Serhiy Storchakac9a59e62016-04-15 14:11:10 +0300713 b = self.type2test(b'hello, %b!')
Ethan Furmanb95b5612015-01-23 20:05:18 -0800714 orig = b
715 b %= b'world'
716 self.assertEqual(b, b'hello, world!')
717 self.assertEqual(orig, b'hello, %b!')
718 self.assertFalse(b is orig)
Serhiy Storchakac9a59e62016-04-15 14:11:10 +0300719 b = self.type2test(b'%s / 100 = %d%%')
Ethan Furmanb95b5612015-01-23 20:05:18 -0800720 b %= (b'seventy-nine', 79)
Serhiy Storchaka4e1942b2015-01-26 09:28:11 +0200721 self.assertEqual(b, b'seventy-nine / 100 = 79%')
Victor Stinnere914d412016-04-15 17:52:27 +0200722 self.assertIs(type(b), self.type2test)
Xiang Zhangb76ad512017-03-06 17:17:05 +0800723 # issue 29714
724 b = self.type2test(b'hello,\x00%b!')
725 b %= b'world'
726 self.assertEqual(b, b'hello,\x00world!')
727 self.assertIs(type(b), self.type2test)
Serhiy Storchakac9a59e62016-04-15 14:11:10 +0300728
729 def test_rmod(self):
730 with self.assertRaises(TypeError):
731 object() % self.type2test(b'abc')
732 self.assertIs(self.type2test(b'abc').__rmod__('%r'), NotImplemented)
Ethan Furmanb95b5612015-01-23 20:05:18 -0800733
Christian Heimes510711d2008-01-30 11:57:58 +0000734 def test_replace(self):
735 b = self.type2test(b'mississippi')
736 self.assertEqual(b.replace(b'i', b'a'), b'massassappa')
737 self.assertEqual(b.replace(b'ss', b'x'), b'mixixippi')
738
Serhiy Storchakaa2314282017-10-29 02:11:54 +0300739 def test_replace_int_error(self):
740 self.assertRaises(TypeError, self.type2test(b'a b').replace, 32, b'')
741
Christian Heimes510711d2008-01-30 11:57:58 +0000742 def test_split_string_error(self):
743 self.assertRaises(TypeError, self.type2test(b'a b').split, ' ')
Serhiy Storchakaa2314282017-10-29 02:11:54 +0300744 self.assertRaises(TypeError, self.type2test(b'a b').rsplit, ' ')
745
746 def test_split_int_error(self):
747 self.assertRaises(TypeError, self.type2test(b'a b').split, 32)
748 self.assertRaises(TypeError, self.type2test(b'a b').rsplit, 32)
Christian Heimes510711d2008-01-30 11:57:58 +0000749
Antoine Pitrouf8453022010-01-12 22:05:42 +0000750 def test_split_unicodewhitespace(self):
Martin Panter0d0db6c2016-04-10 08:45:26 +0000751 for b in (b'a\x1Cb', b'a\x1Db', b'a\x1Eb', b'a\x1Fb'):
752 b = self.type2test(b)
753 self.assertEqual(b.split(), [b])
Antoine Pitrouf8453022010-01-12 22:05:42 +0000754 b = self.type2test(b"\x09\x0A\x0B\x0C\x0D\x1C\x1D\x1E\x1F")
755 self.assertEqual(b.split(), [b'\x1c\x1d\x1e\x1f'])
756
Christian Heimes510711d2008-01-30 11:57:58 +0000757 def test_rsplit_unicodewhitespace(self):
758 b = self.type2test(b"\x09\x0A\x0B\x0C\x0D\x1C\x1D\x1E\x1F")
Christian Heimes510711d2008-01-30 11:57:58 +0000759 self.assertEqual(b.rsplit(), [b'\x1c\x1d\x1e\x1f'])
760
761 def test_partition(self):
762 b = self.type2test(b'mississippi')
763 self.assertEqual(b.partition(b'ss'), (b'mi', b'ss', b'issippi'))
Antoine Pitrouf8453022010-01-12 22:05:42 +0000764 self.assertEqual(b.partition(b'w'), (b'mississippi', b'', b''))
Christian Heimes510711d2008-01-30 11:57:58 +0000765
766 def test_rpartition(self):
767 b = self.type2test(b'mississippi')
768 self.assertEqual(b.rpartition(b'ss'), (b'missi', b'ss', b'ippi'))
769 self.assertEqual(b.rpartition(b'i'), (b'mississipp', b'i', b''))
Antoine Pitrouf8453022010-01-12 22:05:42 +0000770 self.assertEqual(b.rpartition(b'w'), (b'', b'', b'mississippi'))
Christian Heimes510711d2008-01-30 11:57:58 +0000771
Serhiy Storchakaa2314282017-10-29 02:11:54 +0300772 def test_partition_string_error(self):
773 self.assertRaises(TypeError, self.type2test(b'a b').partition, ' ')
774 self.assertRaises(TypeError, self.type2test(b'a b').rpartition, ' ')
775
776 def test_partition_int_error(self):
777 self.assertRaises(TypeError, self.type2test(b'a b').partition, 32)
778 self.assertRaises(TypeError, self.type2test(b'a b').rpartition, 32)
779
Christian Heimes510711d2008-01-30 11:57:58 +0000780 def test_pickling(self):
Hirokazu Yamamotod0d0b652008-10-23 00:38:15 +0000781 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
Christian Heimes510711d2008-01-30 11:57:58 +0000782 for b in b"", b"a", b"abc", b"\xffab\x80", b"\0\0\377\0\0":
783 b = self.type2test(b)
784 ps = pickle.dumps(b, proto)
785 q = pickle.loads(ps)
786 self.assertEqual(b, q)
787
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000788 def test_iterator_pickling(self):
Serhiy Storchakabad12572014-12-15 14:03:42 +0200789 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
790 for b in b"", b"a", b"abc", b"\xffab\x80", b"\0\0\377\0\0":
791 it = itorg = iter(self.type2test(b))
792 data = list(self.type2test(b))
793 d = pickle.dumps(it, proto)
794 it = pickle.loads(d)
795 self.assertEqual(type(itorg), type(it))
796 self.assertEqual(list(it), data)
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000797
Serhiy Storchakabad12572014-12-15 14:03:42 +0200798 it = pickle.loads(d)
Serhiy Storchakaaabafe72016-03-06 14:10:24 +0200799 if not b:
Serhiy Storchakabad12572014-12-15 14:03:42 +0200800 continue
Serhiy Storchakaaabafe72016-03-06 14:10:24 +0200801 next(it)
Serhiy Storchakabad12572014-12-15 14:03:42 +0200802 d = pickle.dumps(it, proto)
803 it = pickle.loads(d)
804 self.assertEqual(list(it), data[1:])
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000805
Christian Heimes510711d2008-01-30 11:57:58 +0000806 def test_strip_bytearray(self):
807 self.assertEqual(self.type2test(b'abc').strip(memoryview(b'ac')), b'b')
808 self.assertEqual(self.type2test(b'abc').lstrip(memoryview(b'ac')), b'bc')
809 self.assertEqual(self.type2test(b'abc').rstrip(memoryview(b'ac')), b'ab')
810
811 def test_strip_string_error(self):
Serhiy Storchakaa2314282017-10-29 02:11:54 +0300812 self.assertRaises(TypeError, self.type2test(b'abc').strip, 'ac')
813 self.assertRaises(TypeError, self.type2test(b'abc').lstrip, 'ac')
814 self.assertRaises(TypeError, self.type2test(b'abc').rstrip, 'ac')
815
816 def test_strip_int_error(self):
817 self.assertRaises(TypeError, self.type2test(b' abc ').strip, 32)
818 self.assertRaises(TypeError, self.type2test(b' abc ').lstrip, 32)
819 self.assertRaises(TypeError, self.type2test(b' abc ').rstrip, 32)
Christian Heimes510711d2008-01-30 11:57:58 +0000820
Eli Bendersky906b88f2011-07-29 07:05:08 +0300821 def test_center(self):
822 # Fill character can be either bytes or bytearray (issue 12380)
823 b = self.type2test(b'abc')
824 for fill_type in (bytes, bytearray):
825 self.assertEqual(b.center(7, fill_type(b'-')),
826 self.type2test(b'--abc--'))
827
828 def test_ljust(self):
829 # Fill character can be either bytes or bytearray (issue 12380)
830 b = self.type2test(b'abc')
831 for fill_type in (bytes, bytearray):
832 self.assertEqual(b.ljust(7, fill_type(b'-')),
833 self.type2test(b'abc----'))
834
835 def test_rjust(self):
836 # Fill character can be either bytes or bytearray (issue 12380)
837 b = self.type2test(b'abc')
838 for fill_type in (bytes, bytearray):
839 self.assertEqual(b.rjust(7, fill_type(b'-')),
840 self.type2test(b'----abc'))
841
Serhiy Storchakaa2314282017-10-29 02:11:54 +0300842 def test_xjust_int_error(self):
843 self.assertRaises(TypeError, self.type2test(b'abc').center, 7, 32)
844 self.assertRaises(TypeError, self.type2test(b'abc').ljust, 7, 32)
845 self.assertRaises(TypeError, self.type2test(b'abc').rjust, 7, 32)
846
Christian Heimes510711d2008-01-30 11:57:58 +0000847 def test_ord(self):
848 b = self.type2test(b'\0A\x7f\x80\xff')
849 self.assertEqual([ord(b[i:i+1]) for i in range(len(b))],
850 [0, 65, 127, 128, 255])
851
Georg Brandlabc38772009-04-12 15:51:51 +0000852 def test_maketrans(self):
853 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'
Georg Brandlabc38772009-04-12 15:51:51 +0000854 self.assertEqual(self.type2test.maketrans(b'abc', b'xyz'), transtable)
Antoine Pitrou403ce782009-10-14 17:14:16 +0000855 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'
856 self.assertEqual(self.type2test.maketrans(b'\375\376\377', b'xyz'), transtable)
Georg Brandlabc38772009-04-12 15:51:51 +0000857 self.assertRaises(ValueError, self.type2test.maketrans, b'abc', b'xyzq')
858 self.assertRaises(TypeError, self.type2test.maketrans, 'abc', 'def')
859
Jesus Ceaac451502011-04-20 17:09:23 +0200860 def test_none_arguments(self):
861 # issue 11828
862 b = self.type2test(b'hello')
863 l = self.type2test(b'l')
864 h = self.type2test(b'h')
865 x = self.type2test(b'x')
866 o = self.type2test(b'o')
867
868 self.assertEqual(2, b.find(l, None))
869 self.assertEqual(3, b.find(l, -2, None))
870 self.assertEqual(2, b.find(l, None, -2))
871 self.assertEqual(0, b.find(h, None, None))
872
873 self.assertEqual(3, b.rfind(l, None))
874 self.assertEqual(3, b.rfind(l, -2, None))
875 self.assertEqual(2, b.rfind(l, None, -2))
876 self.assertEqual(0, b.rfind(h, None, None))
877
878 self.assertEqual(2, b.index(l, None))
879 self.assertEqual(3, b.index(l, -2, None))
880 self.assertEqual(2, b.index(l, None, -2))
881 self.assertEqual(0, b.index(h, None, None))
882
883 self.assertEqual(3, b.rindex(l, None))
884 self.assertEqual(3, b.rindex(l, -2, None))
885 self.assertEqual(2, b.rindex(l, None, -2))
886 self.assertEqual(0, b.rindex(h, None, None))
887
888 self.assertEqual(2, b.count(l, None))
889 self.assertEqual(1, b.count(l, -2, None))
890 self.assertEqual(1, b.count(l, None, -2))
891 self.assertEqual(0, b.count(x, None, None))
892
893 self.assertEqual(True, b.endswith(o, None))
894 self.assertEqual(True, b.endswith(o, -2, None))
895 self.assertEqual(True, b.endswith(l, None, -2))
896 self.assertEqual(False, b.endswith(x, None, None))
897
898 self.assertEqual(True, b.startswith(h, None))
899 self.assertEqual(True, b.startswith(l, -2, None))
900 self.assertEqual(True, b.startswith(h, None, -2))
901 self.assertEqual(False, b.startswith(x, None, None))
902
Antoine Pitrouac65d962011-10-20 23:54:17 +0200903 def test_integer_arguments_out_of_byte_range(self):
904 b = self.type2test(b'hello')
905
906 for method in (b.count, b.find, b.index, b.rfind, b.rindex):
907 self.assertRaises(ValueError, method, -1)
908 self.assertRaises(ValueError, method, 256)
909 self.assertRaises(ValueError, method, 9999)
910
Jesus Ceaac451502011-04-20 17:09:23 +0200911 def test_find_etc_raise_correct_error_messages(self):
912 # issue 11828
913 b = self.type2test(b'hello')
914 x = self.type2test(b'x')
Ezio Melottiaf928422011-04-20 21:56:21 +0300915 self.assertRaisesRegex(TypeError, r'\bfind\b', b.find,
Jesus Ceaac451502011-04-20 17:09:23 +0200916 x, None, None, None)
Ezio Melottiaf928422011-04-20 21:56:21 +0300917 self.assertRaisesRegex(TypeError, r'\brfind\b', b.rfind,
Jesus Ceaac451502011-04-20 17:09:23 +0200918 x, None, None, None)
Ezio Melottiaf928422011-04-20 21:56:21 +0300919 self.assertRaisesRegex(TypeError, r'\bindex\b', b.index,
Jesus Ceaac451502011-04-20 17:09:23 +0200920 x, None, None, None)
Ezio Melottiaf928422011-04-20 21:56:21 +0300921 self.assertRaisesRegex(TypeError, r'\brindex\b', b.rindex,
Jesus Ceaac451502011-04-20 17:09:23 +0200922 x, None, None, None)
Ezio Melottiaf928422011-04-20 21:56:21 +0300923 self.assertRaisesRegex(TypeError, r'\bcount\b', b.count,
Jesus Ceaac451502011-04-20 17:09:23 +0200924 x, None, None, None)
Ezio Melottiaf928422011-04-20 21:56:21 +0300925 self.assertRaisesRegex(TypeError, r'\bstartswith\b', b.startswith,
Jesus Ceaac451502011-04-20 17:09:23 +0200926 x, None, None, None)
Ezio Melottiaf928422011-04-20 21:56:21 +0300927 self.assertRaisesRegex(TypeError, r'\bendswith\b', b.endswith,
Jesus Ceaac451502011-04-20 17:09:23 +0200928 x, None, None, None)
929
Serhiy Storchakafbb1c5e2016-03-30 20:40:02 +0300930 def test_free_after_iterating(self):
931 test.support.check_free_after_iterating(self, iter, self.type2test)
932 test.support.check_free_after_iterating(self, reversed, self.type2test)
933
Martin Panter1b6c6da2016-08-27 08:35:02 +0000934 def test_translate(self):
935 b = self.type2test(b'hello')
936 rosetta = bytearray(range(256))
937 rosetta[ord('o')] = ord('e')
938
939 self.assertRaises(TypeError, b.translate)
940 self.assertRaises(TypeError, b.translate, None, None)
941 self.assertRaises(ValueError, b.translate, bytes(range(255)))
942
943 c = b.translate(rosetta, b'hello')
944 self.assertEqual(b, b'hello')
945 self.assertIsInstance(c, self.type2test)
946
947 c = b.translate(rosetta)
948 d = b.translate(rosetta, b'')
949 self.assertEqual(c, d)
950 self.assertEqual(c, b'helle')
951
952 c = b.translate(rosetta, b'l')
953 self.assertEqual(c, b'hee')
954 c = b.translate(None, b'e')
955 self.assertEqual(c, b'hllo')
956
957 # test delete as a keyword argument
958 c = b.translate(rosetta, delete=b'')
959 self.assertEqual(c, b'helle')
960 c = b.translate(rosetta, delete=b'l')
961 self.assertEqual(c, b'hee')
962 c = b.translate(None, delete=b'e')
963 self.assertEqual(c, b'hllo')
964
Sergey Fedoseev92709a22019-09-09 21:28:34 +0500965 def test_sq_item(self):
966 _testcapi = test.support.import_module('_testcapi')
967 obj = self.type2test((42,))
968 with self.assertRaises(IndexError):
969 _testcapi.sequence_getitem(obj, -2)
970 with self.assertRaises(IndexError):
971 _testcapi.sequence_getitem(obj, 1)
972 self.assertEqual(_testcapi.sequence_getitem(obj, 0), 42)
973
Christian Heimes510711d2008-01-30 11:57:58 +0000974
Ezio Melotti0dceb562013-01-10 07:43:26 +0200975class BytesTest(BaseBytesTest, unittest.TestCase):
Christian Heimes510711d2008-01-30 11:57:58 +0000976 type2test = bytes
977
Terry Jan Reedyffff1442014-08-02 01:30:37 -0400978 def test_getitem_error(self):
Serhiy Storchaka8e79e6e2019-02-19 13:49:09 +0200979 b = b'python'
Terry Jan Reedyffff1442014-08-02 01:30:37 -0400980 msg = "byte indices must be integers or slices"
981 with self.assertRaisesRegex(TypeError, msg):
Serhiy Storchaka8e79e6e2019-02-19 13:49:09 +0200982 b['a']
Terry Jan Reedyffff1442014-08-02 01:30:37 -0400983
Antoine Pitrou2f89aa62008-08-02 21:02:48 +0000984 def test_buffer_is_readonly(self):
Victor Stinner76119642014-07-28 22:07:07 +0200985 fd = os.open(__file__, os.O_RDONLY)
Antoine Pitrou47d305d2008-08-16 23:28:44 +0000986 with open(fd, "rb", buffering=0) as f:
Antoine Pitrou2f89aa62008-08-02 21:02:48 +0000987 self.assertRaises(TypeError, f.readinto, b"")
988
Benjamin Petersonc15a0732008-08-26 16:46:47 +0000989 def test_custom(self):
990 class A:
991 def __bytes__(self):
992 return b'abc'
993 self.assertEqual(bytes(A()), b'abc')
994 class A: pass
995 self.assertRaises(TypeError, bytes, A())
996 class A:
997 def __bytes__(self):
998 return None
999 self.assertRaises(TypeError, bytes, A())
Benjamin Peterson5ff3f732012-12-19 15:27:41 -06001000 class A:
1001 def __bytes__(self):
1002 return b'a'
1003 def __index__(self):
1004 return 42
1005 self.assertEqual(bytes(A()), b'a')
Serhiy Storchaka5aac3ed2015-12-20 16:36:34 +02001006 # Issue #25766
1007 class A(str):
1008 def __bytes__(self):
1009 return b'abc'
1010 self.assertEqual(bytes(A('\u20ac')), b'abc')
1011 self.assertEqual(bytes(A('\u20ac'), 'iso8859-15'), b'\xa4')
Serhiy Storchaka15095802015-11-25 15:47:01 +02001012 # Issue #24731
1013 class A:
1014 def __bytes__(self):
1015 return OtherBytesSubclass(b'abc')
1016 self.assertEqual(bytes(A()), b'abc')
1017 self.assertIs(type(bytes(A())), OtherBytesSubclass)
1018 self.assertEqual(BytesSubclass(A()), b'abc')
1019 self.assertIs(type(BytesSubclass(A())), BytesSubclass)
Benjamin Petersonc15a0732008-08-26 16:46:47 +00001020
Victor Stinner29e762c2011-01-05 03:33:28 +00001021 # Test PyBytes_FromFormat()
1022 def test_from_format(self):
Victor Stinner7ab986d2015-10-14 02:55:12 +02001023 ctypes = test.support.import_module('ctypes')
Victor Stinner03dab782015-10-14 00:21:35 +02001024 _testcapi = test.support.import_module('_testcapi')
1025 from ctypes import pythonapi, py_object
1026 from ctypes import (
1027 c_int, c_uint,
1028 c_long, c_ulong,
1029 c_size_t, c_ssize_t,
1030 c_char_p)
1031
Victor Stinner29e762c2011-01-05 03:33:28 +00001032 PyBytes_FromFormat = pythonapi.PyBytes_FromFormat
1033 PyBytes_FromFormat.restype = py_object
1034
Victor Stinner03dab782015-10-14 00:21:35 +02001035 # basic tests
Victor Stinner29e762c2011-01-05 03:33:28 +00001036 self.assertEqual(PyBytes_FromFormat(b'format'),
1037 b'format')
Victor Stinner03dab782015-10-14 00:21:35 +02001038 self.assertEqual(PyBytes_FromFormat(b'Hello %s !', b'world'),
1039 b'Hello world !')
Victor Stinner29e762c2011-01-05 03:33:28 +00001040
Victor Stinner03dab782015-10-14 00:21:35 +02001041 # test formatters
1042 self.assertEqual(PyBytes_FromFormat(b'c=%c', c_int(0)),
1043 b'c=\0')
1044 self.assertEqual(PyBytes_FromFormat(b'c=%c', c_int(ord('@'))),
1045 b'c=@')
1046 self.assertEqual(PyBytes_FromFormat(b'c=%c', c_int(255)),
1047 b'c=\xff')
1048 self.assertEqual(PyBytes_FromFormat(b'd=%d ld=%ld zd=%zd',
1049 c_int(1), c_long(2),
1050 c_size_t(3)),
1051 b'd=1 ld=2 zd=3')
1052 self.assertEqual(PyBytes_FromFormat(b'd=%d ld=%ld zd=%zd',
1053 c_int(-1), c_long(-2),
1054 c_size_t(-3)),
1055 b'd=-1 ld=-2 zd=-3')
1056 self.assertEqual(PyBytes_FromFormat(b'u=%u lu=%lu zu=%zu',
1057 c_uint(123), c_ulong(456),
1058 c_size_t(789)),
1059 b'u=123 lu=456 zu=789')
1060 self.assertEqual(PyBytes_FromFormat(b'i=%i', c_int(123)),
1061 b'i=123')
1062 self.assertEqual(PyBytes_FromFormat(b'i=%i', c_int(-123)),
1063 b'i=-123')
1064 self.assertEqual(PyBytes_FromFormat(b'x=%x', c_int(0xabc)),
1065 b'x=abc')
Victor Stinner83ff8a62015-10-14 15:28:59 +02001066
1067 sizeof_ptr = ctypes.sizeof(c_char_p)
1068
1069 if os.name == 'nt':
1070 # Windows (MSCRT)
1071 ptr_format = '0x%0{}X'.format(2 * sizeof_ptr)
1072 def ptr_formatter(ptr):
1073 return (ptr_format % ptr)
1074 else:
1075 # UNIX (glibc)
1076 def ptr_formatter(ptr):
1077 return '%#x' % ptr
1078
Victor Stinner7ab986d2015-10-14 02:55:12 +02001079 ptr = 0xabcdef
Victor Stinner83ff8a62015-10-14 15:28:59 +02001080 self.assertEqual(PyBytes_FromFormat(b'ptr=%p', c_char_p(ptr)),
1081 ('ptr=' + ptr_formatter(ptr)).encode('ascii'))
Victor Stinner03dab782015-10-14 00:21:35 +02001082 self.assertEqual(PyBytes_FromFormat(b's=%s', c_char_p(b'cstr')),
1083 b's=cstr')
1084
1085 # test minimum and maximum integer values
1086 size_max = c_size_t(-1).value
1087 for formatstr, ctypes_type, value, py_formatter in (
1088 (b'%d', c_int, _testcapi.INT_MIN, str),
1089 (b'%d', c_int, _testcapi.INT_MAX, str),
1090 (b'%ld', c_long, _testcapi.LONG_MIN, str),
1091 (b'%ld', c_long, _testcapi.LONG_MAX, str),
1092 (b'%lu', c_ulong, _testcapi.ULONG_MAX, str),
1093 (b'%zd', c_ssize_t, _testcapi.PY_SSIZE_T_MIN, str),
1094 (b'%zd', c_ssize_t, _testcapi.PY_SSIZE_T_MAX, str),
1095 (b'%zu', c_size_t, size_max, str),
Victor Stinner83ff8a62015-10-14 15:28:59 +02001096 (b'%p', c_char_p, size_max, ptr_formatter),
Victor Stinner03dab782015-10-14 00:21:35 +02001097 ):
1098 self.assertEqual(PyBytes_FromFormat(formatstr, ctypes_type(value)),
1099 py_formatter(value).encode('ascii')),
1100
1101 # width and precision (width is currently ignored)
1102 self.assertEqual(PyBytes_FromFormat(b'%5s', b'a'),
1103 b'a')
1104 self.assertEqual(PyBytes_FromFormat(b'%.3s', b'abcdef'),
1105 b'abc')
1106
1107 # '%%' formatter
1108 self.assertEqual(PyBytes_FromFormat(b'%%'),
1109 b'%')
1110 self.assertEqual(PyBytes_FromFormat(b'[%%]'),
1111 b'[%]')
1112 self.assertEqual(PyBytes_FromFormat(b'%%%c', c_int(ord('_'))),
1113 b'%_')
1114 self.assertEqual(PyBytes_FromFormat(b'%%s'),
1115 b'%s')
1116
1117 # Invalid formats and partial formatting
Victor Stinner29e762c2011-01-05 03:33:28 +00001118 self.assertEqual(PyBytes_FromFormat(b'%'), b'%')
Victor Stinner03dab782015-10-14 00:21:35 +02001119 self.assertEqual(PyBytes_FromFormat(b'x=%i y=%', c_int(2), c_int(3)),
1120 b'x=2 y=%')
Victor Stinner29e762c2011-01-05 03:33:28 +00001121
Victor Stinner03dab782015-10-14 00:21:35 +02001122 # Issue #19969: %c must raise OverflowError for values
1123 # not in the range [0; 255]
Victor Stinnerc9362cf2013-12-13 12:14:44 +01001124 self.assertRaises(OverflowError,
1125 PyBytes_FromFormat, b'%c', c_int(-1))
1126 self.assertRaises(OverflowError,
1127 PyBytes_FromFormat, b'%c', c_int(256))
1128
Serhiy Storchaka44cc4822019-01-12 09:22:29 +02001129 # Issue #33817: empty strings
1130 self.assertEqual(PyBytes_FromFormat(b''),
1131 b'')
1132 self.assertEqual(PyBytes_FromFormat(b'%s', b''),
1133 b'')
1134
Guido van Rossum97c1adf2016-08-18 09:22:23 -07001135 def test_bytes_blocking(self):
1136 class IterationBlocked(list):
1137 __bytes__ = None
1138 i = [0, 1, 2, 3]
1139 self.assertEqual(bytes(i), b'\x00\x01\x02\x03')
1140 self.assertRaises(TypeError, bytes, IterationBlocked(i))
1141
1142 # At least in CPython, because bytes.__new__ and the C API
1143 # PyBytes_FromObject have different fallback rules, integer
1144 # fallback is handled specially, so test separately.
1145 class IntBlocked(int):
1146 __bytes__ = None
1147 self.assertEqual(bytes(3), b'\0\0\0')
1148 self.assertRaises(TypeError, bytes, IntBlocked(3))
1149
1150 # While there is no separately-defined rule for handling bytes
1151 # subclasses differently from other buffer-interface classes,
1152 # an implementation may well special-case them (as CPython 2.x
1153 # str did), so test them separately.
1154 class BytesSubclassBlocked(bytes):
1155 __bytes__ = None
1156 self.assertEqual(bytes(b'ab'), b'ab')
1157 self.assertRaises(TypeError, bytes, BytesSubclassBlocked(b'ab'))
1158
1159 class BufferBlocked(bytearray):
1160 __bytes__ = None
1161 ba, bb = bytearray(b'ab'), BufferBlocked(b'ab')
1162 self.assertEqual(bytes(ba), b'ab')
1163 self.assertRaises(TypeError, bytes, bb)
1164
Antoine Pitrou2f89aa62008-08-02 21:02:48 +00001165
Ezio Melotti0dceb562013-01-10 07:43:26 +02001166class ByteArrayTest(BaseBytesTest, unittest.TestCase):
Christian Heimes510711d2008-01-30 11:57:58 +00001167 type2test = bytearray
Guido van Rossumebea9be2007-04-09 00:49:13 +00001168
Terry Jan Reedyffff1442014-08-02 01:30:37 -04001169 def test_getitem_error(self):
Serhiy Storchaka8e79e6e2019-02-19 13:49:09 +02001170 b = bytearray(b'python')
Terry Jan Reedyffff1442014-08-02 01:30:37 -04001171 msg = "bytearray indices must be integers or slices"
1172 with self.assertRaisesRegex(TypeError, msg):
Serhiy Storchaka8e79e6e2019-02-19 13:49:09 +02001173 b['a']
Terry Jan Reedyffff1442014-08-02 01:30:37 -04001174
1175 def test_setitem_error(self):
Serhiy Storchaka8e79e6e2019-02-19 13:49:09 +02001176 b = bytearray(b'python')
Terry Jan Reedyffff1442014-08-02 01:30:37 -04001177 msg = "bytearray indices must be integers or slices"
1178 with self.assertRaisesRegex(TypeError, msg):
Terry Jan Reedyffff1442014-08-02 01:30:37 -04001179 b['a'] = "python"
1180
Guido van Rossum4dfe8a12006-04-22 23:28:04 +00001181 def test_nohash(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001182 self.assertRaises(TypeError, hash, bytearray())
Guido van Rossum4dfe8a12006-04-22 23:28:04 +00001183
Guido van Rossum254348e2007-11-21 19:29:53 +00001184 def test_bytearray_api(self):
Guido van Rossum75d6f1a2007-05-24 17:52:00 +00001185 short_sample = b"Hello world\n"
Guido van Rossum98297ee2007-11-06 21:34:58 +00001186 sample = short_sample + b"\0"*(20 - len(short_sample))
Guido van Rossumd624f182006-04-24 13:47:05 +00001187 tfn = tempfile.mktemp()
1188 try:
1189 # Prepare
1190 with open(tfn, "wb") as f:
1191 f.write(short_sample)
1192 # Test readinto
1193 with open(tfn, "rb") as f:
Guido van Rossum254348e2007-11-21 19:29:53 +00001194 b = bytearray(20)
Guido van Rossumd624f182006-04-24 13:47:05 +00001195 n = f.readinto(b)
1196 self.assertEqual(n, len(short_sample))
Guido van Rossumc1f779c2007-07-03 08:25:58 +00001197 self.assertEqual(list(b), list(sample))
Guido van Rossumd624f182006-04-24 13:47:05 +00001198 # Test writing in binary mode
1199 with open(tfn, "wb") as f:
1200 f.write(b)
1201 with open(tfn, "rb") as f:
1202 self.assertEqual(f.read(), sample)
Guido van Rossum13633bb2007-04-13 18:42:35 +00001203 # Text mode is ambiguous; don't test
Guido van Rossumd624f182006-04-24 13:47:05 +00001204 finally:
1205 try:
1206 os.remove(tfn)
Andrew Svetlov8b33dd82012-12-24 19:58:48 +02001207 except OSError:
Guido van Rossumd624f182006-04-24 13:47:05 +00001208 pass
1209
Neal Norwitz6968b052007-02-27 19:02:19 +00001210 def test_reverse(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001211 b = bytearray(b'hello')
Neal Norwitz6968b052007-02-27 19:02:19 +00001212 self.assertEqual(b.reverse(), None)
1213 self.assertEqual(b, b'olleh')
Guido van Rossum254348e2007-11-21 19:29:53 +00001214 b = bytearray(b'hello1') # test even number of items
Neal Norwitz6968b052007-02-27 19:02:19 +00001215 b.reverse()
1216 self.assertEqual(b, b'1olleh')
Guido van Rossum254348e2007-11-21 19:29:53 +00001217 b = bytearray()
Neal Norwitz6968b052007-02-27 19:02:19 +00001218 b.reverse()
1219 self.assertFalse(b)
1220
Eli Bendersky4db28d32011-03-03 18:21:02 +00001221 def test_clear(self):
1222 b = bytearray(b'python')
1223 b.clear()
1224 self.assertEqual(b, b'')
1225
1226 b = bytearray(b'')
1227 b.clear()
1228 self.assertEqual(b, b'')
1229
1230 b = bytearray(b'')
1231 b.append(ord('r'))
1232 b.clear()
1233 b.append(ord('p'))
1234 self.assertEqual(b, b'p')
1235
1236 def test_copy(self):
1237 b = bytearray(b'abc')
1238 bb = b.copy()
1239 self.assertEqual(bb, b'abc')
1240
1241 b = bytearray(b'')
1242 bb = b.copy()
1243 self.assertEqual(bb, b'')
1244
1245 # test that it's indeed a copy and not a reference
1246 b = bytearray(b'abc')
1247 bb = b.copy()
1248 self.assertEqual(b, bb)
1249 self.assertIsNot(b, bb)
1250 bb.append(ord('d'))
1251 self.assertEqual(bb, b'abcd')
1252 self.assertEqual(b, b'abc')
1253
Guido van Rossumd624f182006-04-24 13:47:05 +00001254 def test_regexps(self):
1255 def by(s):
Guido van Rossum254348e2007-11-21 19:29:53 +00001256 return bytearray(map(ord, s))
Guido van Rossumd624f182006-04-24 13:47:05 +00001257 b = by("Hello, world")
Antoine Pitroufd036452008-08-19 17:56:33 +00001258 self.assertEqual(re.findall(br"\w+", b), [by("Hello"), by("world")])
Guido van Rossumd624f182006-04-24 13:47:05 +00001259
1260 def test_setitem(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001261 b = bytearray([1, 2, 3])
Guido van Rossumd624f182006-04-24 13:47:05 +00001262 b[1] = 100
Guido van Rossum254348e2007-11-21 19:29:53 +00001263 self.assertEqual(b, bytearray([1, 100, 3]))
Guido van Rossumd624f182006-04-24 13:47:05 +00001264 b[-1] = 200
Guido van Rossum254348e2007-11-21 19:29:53 +00001265 self.assertEqual(b, bytearray([1, 100, 200]))
Georg Brandl9a54d7c2008-07-16 23:15:30 +00001266 b[0] = Indexable(10)
Guido van Rossum254348e2007-11-21 19:29:53 +00001267 self.assertEqual(b, bytearray([10, 100, 200]))
Guido van Rossumd624f182006-04-24 13:47:05 +00001268 try:
1269 b[3] = 0
1270 self.fail("Didn't raise IndexError")
1271 except IndexError:
1272 pass
1273 try:
1274 b[-10] = 0
1275 self.fail("Didn't raise IndexError")
1276 except IndexError:
1277 pass
1278 try:
1279 b[0] = 256
1280 self.fail("Didn't raise ValueError")
1281 except ValueError:
1282 pass
1283 try:
Georg Brandl9a54d7c2008-07-16 23:15:30 +00001284 b[0] = Indexable(-1)
Guido van Rossumd624f182006-04-24 13:47:05 +00001285 self.fail("Didn't raise ValueError")
1286 except ValueError:
1287 pass
1288 try:
1289 b[0] = None
1290 self.fail("Didn't raise TypeError")
1291 except TypeError:
1292 pass
1293
1294 def test_delitem(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001295 b = bytearray(range(10))
Guido van Rossumd624f182006-04-24 13:47:05 +00001296 del b[0]
Guido van Rossum254348e2007-11-21 19:29:53 +00001297 self.assertEqual(b, bytearray(range(1, 10)))
Guido van Rossumd624f182006-04-24 13:47:05 +00001298 del b[-1]
Guido van Rossum254348e2007-11-21 19:29:53 +00001299 self.assertEqual(b, bytearray(range(1, 9)))
Guido van Rossumd624f182006-04-24 13:47:05 +00001300 del b[4]
Guido van Rossum254348e2007-11-21 19:29:53 +00001301 self.assertEqual(b, bytearray([1, 2, 3, 4, 6, 7, 8]))
Guido van Rossumd624f182006-04-24 13:47:05 +00001302
1303 def test_setslice(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001304 b = bytearray(range(10))
Guido van Rossumd624f182006-04-24 13:47:05 +00001305 self.assertEqual(list(b), list(range(10)))
1306
Guido van Rossum254348e2007-11-21 19:29:53 +00001307 b[0:5] = bytearray([1, 1, 1, 1, 1])
1308 self.assertEqual(b, bytearray([1, 1, 1, 1, 1, 5, 6, 7, 8, 9]))
Guido van Rossumd624f182006-04-24 13:47:05 +00001309
1310 del b[0:-5]
Guido van Rossum254348e2007-11-21 19:29:53 +00001311 self.assertEqual(b, bytearray([5, 6, 7, 8, 9]))
Guido van Rossumd624f182006-04-24 13:47:05 +00001312
Guido van Rossum254348e2007-11-21 19:29:53 +00001313 b[0:0] = bytearray([0, 1, 2, 3, 4])
1314 self.assertEqual(b, bytearray(range(10)))
Guido van Rossumd624f182006-04-24 13:47:05 +00001315
Guido van Rossum254348e2007-11-21 19:29:53 +00001316 b[-7:-3] = bytearray([100, 101])
1317 self.assertEqual(b, bytearray([0, 1, 2, 100, 101, 7, 8, 9]))
Guido van Rossumd624f182006-04-24 13:47:05 +00001318
1319 b[3:5] = [3, 4, 5, 6]
Guido van Rossum254348e2007-11-21 19:29:53 +00001320 self.assertEqual(b, bytearray(range(10)))
Guido van Rossumad7d8d12007-04-13 01:39:34 +00001321
Thomas Wouters9a6e62b2006-08-23 23:20:29 +00001322 b[3:0] = [42, 42, 42]
Guido van Rossum254348e2007-11-21 19:29:53 +00001323 self.assertEqual(b, bytearray([0, 1, 2, 42, 42, 42, 3, 4, 5, 6, 7, 8, 9]))
Guido van Rossumd624f182006-04-24 13:47:05 +00001324
Ezio Melottic64bcbe2012-11-03 21:19:06 +02001325 b[3:] = b'foo'
1326 self.assertEqual(b, bytearray([0, 1, 2, 102, 111, 111]))
1327
1328 b[:3] = memoryview(b'foo')
1329 self.assertEqual(b, bytearray([102, 111, 111, 102, 111, 111]))
1330
1331 b[3:4] = []
1332 self.assertEqual(b, bytearray([102, 111, 111, 111, 111]))
1333
1334 for elem in [5, -5, 0, int(10e20), 'str', 2.3,
1335 ['a', 'b'], [b'a', b'b'], [[]]]:
1336 with self.assertRaises(TypeError):
1337 b[3:4] = elem
1338
1339 for elem in [[254, 255, 256], [-256, 9000]]:
1340 with self.assertRaises(ValueError):
1341 b[3:4] = elem
1342
Antoine Pitrou5df8a8a2013-10-05 21:12:18 +02001343 def test_setslice_extend(self):
1344 # Exercise the resizing logic (see issue #19087)
1345 b = bytearray(range(100))
1346 self.assertEqual(list(b), list(range(100)))
1347 del b[:10]
1348 self.assertEqual(list(b), list(range(10, 100)))
1349 b.extend(range(100, 110))
1350 self.assertEqual(list(b), list(range(10, 110)))
1351
Antoine Pitrou25454112015-05-19 20:52:27 +02001352 def test_fifo_overrun(self):
1353 # Test for issue #23985, a buffer overrun when implementing a FIFO
1354 # Build Python in pydebug mode for best results.
1355 b = bytearray(10)
1356 b.pop() # Defeat expanding buffer off-by-one quirk
1357 del b[:1] # Advance start pointer without reallocating
1358 b += bytes(2) # Append exactly the number of deleted bytes
1359 del b # Free memory buffer, allowing pydebug verification
1360
1361 def test_del_expand(self):
1362 # Reducing the size should not expand the buffer (issue #23985)
1363 b = bytearray(10)
1364 size = sys.getsizeof(b)
1365 del b[:1]
1366 self.assertLessEqual(sys.getsizeof(b), size)
1367
Thomas Wouters376446d2006-12-19 08:30:14 +00001368 def test_extended_set_del_slice(self):
Zackery Spytz14514d92019-05-17 01:13:03 -06001369 indices = (0, None, 1, 3, 19, 300, 1<<333, sys.maxsize,
1370 -1, -2, -31, -300)
Thomas Wouters376446d2006-12-19 08:30:14 +00001371 for start in indices:
1372 for stop in indices:
1373 # Skip invalid step 0
1374 for step in indices[1:]:
1375 L = list(range(255))
Guido van Rossum254348e2007-11-21 19:29:53 +00001376 b = bytearray(L)
Thomas Wouters376446d2006-12-19 08:30:14 +00001377 # Make sure we have a slice of exactly the right length,
1378 # but with different data.
1379 data = L[start:stop:step]
1380 data.reverse()
1381 L[start:stop:step] = data
1382 b[start:stop:step] = data
Ezio Melottib3aedd42010-11-20 19:04:17 +00001383 self.assertEqual(b, bytearray(L))
Guido van Rossumad7d8d12007-04-13 01:39:34 +00001384
Thomas Wouters376446d2006-12-19 08:30:14 +00001385 del L[start:stop:step]
1386 del b[start:stop:step]
Ezio Melottib3aedd42010-11-20 19:04:17 +00001387 self.assertEqual(b, bytearray(L))
Thomas Wouters376446d2006-12-19 08:30:14 +00001388
Guido van Rossumd624f182006-04-24 13:47:05 +00001389 def test_setslice_trap(self):
1390 # This test verifies that we correctly handle assigning self
1391 # to a slice of self (the old Lambert Meertens trap).
Guido van Rossum254348e2007-11-21 19:29:53 +00001392 b = bytearray(range(256))
Guido van Rossumd624f182006-04-24 13:47:05 +00001393 b[8:] = b
Guido van Rossum254348e2007-11-21 19:29:53 +00001394 self.assertEqual(b, bytearray(list(range(8)) + list(range(256))))
Guido van Rossumd624f182006-04-24 13:47:05 +00001395
Guido van Rossum13e57212006-04-27 22:54:26 +00001396 def test_iconcat(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001397 b = bytearray(b"abc")
Guido van Rossum13e57212006-04-27 22:54:26 +00001398 b1 = b
Guido van Rossum9c627722007-08-27 18:31:48 +00001399 b += b"def"
1400 self.assertEqual(b, b"abcdef")
Guido van Rossum13e57212006-04-27 22:54:26 +00001401 self.assertEqual(b, b1)
Serhiy Storchaka604e74c2017-03-27 13:59:07 +03001402 self.assertIs(b, b1)
Guido van Rossum98297ee2007-11-06 21:34:58 +00001403 b += b"xyz"
Guido van Rossumad7d8d12007-04-13 01:39:34 +00001404 self.assertEqual(b, b"abcdefxyz")
1405 try:
Guido van Rossumef87d6e2007-05-02 19:09:54 +00001406 b += ""
Guido van Rossumad7d8d12007-04-13 01:39:34 +00001407 except TypeError:
1408 pass
1409 else:
1410 self.fail("bytes += unicode didn't raise TypeError")
Guido van Rossum13e57212006-04-27 22:54:26 +00001411
1412 def test_irepeat(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001413 b = bytearray(b"abc")
Guido van Rossum13e57212006-04-27 22:54:26 +00001414 b1 = b
1415 b *= 3
Guido van Rossum9c627722007-08-27 18:31:48 +00001416 self.assertEqual(b, b"abcabcabc")
Guido van Rossum13e57212006-04-27 22:54:26 +00001417 self.assertEqual(b, b1)
Serhiy Storchaka604e74c2017-03-27 13:59:07 +03001418 self.assertIs(b, b1)
Guido van Rossum13e57212006-04-27 22:54:26 +00001419
1420 def test_irepeat_1char(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001421 b = bytearray(b"x")
Guido van Rossum13e57212006-04-27 22:54:26 +00001422 b1 = b
1423 b *= 100
Guido van Rossum98297ee2007-11-06 21:34:58 +00001424 self.assertEqual(b, b"x"*100)
Guido van Rossum13e57212006-04-27 22:54:26 +00001425 self.assertEqual(b, b1)
Serhiy Storchaka604e74c2017-03-27 13:59:07 +03001426 self.assertIs(b, b1)
Guido van Rossum13e57212006-04-27 22:54:26 +00001427
Guido van Rossum20188312006-05-05 15:15:40 +00001428 def test_alloc(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001429 b = bytearray()
Guido van Rossum20188312006-05-05 15:15:40 +00001430 alloc = b.__alloc__()
Serhiy Storchaka604e74c2017-03-27 13:59:07 +03001431 self.assertGreaterEqual(alloc, 0)
Guido van Rossum20188312006-05-05 15:15:40 +00001432 seq = [alloc]
1433 for i in range(100):
Guido van Rossum9c627722007-08-27 18:31:48 +00001434 b += b"x"
Guido van Rossum20188312006-05-05 15:15:40 +00001435 alloc = b.__alloc__()
Serhiy Storchaka7b6e3b92015-06-29 21:14:06 +03001436 self.assertGreater(alloc, len(b)) # including trailing null byte
Guido van Rossum20188312006-05-05 15:15:40 +00001437 if alloc not in seq:
1438 seq.append(alloc)
Guido van Rossum20188312006-05-05 15:15:40 +00001439
Serhiy Storchaka7b6e3b92015-06-29 21:14:06 +03001440 def test_init_alloc(self):
1441 b = bytearray()
1442 def g():
1443 for i in range(1, 100):
1444 yield i
1445 a = list(b)
1446 self.assertEqual(a, list(range(1, len(a)+1)))
1447 self.assertEqual(len(b), len(a))
1448 self.assertLessEqual(len(b), i)
1449 alloc = b.__alloc__()
1450 self.assertGreater(alloc, len(b)) # including trailing null byte
1451 b.__init__(g())
1452 self.assertEqual(list(b), list(range(1, 100)))
1453 self.assertEqual(len(b), 99)
1454 alloc = b.__alloc__()
1455 self.assertGreater(alloc, len(b))
1456
Neal Norwitz6968b052007-02-27 19:02:19 +00001457 def test_extend(self):
1458 orig = b'hello'
Guido van Rossum254348e2007-11-21 19:29:53 +00001459 a = bytearray(orig)
Neal Norwitz6968b052007-02-27 19:02:19 +00001460 a.extend(a)
1461 self.assertEqual(a, orig + orig)
1462 self.assertEqual(a[5:], orig)
Alexandre Vassalotti09121e82007-12-04 05:51:13 +00001463 a = bytearray(b'')
1464 # Test iterators that don't have a __length_hint__
1465 a.extend(map(int, orig * 25))
1466 a.extend(int(x) for x in orig * 25)
1467 self.assertEqual(a, orig * 50)
1468 self.assertEqual(a[-5:], orig)
1469 a = bytearray(b'')
1470 a.extend(iter(map(int, orig * 50)))
1471 self.assertEqual(a, orig * 50)
1472 self.assertEqual(a[-5:], orig)
1473 a = bytearray(b'')
1474 a.extend(list(map(int, orig * 50)))
1475 self.assertEqual(a, orig * 50)
1476 self.assertEqual(a[-5:], orig)
1477 a = bytearray(b'')
1478 self.assertRaises(ValueError, a.extend, [0, 1, 2, 256])
1479 self.assertRaises(ValueError, a.extend, [0, 1, 2, -1])
1480 self.assertEqual(len(a), 0)
Georg Brandl9a54d7c2008-07-16 23:15:30 +00001481 a = bytearray(b'')
1482 a.extend([Indexable(ord('a'))])
1483 self.assertEqual(a, b'a')
Guido van Rossumad7d8d12007-04-13 01:39:34 +00001484
Neal Norwitz6968b052007-02-27 19:02:19 +00001485 def test_remove(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001486 b = bytearray(b'hello')
Neal Norwitz6968b052007-02-27 19:02:19 +00001487 b.remove(ord('l'))
1488 self.assertEqual(b, b'helo')
1489 b.remove(ord('l'))
1490 self.assertEqual(b, b'heo')
1491 self.assertRaises(ValueError, lambda: b.remove(ord('l')))
1492 self.assertRaises(ValueError, lambda: b.remove(400))
Gregory P. Smith60d241f2007-10-16 06:31:30 +00001493 self.assertRaises(TypeError, lambda: b.remove('e'))
Neal Norwitz6968b052007-02-27 19:02:19 +00001494 # remove first and last
1495 b.remove(ord('o'))
1496 b.remove(ord('h'))
1497 self.assertEqual(b, b'e')
Gregory P. Smith60d241f2007-10-16 06:31:30 +00001498 self.assertRaises(TypeError, lambda: b.remove(b'e'))
Georg Brandl9a54d7c2008-07-16 23:15:30 +00001499 b.remove(Indexable(ord('e')))
1500 self.assertEqual(b, b'')
Neal Norwitz6968b052007-02-27 19:02:19 +00001501
Serhiy Storchaka7bf36da2016-05-16 22:15:38 +03001502 # test values outside of the ascii range: (0, 127)
1503 c = bytearray([126, 127, 128, 129])
1504 c.remove(127)
1505 self.assertEqual(c, bytes([126, 128, 129]))
1506 c.remove(129)
1507 self.assertEqual(c, bytes([126, 128]))
1508
Neal Norwitz6968b052007-02-27 19:02:19 +00001509 def test_pop(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001510 b = bytearray(b'world')
Neal Norwitz6968b052007-02-27 19:02:19 +00001511 self.assertEqual(b.pop(), ord('d'))
1512 self.assertEqual(b.pop(0), ord('w'))
1513 self.assertEqual(b.pop(-2), ord('r'))
1514 self.assertRaises(IndexError, lambda: b.pop(10))
Eli Bendersky1bc4f192011-03-04 04:55:25 +00001515 self.assertRaises(IndexError, lambda: bytearray().pop())
Mark Dickinson54a3db92009-09-06 10:19:23 +00001516 # test for issue #6846
1517 self.assertEqual(bytearray(b'\xff').pop(), 0xff)
Neal Norwitz6968b052007-02-27 19:02:19 +00001518
1519 def test_nosort(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001520 self.assertRaises(AttributeError, lambda: bytearray().sort())
Neal Norwitz6968b052007-02-27 19:02:19 +00001521
Neal Norwitz6968b052007-02-27 19:02:19 +00001522 def test_append(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001523 b = bytearray(b'hell')
Neal Norwitz6968b052007-02-27 19:02:19 +00001524 b.append(ord('o'))
1525 self.assertEqual(b, b'hello')
1526 self.assertEqual(b.append(100), None)
Guido van Rossum254348e2007-11-21 19:29:53 +00001527 b = bytearray()
Neal Norwitz6968b052007-02-27 19:02:19 +00001528 b.append(ord('A'))
1529 self.assertEqual(len(b), 1)
Gregory P. Smith60d241f2007-10-16 06:31:30 +00001530 self.assertRaises(TypeError, lambda: b.append(b'o'))
Georg Brandl9a54d7c2008-07-16 23:15:30 +00001531 b = bytearray()
1532 b.append(Indexable(ord('A')))
1533 self.assertEqual(b, b'A')
Neal Norwitz6968b052007-02-27 19:02:19 +00001534
1535 def test_insert(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001536 b = bytearray(b'msssspp')
Neal Norwitz6968b052007-02-27 19:02:19 +00001537 b.insert(1, ord('i'))
1538 b.insert(4, ord('i'))
1539 b.insert(-2, ord('i'))
1540 b.insert(1000, ord('i'))
1541 self.assertEqual(b, b'mississippi')
Gregory P. Smith60d241f2007-10-16 06:31:30 +00001542 self.assertRaises(TypeError, lambda: b.insert(0, b'1'))
Georg Brandl9a54d7c2008-07-16 23:15:30 +00001543 b = bytearray()
1544 b.insert(0, Indexable(ord('A')))
1545 self.assertEqual(b, b'A')
Neal Norwitz6968b052007-02-27 19:02:19 +00001546
Benjamin Peterson0f3641c2008-11-19 22:05:52 +00001547 def test_copied(self):
1548 # Issue 4348. Make sure that operations that don't mutate the array
1549 # copy the bytes.
1550 b = bytearray(b'abc')
Serhiy Storchaka604e74c2017-03-27 13:59:07 +03001551 self.assertIsNot(b, b.replace(b'abc', b'cde', 0))
Benjamin Peterson0f3641c2008-11-19 22:05:52 +00001552
1553 t = bytearray([i for i in range(256)])
1554 x = bytearray(b'')
Serhiy Storchaka604e74c2017-03-27 13:59:07 +03001555 self.assertIsNot(x, x.translate(t))
Benjamin Peterson0f3641c2008-11-19 22:05:52 +00001556
Guido van Rossum254348e2007-11-21 19:29:53 +00001557 def test_partition_bytearray_doesnt_share_nullstring(self):
1558 a, b, c = bytearray(b"x").partition(b"y")
Guido van Rossum98297ee2007-11-06 21:34:58 +00001559 self.assertEqual(b, b"")
1560 self.assertEqual(c, b"")
Serhiy Storchaka604e74c2017-03-27 13:59:07 +03001561 self.assertIsNot(b, c)
Guido van Rossum98297ee2007-11-06 21:34:58 +00001562 b += b"!"
1563 self.assertEqual(c, b"")
Guido van Rossum254348e2007-11-21 19:29:53 +00001564 a, b, c = bytearray(b"x").partition(b"y")
Guido van Rossum98297ee2007-11-06 21:34:58 +00001565 self.assertEqual(b, b"")
1566 self.assertEqual(c, b"")
1567 # Same for rpartition
Guido van Rossum254348e2007-11-21 19:29:53 +00001568 b, c, a = bytearray(b"x").rpartition(b"y")
Guido van Rossum98297ee2007-11-06 21:34:58 +00001569 self.assertEqual(b, b"")
1570 self.assertEqual(c, b"")
Serhiy Storchaka604e74c2017-03-27 13:59:07 +03001571 self.assertIsNot(b, c)
Guido van Rossum98297ee2007-11-06 21:34:58 +00001572 b += b"!"
1573 self.assertEqual(c, b"")
Guido van Rossum254348e2007-11-21 19:29:53 +00001574 c, b, a = bytearray(b"x").rpartition(b"y")
Guido van Rossum98297ee2007-11-06 21:34:58 +00001575 self.assertEqual(b, b"")
1576 self.assertEqual(c, b"")
1577
Antoine Pitrou5504e892008-12-06 21:27:53 +00001578 def test_resize_forbidden(self):
1579 # #4509: can't resize a bytearray when there are buffer exports, even
1580 # if it wouldn't reallocate the underlying buffer.
1581 # Furthermore, no destructive changes to the buffer may be applied
1582 # before raising the error.
1583 b = bytearray(range(10))
1584 v = memoryview(b)
1585 def resize(n):
1586 b[1:-1] = range(n + 1, 2*n - 1)
1587 resize(10)
1588 orig = b[:]
1589 self.assertRaises(BufferError, resize, 11)
Ezio Melottib3aedd42010-11-20 19:04:17 +00001590 self.assertEqual(b, orig)
Antoine Pitrou5504e892008-12-06 21:27:53 +00001591 self.assertRaises(BufferError, resize, 9)
Ezio Melottib3aedd42010-11-20 19:04:17 +00001592 self.assertEqual(b, orig)
Antoine Pitrou5504e892008-12-06 21:27:53 +00001593 self.assertRaises(BufferError, resize, 0)
Ezio Melottib3aedd42010-11-20 19:04:17 +00001594 self.assertEqual(b, orig)
Antoine Pitrou5504e892008-12-06 21:27:53 +00001595 # Other operations implying resize
1596 self.assertRaises(BufferError, b.pop, 0)
Ezio Melottib3aedd42010-11-20 19:04:17 +00001597 self.assertEqual(b, orig)
Antoine Pitrou5504e892008-12-06 21:27:53 +00001598 self.assertRaises(BufferError, b.remove, b[1])
Ezio Melottib3aedd42010-11-20 19:04:17 +00001599 self.assertEqual(b, orig)
Antoine Pitrou5504e892008-12-06 21:27:53 +00001600 def delitem():
1601 del b[1]
1602 self.assertRaises(BufferError, delitem)
Ezio Melottib3aedd42010-11-20 19:04:17 +00001603 self.assertEqual(b, orig)
Antoine Pitrou5504e892008-12-06 21:27:53 +00001604 # deleting a non-contiguous slice
1605 def delslice():
1606 b[1:-1:2] = b""
1607 self.assertRaises(BufferError, delslice)
Ezio Melottib3aedd42010-11-20 19:04:17 +00001608 self.assertEqual(b, orig)
Guido van Rossum98297ee2007-11-06 21:34:58 +00001609
Stefan Krah650c1e82015-02-03 21:43:23 +01001610 @test.support.cpython_only
1611 def test_obsolete_write_lock(self):
1612 from _testcapi import getbuffer_with_null_view
1613 self.assertRaises(BufferError, getbuffer_with_null_view, bytearray())
Antoine Pitroufc8d6f42010-01-17 12:38:54 +00001614
Serhiy Storchakaaabafe72016-03-06 14:10:24 +02001615 def test_iterator_pickling2(self):
1616 orig = bytearray(b'abc')
1617 data = list(b'qwerty')
1618 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1619 # initial iterator
1620 itorig = iter(orig)
1621 d = pickle.dumps((itorig, orig), proto)
1622 it, b = pickle.loads(d)
1623 b[:] = data
1624 self.assertEqual(type(it), type(itorig))
1625 self.assertEqual(list(it), data)
1626
1627 # running iterator
1628 next(itorig)
1629 d = pickle.dumps((itorig, orig), proto)
1630 it, b = pickle.loads(d)
1631 b[:] = data
1632 self.assertEqual(type(it), type(itorig))
1633 self.assertEqual(list(it), data[1:])
1634
1635 # empty iterator
1636 for i in range(1, len(orig)):
1637 next(itorig)
1638 d = pickle.dumps((itorig, orig), proto)
1639 it, b = pickle.loads(d)
1640 b[:] = data
1641 self.assertEqual(type(it), type(itorig))
1642 self.assertEqual(list(it), data[len(orig):])
1643
1644 # exhausted iterator
1645 self.assertRaises(StopIteration, next, itorig)
1646 d = pickle.dumps((itorig, orig), proto)
1647 it, b = pickle.loads(d)
1648 b[:] = data
1649 self.assertEqual(list(it), [])
1650
Serhiy Storchaka8dc2ec12016-03-30 21:01:26 +03001651 test_exhausted_iterator = test.list_tests.CommonTest.test_exhausted_iterator
Serhiy Storchakaaabafe72016-03-06 14:10:24 +02001652
Serhiy Storchakaaf658722016-07-03 14:41:36 +03001653 def test_iterator_length_hint(self):
1654 # Issue 27443: __length_hint__ can return negative integer
1655 ba = bytearray(b'ab')
1656 it = iter(ba)
1657 next(it)
1658 ba.clear()
1659 # Shouldn't raise an error
1660 self.assertEqual(list(it), [])
1661
1662
Christian Heimes510711d2008-01-30 11:57:58 +00001663class AssortedBytesTest(unittest.TestCase):
1664 #
1665 # Test various combinations of bytes and bytearray
1666 #
1667
Florent Xiclunaedf5f0d2010-09-03 20:00:37 +00001668 @check_bytes_warnings
Christian Heimes510711d2008-01-30 11:57:58 +00001669 def test_repr_str(self):
Florent Xiclunaedf5f0d2010-09-03 20:00:37 +00001670 for f in str, repr:
1671 self.assertEqual(f(bytearray()), "bytearray(b'')")
1672 self.assertEqual(f(bytearray([0])), "bytearray(b'\\x00')")
1673 self.assertEqual(f(bytearray([0, 1, 254, 255])),
1674 "bytearray(b'\\x00\\x01\\xfe\\xff')")
1675 self.assertEqual(f(b"abc"), "b'abc'")
1676 self.assertEqual(f(b"'"), '''b"'"''') # '''
1677 self.assertEqual(f(b"'\""), r"""b'\'"'""") # '
Christian Heimes510711d2008-01-30 11:57:58 +00001678
Serhiy Storchakad1af5ef2016-10-30 19:33:54 +02001679 @check_bytes_warnings
1680 def test_format(self):
1681 for b in b'abc', bytearray(b'abc'):
1682 self.assertEqual(format(b), str(b))
1683 self.assertEqual(format(b, ''), str(b))
1684 with self.assertRaisesRegex(TypeError,
1685 r'\b%s\b' % re.escape(type(b).__name__)):
1686 format(b, 's')
1687
Christian Heimes510711d2008-01-30 11:57:58 +00001688 def test_compare_bytes_to_bytearray(self):
1689 self.assertEqual(b"abc" == bytes(b"abc"), True)
1690 self.assertEqual(b"ab" != bytes(b"abc"), True)
1691 self.assertEqual(b"ab" <= bytes(b"abc"), True)
1692 self.assertEqual(b"ab" < bytes(b"abc"), True)
1693 self.assertEqual(b"abc" >= bytes(b"ab"), True)
1694 self.assertEqual(b"abc" > bytes(b"ab"), True)
1695
1696 self.assertEqual(b"abc" != bytes(b"abc"), False)
1697 self.assertEqual(b"ab" == bytes(b"abc"), False)
1698 self.assertEqual(b"ab" > bytes(b"abc"), False)
1699 self.assertEqual(b"ab" >= bytes(b"abc"), False)
1700 self.assertEqual(b"abc" < bytes(b"ab"), False)
1701 self.assertEqual(b"abc" <= bytes(b"ab"), False)
1702
1703 self.assertEqual(bytes(b"abc") == b"abc", True)
1704 self.assertEqual(bytes(b"ab") != b"abc", True)
1705 self.assertEqual(bytes(b"ab") <= b"abc", True)
1706 self.assertEqual(bytes(b"ab") < b"abc", True)
1707 self.assertEqual(bytes(b"abc") >= b"ab", True)
1708 self.assertEqual(bytes(b"abc") > b"ab", True)
1709
1710 self.assertEqual(bytes(b"abc") != b"abc", False)
1711 self.assertEqual(bytes(b"ab") == b"abc", False)
1712 self.assertEqual(bytes(b"ab") > b"abc", False)
1713 self.assertEqual(bytes(b"ab") >= b"abc", False)
1714 self.assertEqual(bytes(b"abc") < b"ab", False)
1715 self.assertEqual(bytes(b"abc") <= b"ab", False)
1716
Stefan Krah6e572b82013-01-26 13:06:36 +01001717 @test.support.requires_docstrings
Christian Heimes510711d2008-01-30 11:57:58 +00001718 def test_doc(self):
Florent Xicluna9b86b9a2010-03-19 19:00:44 +00001719 self.assertIsNotNone(bytearray.__doc__)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +00001720 self.assertTrue(bytearray.__doc__.startswith("bytearray("), bytearray.__doc__)
Florent Xicluna9b86b9a2010-03-19 19:00:44 +00001721 self.assertIsNotNone(bytes.__doc__)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +00001722 self.assertTrue(bytes.__doc__.startswith("bytes("), bytes.__doc__)
Christian Heimes510711d2008-01-30 11:57:58 +00001723
1724 def test_from_bytearray(self):
1725 sample = bytes(b"Hello world\n\x80\x81\xfe\xff")
1726 buf = memoryview(sample)
1727 b = bytearray(buf)
1728 self.assertEqual(b, bytearray(sample))
1729
Florent Xiclunaedf5f0d2010-09-03 20:00:37 +00001730 @check_bytes_warnings
Christian Heimes510711d2008-01-30 11:57:58 +00001731 def test_to_str(self):
Florent Xiclunaedf5f0d2010-09-03 20:00:37 +00001732 self.assertEqual(str(b''), "b''")
1733 self.assertEqual(str(b'x'), "b'x'")
1734 self.assertEqual(str(b'\x80'), "b'\\x80'")
1735 self.assertEqual(str(bytearray(b'')), "bytearray(b'')")
1736 self.assertEqual(str(bytearray(b'x')), "bytearray(b'x')")
1737 self.assertEqual(str(bytearray(b'\x80')), "bytearray(b'\\x80')")
Christian Heimes510711d2008-01-30 11:57:58 +00001738
1739 def test_literal(self):
1740 tests = [
1741 (b"Wonderful spam", "Wonderful spam"),
1742 (br"Wonderful spam too", "Wonderful spam too"),
1743 (b"\xaa\x00\000\200", "\xaa\x00\000\200"),
1744 (br"\xaa\x00\000\200", r"\xaa\x00\000\200"),
1745 ]
1746 for b, s in tests:
1747 self.assertEqual(b, bytearray(s, 'latin-1'))
1748 for c in range(128, 256):
1749 self.assertRaises(SyntaxError, eval,
1750 'b"%s"' % chr(c))
1751
Christian Heimes510711d2008-01-30 11:57:58 +00001752 def test_split_bytearray(self):
1753 self.assertEqual(b'a b'.split(memoryview(b' ')), [b'a', b'b'])
1754
1755 def test_rsplit_bytearray(self):
1756 self.assertEqual(b'a b'.rsplit(memoryview(b' ')), [b'a', b'b'])
1757
Georg Brandleb2c9642008-05-30 12:05:02 +00001758 def test_return_self(self):
1759 # bytearray.replace must always return a new bytearray
1760 b = bytearray()
Serhiy Storchaka604e74c2017-03-27 13:59:07 +03001761 self.assertIsNot(b.replace(b'', b''), b)
Georg Brandleb2c9642008-05-30 12:05:02 +00001762
Serhiy Storchaka1dd49822015-03-20 16:54:57 +02001763 @unittest.skipUnless(sys.flags.bytes_warning,
1764 "BytesWarning is needed for this test: use -bb option")
Barry Warsaw9e9dcd62008-10-17 01:50:37 +00001765 def test_compare(self):
Serhiy Storchaka1dd49822015-03-20 16:54:57 +02001766 def bytes_warning():
1767 return test.support.check_warnings(('', BytesWarning))
1768 with bytes_warning():
1769 b'' == ''
1770 with bytes_warning():
1771 '' == b''
1772 with bytes_warning():
1773 b'' != ''
1774 with bytes_warning():
1775 '' != b''
1776 with bytes_warning():
1777 bytearray(b'') == ''
1778 with bytes_warning():
1779 '' == bytearray(b'')
1780 with bytes_warning():
1781 bytearray(b'') != ''
1782 with bytes_warning():
1783 '' != bytearray(b'')
1784 with bytes_warning():
1785 b'\0' == 0
1786 with bytes_warning():
1787 0 == b'\0'
1788 with bytes_warning():
1789 b'\0' != 0
1790 with bytes_warning():
1791 0 != b'\0'
Barry Warsaw9e9dcd62008-10-17 01:50:37 +00001792
Guido van Rossumd624f182006-04-24 13:47:05 +00001793 # Optimizations:
Guido van Rossume06b6b82006-04-23 07:43:54 +00001794 # __iter__? (optimization)
Guido van Rossumd624f182006-04-24 13:47:05 +00001795 # __reversed__? (optimization)
1796
Guido van Rossumad7d8d12007-04-13 01:39:34 +00001797 # XXX More string methods? (Those that don't use character properties)
1798
Neal Norwitz6968b052007-02-27 19:02:19 +00001799 # There are tests in string_tests.py that are more
Martin Panter0d0db6c2016-04-10 08:45:26 +00001800 # comprehensive for things like partition, etc.
Neal Norwitz6968b052007-02-27 19:02:19 +00001801 # Unfortunately they are all bundled with tests that
1802 # are not appropriate for bytes
Guido van Rossume06b6b82006-04-23 07:43:54 +00001803
Guido van Rossum254348e2007-11-21 19:29:53 +00001804 # I've started porting some of those into bytearray_tests.py, we should port
Gregory P. Smith60d241f2007-10-16 06:31:30 +00001805 # the rest that make sense (the code can be cleaned up to use modern
1806 # unittest methods at the same time).
1807
Martin Panter152a19c2016-04-06 06:37:17 +00001808class BytearrayPEP3137Test(unittest.TestCase):
Gregory P. Smith60d241f2007-10-16 06:31:30 +00001809 def marshal(self, x):
Guido van Rossum254348e2007-11-21 19:29:53 +00001810 return bytearray(x)
Gregory P. Smith60d241f2007-10-16 06:31:30 +00001811
1812 def test_returns_new_copy(self):
1813 val = self.marshal(b'1234')
1814 # On immutable types these MAY return a reference to themselves
Guido van Rossum254348e2007-11-21 19:29:53 +00001815 # but on mutable types like bytearray they MUST return a new copy.
Gregory P. Smith60d241f2007-10-16 06:31:30 +00001816 for methname in ('zfill', 'rjust', 'ljust', 'center'):
1817 method = getattr(val, methname)
1818 newval = method(3)
1819 self.assertEqual(val, newval)
Serhiy Storchaka604e74c2017-03-27 13:59:07 +03001820 self.assertIsNot(val, newval,
Gregory P. Smith60d241f2007-10-16 06:31:30 +00001821 methname+' returned self on a mutable object')
Antoine Pitroucbaa62502010-01-13 15:03:39 +00001822 for expr in ('val.split()[0]', 'val.rsplit()[0]',
1823 'val.partition(b".")[0]', 'val.rpartition(b".")[2]',
1824 'val.splitlines()[0]', 'val.replace(b"", b"")'):
1825 newval = eval(expr)
1826 self.assertEqual(val, newval)
Serhiy Storchaka604e74c2017-03-27 13:59:07 +03001827 self.assertIsNot(val, newval,
Antoine Pitroucbaa62502010-01-13 15:03:39 +00001828 expr+' returned val on a mutable object')
Antoine Pitroucfc22b42012-10-16 21:07:23 +02001829 sep = self.marshal(b'')
1830 newval = sep.join([val])
1831 self.assertEqual(val, newval)
1832 self.assertIsNot(val, newval)
1833
Guido van Rossum4dfe8a12006-04-22 23:28:04 +00001834
Christian Heimes510711d2008-01-30 11:57:58 +00001835class FixedStringTest(test.string_tests.BaseTest):
Guido van Rossum9c627722007-08-27 18:31:48 +00001836 def fixtype(self, obj):
1837 if isinstance(obj, str):
Martin Panter152a19c2016-04-06 06:37:17 +00001838 return self.type2test(obj.encode("utf-8"))
Guido van Rossum9c627722007-08-27 18:31:48 +00001839 return super().fixtype(obj)
1840
Martin Panter152a19c2016-04-06 06:37:17 +00001841 contains_bytes = True
1842
Ezio Melotti0dceb562013-01-10 07:43:26 +02001843class ByteArrayAsStringTest(FixedStringTest, unittest.TestCase):
Christian Heimes510711d2008-01-30 11:57:58 +00001844 type2test = bytearray
1845
Ezio Melotti0dceb562013-01-10 07:43:26 +02001846class BytesAsStringTest(FixedStringTest, unittest.TestCase):
Christian Heimes510711d2008-01-30 11:57:58 +00001847 type2test = bytes
1848
Georg Brandlc7885542007-03-06 19:16:20 +00001849
Ezio Melotti0dceb562013-01-10 07:43:26 +02001850class SubclassTest:
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001851
1852 def test_basic(self):
Serhiy Storchakae78592d2016-05-12 12:33:21 +03001853 self.assertTrue(issubclass(self.type2test, self.basetype))
1854 self.assertIsInstance(self.type2test(), self.basetype)
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001855
1856 a, b = b"abcd", b"efgh"
Serhiy Storchakae78592d2016-05-12 12:33:21 +03001857 _a, _b = self.type2test(a), self.type2test(b)
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001858
1859 # test comparison operators with subclass instances
Benjamin Petersonc9c0f202009-06-30 23:06:06 +00001860 self.assertTrue(_a == _a)
1861 self.assertTrue(_a != _b)
1862 self.assertTrue(_a < _b)
1863 self.assertTrue(_a <= _b)
1864 self.assertTrue(_b >= _a)
1865 self.assertTrue(_b > _a)
Serhiy Storchaka604e74c2017-03-27 13:59:07 +03001866 self.assertIsNot(_a, a)
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001867
1868 # test concat of subclass instances
1869 self.assertEqual(a + b, _a + _b)
1870 self.assertEqual(a + b, a + _b)
1871 self.assertEqual(a + b, _a + b)
1872
1873 # test repeat
Benjamin Petersonc9c0f202009-06-30 23:06:06 +00001874 self.assertTrue(a*5 == _a*5)
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001875
1876 def test_join(self):
1877 # Make sure join returns a NEW object for single item sequences
1878 # involving a subclass.
1879 # Make sure that it is of the appropriate type.
Serhiy Storchakae78592d2016-05-12 12:33:21 +03001880 s1 = self.type2test(b"abcd")
1881 s2 = self.basetype().join([s1])
Serhiy Storchaka604e74c2017-03-27 13:59:07 +03001882 self.assertIsNot(s1, s2)
1883 self.assertIs(type(s2), self.basetype, type(s2))
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001884
1885 # Test reverse, calling join on subclass
1886 s3 = s1.join([b"abcd"])
Serhiy Storchaka604e74c2017-03-27 13:59:07 +03001887 self.assertIs(type(s3), self.basetype)
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001888
1889 def test_pickle(self):
Serhiy Storchakae78592d2016-05-12 12:33:21 +03001890 a = self.type2test(b"abcd")
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001891 a.x = 10
Serhiy Storchakae78592d2016-05-12 12:33:21 +03001892 a.y = self.type2test(b"efgh")
Hirokazu Yamamotod0d0b652008-10-23 00:38:15 +00001893 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001894 b = pickle.loads(pickle.dumps(a, proto))
1895 self.assertNotEqual(id(a), id(b))
1896 self.assertEqual(a, b)
1897 self.assertEqual(a.x, b.x)
1898 self.assertEqual(a.y, b.y)
1899 self.assertEqual(type(a), type(b))
1900 self.assertEqual(type(a.y), type(b.y))
1901
1902 def test_copy(self):
Serhiy Storchakae78592d2016-05-12 12:33:21 +03001903 a = self.type2test(b"abcd")
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001904 a.x = 10
Serhiy Storchakae78592d2016-05-12 12:33:21 +03001905 a.y = self.type2test(b"efgh")
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001906 for copy_method in (copy.copy, copy.deepcopy):
1907 b = copy_method(a)
1908 self.assertNotEqual(id(a), id(b))
1909 self.assertEqual(a, b)
1910 self.assertEqual(a.x, b.x)
1911 self.assertEqual(a.y, b.y)
1912 self.assertEqual(type(a), type(b))
1913 self.assertEqual(type(a.y), type(b.y))
1914
Serhiy Storchaka0855e702016-07-01 17:22:31 +03001915 def test_fromhex(self):
1916 b = self.type2test.fromhex('1a2B30')
1917 self.assertEqual(b, b'\x1a\x2b\x30')
1918 self.assertIs(type(b), self.type2test)
1919
1920 class B1(self.basetype):
1921 def __new__(cls, value):
1922 me = self.basetype.__new__(cls, value)
1923 me.foo = 'bar'
1924 return me
1925
1926 b = B1.fromhex('1a2B30')
1927 self.assertEqual(b, b'\x1a\x2b\x30')
1928 self.assertIs(type(b), B1)
1929 self.assertEqual(b.foo, 'bar')
1930
1931 class B2(self.basetype):
1932 def __init__(me, *args, **kwargs):
1933 if self.basetype is not bytes:
1934 self.basetype.__init__(me, *args, **kwargs)
1935 me.foo = 'bar'
1936
1937 b = B2.fromhex('1a2B30')
1938 self.assertEqual(b, b'\x1a\x2b\x30')
1939 self.assertIs(type(b), B2)
1940 self.assertEqual(b.foo, 'bar')
Serhiy Storchakae78592d2016-05-12 12:33:21 +03001941
Alexandre Vassalotti41f58a72010-01-12 01:23:09 +00001942
1943class ByteArraySubclass(bytearray):
1944 pass
1945
1946class BytesSubclass(bytes):
1947 pass
1948
Serhiy Storchaka15095802015-11-25 15:47:01 +02001949class OtherBytesSubclass(bytes):
1950 pass
1951
Ezio Melotti0dceb562013-01-10 07:43:26 +02001952class ByteArraySubclassTest(SubclassTest, unittest.TestCase):
Serhiy Storchakae78592d2016-05-12 12:33:21 +03001953 basetype = bytearray
1954 type2test = ByteArraySubclass
Alexandre Vassalotti41f58a72010-01-12 01:23:09 +00001955
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001956 def test_init_override(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001957 class subclass(bytearray):
Alexandre Vassalotti41f58a72010-01-12 01:23:09 +00001958 def __init__(me, newarg=1, *args, **kwargs):
1959 bytearray.__init__(me, *args, **kwargs)
1960 x = subclass(4, b"abcd")
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001961 x = subclass(4, source=b"abcd")
1962 self.assertEqual(x, b"abcd")
1963 x = subclass(newarg=4, source=b"abcd")
1964 self.assertEqual(x, b"abcd")
1965
1966
Ezio Melotti0dceb562013-01-10 07:43:26 +02001967class BytesSubclassTest(SubclassTest, unittest.TestCase):
Serhiy Storchakae78592d2016-05-12 12:33:21 +03001968 basetype = bytes
1969 type2test = BytesSubclass
Alexandre Vassalotti41f58a72010-01-12 01:23:09 +00001970
1971
Guido van Rossum4dfe8a12006-04-22 23:28:04 +00001972if __name__ == "__main__":
Ezio Melotti0dceb562013-01-10 07:43:26 +02001973 unittest.main()