blob: a3ea40aa50f0d5aecde6c5d08823ca5c6f84e0d4 [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
3XXX This is a mess. Common tests should be moved to buffer_tests.py,
4which itself ought to be unified with string_tests.py (and the latter
5should be modernized).
6"""
Guido van Rossum4dfe8a12006-04-22 23:28:04 +00007
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
Barry Warsaw9e9dcd62008-10-17 01:50:37 +000012import operator
Guido van Rossum0ad08122007-04-11 04:37:43 +000013import pickle
Guido van Rossumd624f182006-04-24 13:47:05 +000014import tempfile
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000015import unittest
Guido van Rossum98297ee2007-11-06 21:34:58 +000016import warnings
Benjamin Petersonee8712c2008-05-20 21:35:26 +000017import test.support
Georg Brandlc7885542007-03-06 19:16:20 +000018import test.string_tests
Gregory P. Smith60d241f2007-10-16 06:31:30 +000019import test.buffer_tests
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000020
Georg Brandl9a54d7c2008-07-16 23:15:30 +000021class Indexable:
22 def __init__(self, value=0):
23 self.value = value
24 def __index__(self):
25 return self.value
26
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000027
Christian Heimes510711d2008-01-30 11:57:58 +000028class BaseBytesTest(unittest.TestCase):
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000029
Guido van Rossum98297ee2007-11-06 21:34:58 +000030 def setUp(self):
31 self.warning_filters = warnings.filters[:]
32
33 def tearDown(self):
34 warnings.filters = self.warning_filters
35
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000036 def test_basics(self):
Christian Heimes510711d2008-01-30 11:57:58 +000037 b = self.type2test()
38 self.assertEqual(type(b), self.type2test)
39 self.assertEqual(b.__class__, self.type2test)
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000040
41 def test_empty_sequence(self):
Christian Heimes510711d2008-01-30 11:57:58 +000042 b = self.type2test()
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000043 self.assertEqual(len(b), 0)
44 self.assertRaises(IndexError, lambda: b[0])
45 self.assertRaises(IndexError, lambda: b[1])
Christian Heimesa37d4c62007-12-04 23:02:19 +000046 self.assertRaises(IndexError, lambda: b[sys.maxsize])
47 self.assertRaises(IndexError, lambda: b[sys.maxsize+1])
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000048 self.assertRaises(IndexError, lambda: b[10**100])
49 self.assertRaises(IndexError, lambda: b[-1])
50 self.assertRaises(IndexError, lambda: b[-2])
Christian Heimesa37d4c62007-12-04 23:02:19 +000051 self.assertRaises(IndexError, lambda: b[-sys.maxsize])
52 self.assertRaises(IndexError, lambda: b[-sys.maxsize-1])
53 self.assertRaises(IndexError, lambda: b[-sys.maxsize-2])
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000054 self.assertRaises(IndexError, lambda: b[-10**100])
55
56 def test_from_list(self):
57 ints = list(range(256))
Christian Heimes510711d2008-01-30 11:57:58 +000058 b = self.type2test(i for i in ints)
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000059 self.assertEqual(len(b), 256)
60 self.assertEqual(list(b), ints)
61
62 def test_from_index(self):
Georg Brandl9a54d7c2008-07-16 23:15:30 +000063 b = self.type2test([Indexable(), Indexable(1), Indexable(254),
64 Indexable(255)])
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000065 self.assertEqual(list(b), [0, 1, 254, 255])
Georg Brandl9a54d7c2008-07-16 23:15:30 +000066 self.assertRaises(ValueError, bytearray, [Indexable(-1)])
67 self.assertRaises(ValueError, bytearray, [Indexable(256)])
Guido van Rossum98297ee2007-11-06 21:34:58 +000068
69 def test_from_ssize(self):
Guido van Rossum254348e2007-11-21 19:29:53 +000070 self.assertEqual(bytearray(0), b'')
71 self.assertEqual(bytearray(1), b'\x00')
72 self.assertEqual(bytearray(5), b'\x00\x00\x00\x00\x00')
73 self.assertRaises(ValueError, bytearray, -1)
Guido van Rossum98297ee2007-11-06 21:34:58 +000074
Guido van Rossum254348e2007-11-21 19:29:53 +000075 self.assertEqual(bytearray('0', 'ascii'), b'0')
76 self.assertEqual(bytearray(b'0'), b'0')
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000077
78 def test_constructor_type_errors(self):
Christian Heimes510711d2008-01-30 11:57:58 +000079 self.assertRaises(TypeError, self.type2test, 0.0)
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000080 class C:
81 pass
Christian Heimes510711d2008-01-30 11:57:58 +000082 self.assertRaises(TypeError, self.type2test, ["0"])
83 self.assertRaises(TypeError, self.type2test, [0.0])
84 self.assertRaises(TypeError, self.type2test, [None])
85 self.assertRaises(TypeError, self.type2test, [C()])
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000086
87 def test_constructor_value_errors(self):
Christian Heimes510711d2008-01-30 11:57:58 +000088 self.assertRaises(ValueError, self.type2test, [-1])
89 self.assertRaises(ValueError, self.type2test, [-sys.maxsize])
90 self.assertRaises(ValueError, self.type2test, [-sys.maxsize-1])
91 self.assertRaises(ValueError, self.type2test, [-sys.maxsize-2])
92 self.assertRaises(ValueError, self.type2test, [-10**100])
93 self.assertRaises(ValueError, self.type2test, [256])
94 self.assertRaises(ValueError, self.type2test, [257])
95 self.assertRaises(ValueError, self.type2test, [sys.maxsize])
96 self.assertRaises(ValueError, self.type2test, [sys.maxsize+1])
97 self.assertRaises(ValueError, self.type2test, [10**100])
Guido van Rossum4dfe8a12006-04-22 23:28:04 +000098
99 def test_compare(self):
Christian Heimes510711d2008-01-30 11:57:58 +0000100 b1 = self.type2test([1, 2, 3])
101 b2 = self.type2test([1, 2, 3])
102 b3 = self.type2test([1, 3])
Guido van Rossum4dfe8a12006-04-22 23:28:04 +0000103
Guido van Rossume61fd5b2007-07-11 12:20:59 +0000104 self.assertEqual(b1, b2)
Guido van Rossum4dfe8a12006-04-22 23:28:04 +0000105 self.failUnless(b2 != b3)
106 self.failUnless(b1 <= b2)
107 self.failUnless(b1 <= b3)
108 self.failUnless(b1 < b3)
109 self.failUnless(b1 >= b2)
110 self.failUnless(b3 >= b2)
111 self.failUnless(b3 > b2)
112
113 self.failIf(b1 != b2)
114 self.failIf(b2 == b3)
115 self.failIf(b1 > b2)
116 self.failIf(b1 > b3)
117 self.failIf(b1 >= b3)
118 self.failIf(b1 < b2)
119 self.failIf(b3 < b2)
120 self.failIf(b3 <= b2)
121
Guido van Rossum343e97f2007-04-09 00:43:24 +0000122 def test_compare_to_str(self):
Guido van Rossum98297ee2007-11-06 21:34:58 +0000123 warnings.simplefilter('ignore', BytesWarning)
Guido van Rossum1e35e762007-10-09 17:21:10 +0000124 # Byte comparisons with unicode should always fail!
Guido van Rossumebea9be2007-04-09 00:49:13 +0000125 # Test this for all expected byte orders and Unicode character sizes
Christian Heimes510711d2008-01-30 11:57:58 +0000126 self.assertEqual(self.type2test(b"\0a\0b\0c") == "abc", False)
127 self.assertEqual(self.type2test(b"\0\0\0a\0\0\0b\0\0\0c") == "abc", False)
128 self.assertEqual(self.type2test(b"a\0b\0c\0") == "abc", False)
129 self.assertEqual(self.type2test(b"a\0\0\0b\0\0\0c\0\0\0") == "abc", False)
130 self.assertEqual(self.type2test() == str(), False)
131 self.assertEqual(self.type2test() != str(), True)
132
133 def test_reversed(self):
134 input = list(map(ord, "Hello"))
135 b = self.type2test(input)
136 output = list(reversed(b))
137 input.reverse()
138 self.assertEqual(output, input)
139
140 def test_getslice(self):
141 def by(s):
142 return self.type2test(map(ord, s))
143 b = by("Hello, world")
144
145 self.assertEqual(b[:5], by("Hello"))
146 self.assertEqual(b[1:5], by("ello"))
147 self.assertEqual(b[5:7], by(", "))
148 self.assertEqual(b[7:], by("world"))
149 self.assertEqual(b[7:12], by("world"))
150 self.assertEqual(b[7:100], by("world"))
151
152 self.assertEqual(b[:-7], by("Hello"))
153 self.assertEqual(b[-11:-7], by("ello"))
154 self.assertEqual(b[-7:-5], by(", "))
155 self.assertEqual(b[-5:], by("world"))
156 self.assertEqual(b[-5:12], by("world"))
157 self.assertEqual(b[-5:100], by("world"))
158 self.assertEqual(b[-100:5], by("Hello"))
159
160 def test_extended_getslice(self):
161 # Test extended slicing by comparing with list slicing.
162 L = list(range(255))
163 b = self.type2test(L)
164 indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100)
165 for start in indices:
166 for stop in indices:
167 # Skip step 0 (invalid)
168 for step in indices[1:]:
169 self.assertEqual(b[start:stop:step], self.type2test(L[start:stop:step]))
170
171 def test_encoding(self):
172 sample = "Hello world\n\u1234\u5678\u9abc\udef0"
173 for enc in ("utf8", "utf16"):
174 b = self.type2test(sample, enc)
175 self.assertEqual(b, self.type2test(sample.encode(enc)))
176 self.assertRaises(UnicodeEncodeError, self.type2test, sample, "latin1")
177 b = self.type2test(sample, "latin1", "ignore")
178 self.assertEqual(b, self.type2test(sample[:-4], "utf-8"))
179
180 def test_decode(self):
181 sample = "Hello world\n\u1234\u5678\u9abc\def0\def0"
182 for enc in ("utf8", "utf16"):
183 b = self.type2test(sample, enc)
184 self.assertEqual(b.decode(enc), sample)
185 sample = "Hello world\n\x80\x81\xfe\xff"
186 b = self.type2test(sample, "latin1")
187 self.assertRaises(UnicodeDecodeError, b.decode, "utf8")
188 self.assertEqual(b.decode("utf8", "ignore"), "Hello world\n")
189
190 def test_from_int(self):
191 b = self.type2test(0)
192 self.assertEqual(b, self.type2test())
193 b = self.type2test(10)
194 self.assertEqual(b, self.type2test([0]*10))
195 b = self.type2test(10000)
196 self.assertEqual(b, self.type2test([0]*10000))
197
198 def test_concat(self):
199 b1 = self.type2test(b"abc")
200 b2 = self.type2test(b"def")
201 self.assertEqual(b1 + b2, b"abcdef")
202 self.assertEqual(b1 + bytes(b"def"), b"abcdef")
203 self.assertEqual(bytes(b"def") + b1, b"defabc")
204 self.assertRaises(TypeError, lambda: b1 + "def")
205 self.assertRaises(TypeError, lambda: "abc" + b2)
206
207 def test_repeat(self):
208 for b in b"abc", self.type2test(b"abc"):
209 self.assertEqual(b * 3, b"abcabcabc")
210 self.assertEqual(b * 0, b"")
211 self.assertEqual(b * -1, b"")
212 self.assertRaises(TypeError, lambda: b * 3.14)
213 self.assertRaises(TypeError, lambda: 3.14 * b)
214 # XXX Shouldn't bytes and bytearray agree on what to raise?
215 self.assertRaises((OverflowError, MemoryError),
216 lambda: b * sys.maxsize)
217
218 def test_repeat_1char(self):
219 self.assertEqual(self.type2test(b'x')*100, self.type2test([ord('x')]*100))
220
221 def test_contains(self):
222 b = self.type2test(b"abc")
223 self.failUnless(ord('a') in b)
224 self.failUnless(int(ord('a')) in b)
225 self.failIf(200 in b)
226 self.failIf(200 in b)
227 self.assertRaises(ValueError, lambda: 300 in b)
228 self.assertRaises(ValueError, lambda: -1 in b)
229 self.assertRaises(TypeError, lambda: None in b)
230 self.assertRaises(TypeError, lambda: float(ord('a')) in b)
231 self.assertRaises(TypeError, lambda: "a" in b)
232 for f in bytes, bytearray:
233 self.failUnless(f(b"") in b)
234 self.failUnless(f(b"a") in b)
235 self.failUnless(f(b"b") in b)
236 self.failUnless(f(b"c") in b)
237 self.failUnless(f(b"ab") in b)
238 self.failUnless(f(b"bc") in b)
239 self.failUnless(f(b"abc") in b)
240 self.failIf(f(b"ac") in b)
241 self.failIf(f(b"d") in b)
242 self.failIf(f(b"dab") in b)
243 self.failIf(f(b"abd") in b)
244
245 def test_fromhex(self):
246 self.assertRaises(TypeError, self.type2test.fromhex)
247 self.assertRaises(TypeError, self.type2test.fromhex, 1)
Christian Heimes4f066122008-01-30 15:02:52 +0000248 self.assertEquals(self.type2test.fromhex(''), self.type2test())
Christian Heimes510711d2008-01-30 11:57:58 +0000249 b = bytearray([0x1a, 0x2b, 0x30])
250 self.assertEquals(self.type2test.fromhex('1a2B30'), b)
251 self.assertEquals(self.type2test.fromhex(' 1A 2B 30 '), b)
252 self.assertEquals(self.type2test.fromhex('0000'), b'\0\0')
253 self.assertRaises(TypeError, self.type2test.fromhex, b'1B')
254 self.assertRaises(ValueError, self.type2test.fromhex, 'a')
255 self.assertRaises(ValueError, self.type2test.fromhex, 'rt')
256 self.assertRaises(ValueError, self.type2test.fromhex, '1a b cd')
257 self.assertRaises(ValueError, self.type2test.fromhex, '\x00')
258 self.assertRaises(ValueError, self.type2test.fromhex, '12 \x00 34')
259
260 def test_join(self):
261 self.assertEqual(self.type2test(b"").join([]), b"")
262 self.assertEqual(self.type2test(b"").join([b""]), b"")
263 for lst in [[b"abc"], [b"a", b"bc"], [b"ab", b"c"], [b"a", b"b", b"c"]]:
264 lst = list(map(self.type2test, lst))
265 self.assertEqual(self.type2test(b"").join(lst), b"abc")
266 self.assertEqual(self.type2test(b"").join(tuple(lst)), b"abc")
267 self.assertEqual(self.type2test(b"").join(iter(lst)), b"abc")
268 self.assertEqual(self.type2test(b".").join([b"ab", b"cd"]), b"ab.cd")
269 # XXX more...
270
271 def test_index(self):
272 b = self.type2test(b'parrot')
273 self.assertEqual(b.index('p'), 0)
274 self.assertEqual(b.index('rr'), 2)
275 self.assertEqual(b.index('t'), 5)
276 self.assertRaises(ValueError, lambda: b.index('w'))
277
278 def test_count(self):
279 b = self.type2test(b'mississippi')
280 self.assertEqual(b.count(b'i'), 4)
281 self.assertEqual(b.count(b'ss'), 2)
282 self.assertEqual(b.count(b'w'), 0)
283
284 def test_startswith(self):
285 b = self.type2test(b'hello')
286 self.assertFalse(self.type2test().startswith(b"anything"))
287 self.assertTrue(b.startswith(b"hello"))
288 self.assertTrue(b.startswith(b"hel"))
289 self.assertTrue(b.startswith(b"h"))
290 self.assertFalse(b.startswith(b"hellow"))
291 self.assertFalse(b.startswith(b"ha"))
292
293 def test_endswith(self):
294 b = self.type2test(b'hello')
295 self.assertFalse(bytearray().endswith(b"anything"))
296 self.assertTrue(b.endswith(b"hello"))
297 self.assertTrue(b.endswith(b"llo"))
298 self.assertTrue(b.endswith(b"o"))
299 self.assertFalse(b.endswith(b"whello"))
300 self.assertFalse(b.endswith(b"no"))
301
302 def test_find(self):
303 b = self.type2test(b'mississippi')
304 self.assertEqual(b.find(b'ss'), 2)
305 self.assertEqual(b.find(b'ss', 3), 5)
306 self.assertEqual(b.find(b'ss', 1, 7), 2)
307 self.assertEqual(b.find(b'ss', 1, 3), -1)
308 self.assertEqual(b.find(b'w'), -1)
309 self.assertEqual(b.find(b'mississippian'), -1)
310
311 def test_rfind(self):
312 b = self.type2test(b'mississippi')
313 self.assertEqual(b.rfind(b'ss'), 5)
314 self.assertEqual(b.rfind(b'ss', 3), 5)
315 self.assertEqual(b.rfind(b'ss', 0, 6), 2)
316 self.assertEqual(b.rfind(b'w'), -1)
317 self.assertEqual(b.rfind(b'mississippian'), -1)
318
319 def test_index(self):
320 b = self.type2test(b'world')
321 self.assertEqual(b.index(b'w'), 0)
322 self.assertEqual(b.index(b'orl'), 1)
323 self.assertRaises(ValueError, b.index, b'worm')
324 self.assertRaises(ValueError, b.index, b'ldo')
325
326 def test_rindex(self):
327 # XXX could be more rigorous
328 b = self.type2test(b'world')
329 self.assertEqual(b.rindex(b'w'), 0)
330 self.assertEqual(b.rindex(b'orl'), 1)
331 self.assertRaises(ValueError, b.rindex, b'worm')
332 self.assertRaises(ValueError, b.rindex, b'ldo')
333
334 def test_replace(self):
335 b = self.type2test(b'mississippi')
336 self.assertEqual(b.replace(b'i', b'a'), b'massassappa')
337 self.assertEqual(b.replace(b'ss', b'x'), b'mixixippi')
338
339 def test_split(self):
340 b = self.type2test(b'mississippi')
341 self.assertEqual(b.split(b'i'), [b'm', b'ss', b'ss', b'pp', b''])
342 self.assertEqual(b.split(b'ss'), [b'mi', b'i', b'ippi'])
343 self.assertEqual(b.split(b'w'), [b])
344
345 def test_split_whitespace(self):
346 for b in (b' arf barf ', b'arf\tbarf', b'arf\nbarf', b'arf\rbarf',
347 b'arf\fbarf', b'arf\vbarf'):
348 b = self.type2test(b)
349 self.assertEqual(b.split(), [b'arf', b'barf'])
350 self.assertEqual(b.split(None), [b'arf', b'barf'])
351 self.assertEqual(b.split(None, 2), [b'arf', b'barf'])
352 for b in (b'a\x1Cb', b'a\x1Db', b'a\x1Eb', b'a\x1Fb'):
353 b = self.type2test(b)
354 self.assertEqual(b.split(), [b])
355 self.assertEqual(self.type2test(b' a bb c ').split(None, 0), [b'a bb c '])
356 self.assertEqual(self.type2test(b' a bb c ').split(None, 1), [b'a', b'bb c '])
357 self.assertEqual(self.type2test(b' a bb c ').split(None, 2), [b'a', b'bb', b'c '])
358 self.assertEqual(self.type2test(b' a bb c ').split(None, 3), [b'a', b'bb', b'c'])
359
360 def test_split_string_error(self):
361 self.assertRaises(TypeError, self.type2test(b'a b').split, ' ')
362
363 def test_rsplit(self):
364 b = self.type2test(b'mississippi')
365 self.assertEqual(b.rsplit(b'i'), [b'm', b'ss', b'ss', b'pp', b''])
366 self.assertEqual(b.rsplit(b'ss'), [b'mi', b'i', b'ippi'])
367 self.assertEqual(b.rsplit(b'w'), [b])
368
369 def test_rsplit_whitespace(self):
370 for b in (b' arf barf ', b'arf\tbarf', b'arf\nbarf', b'arf\rbarf',
371 b'arf\fbarf', b'arf\vbarf'):
372 b = self.type2test(b)
373 self.assertEqual(b.rsplit(), [b'arf', b'barf'])
374 self.assertEqual(b.rsplit(None), [b'arf', b'barf'])
375 self.assertEqual(b.rsplit(None, 2), [b'arf', b'barf'])
376 self.assertEqual(self.type2test(b' a bb c ').rsplit(None, 0), [b' a bb c'])
377 self.assertEqual(self.type2test(b' a bb c ').rsplit(None, 1), [b' a bb', b'c'])
378 self.assertEqual(self.type2test(b' a bb c ').rsplit(None, 2), [b' a', b'bb', b'c'])
379 self.assertEqual(self.type2test(b' a bb c ').rsplit(None, 3), [b'a', b'bb', b'c'])
380
381 def test_rsplit_string_error(self):
382 self.assertRaises(TypeError, self.type2test(b'a b').rsplit, ' ')
383
384 def test_rsplit_unicodewhitespace(self):
385 b = self.type2test(b"\x09\x0A\x0B\x0C\x0D\x1C\x1D\x1E\x1F")
386 self.assertEqual(b.split(), [b'\x1c\x1d\x1e\x1f'])
387 self.assertEqual(b.rsplit(), [b'\x1c\x1d\x1e\x1f'])
388
389 def test_partition(self):
390 b = self.type2test(b'mississippi')
391 self.assertEqual(b.partition(b'ss'), (b'mi', b'ss', b'issippi'))
392 self.assertEqual(b.rpartition(b'w'), (b'', b'', b'mississippi'))
393
394 def test_rpartition(self):
395 b = self.type2test(b'mississippi')
396 self.assertEqual(b.rpartition(b'ss'), (b'missi', b'ss', b'ippi'))
397 self.assertEqual(b.rpartition(b'i'), (b'mississipp', b'i', b''))
398
399 def test_pickling(self):
Hirokazu Yamamotod0d0b652008-10-23 00:38:15 +0000400 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
Christian Heimes510711d2008-01-30 11:57:58 +0000401 for b in b"", b"a", b"abc", b"\xffab\x80", b"\0\0\377\0\0":
402 b = self.type2test(b)
403 ps = pickle.dumps(b, proto)
404 q = pickle.loads(ps)
405 self.assertEqual(b, q)
406
407 def test_strip(self):
408 b = self.type2test(b'mississippi')
409 self.assertEqual(b.strip(b'i'), b'mississipp')
410 self.assertEqual(b.strip(b'm'), b'ississippi')
411 self.assertEqual(b.strip(b'pi'), b'mississ')
412 self.assertEqual(b.strip(b'im'), b'ssissipp')
413 self.assertEqual(b.strip(b'pim'), b'ssiss')
414 self.assertEqual(b.strip(b), b'')
415
416 def test_lstrip(self):
417 b = self.type2test(b'mississippi')
418 self.assertEqual(b.lstrip(b'i'), b'mississippi')
419 self.assertEqual(b.lstrip(b'm'), b'ississippi')
420 self.assertEqual(b.lstrip(b'pi'), b'mississippi')
421 self.assertEqual(b.lstrip(b'im'), b'ssissippi')
422 self.assertEqual(b.lstrip(b'pim'), b'ssissippi')
423
424 def test_rstrip(self):
425 b = self.type2test(b'mississippi')
426 self.assertEqual(b.rstrip(b'i'), b'mississipp')
427 self.assertEqual(b.rstrip(b'm'), b'mississippi')
428 self.assertEqual(b.rstrip(b'pi'), b'mississ')
429 self.assertEqual(b.rstrip(b'im'), b'mississipp')
430 self.assertEqual(b.rstrip(b'pim'), b'mississ')
431
432 def test_strip_whitespace(self):
433 b = self.type2test(b' \t\n\r\f\vabc \t\n\r\f\v')
434 self.assertEqual(b.strip(), b'abc')
435 self.assertEqual(b.lstrip(), b'abc \t\n\r\f\v')
436 self.assertEqual(b.rstrip(), b' \t\n\r\f\vabc')
437
438 def test_strip_bytearray(self):
439 self.assertEqual(self.type2test(b'abc').strip(memoryview(b'ac')), b'b')
440 self.assertEqual(self.type2test(b'abc').lstrip(memoryview(b'ac')), b'bc')
441 self.assertEqual(self.type2test(b'abc').rstrip(memoryview(b'ac')), b'ab')
442
443 def test_strip_string_error(self):
444 self.assertRaises(TypeError, self.type2test(b'abc').strip, 'b')
445 self.assertRaises(TypeError, self.type2test(b'abc').lstrip, 'b')
446 self.assertRaises(TypeError, self.type2test(b'abc').rstrip, 'b')
447
448 def test_ord(self):
449 b = self.type2test(b'\0A\x7f\x80\xff')
450 self.assertEqual([ord(b[i:i+1]) for i in range(len(b))],
451 [0, 65, 127, 128, 255])
452
Georg Brandlabc38772009-04-12 15:51:51 +0000453 def test_maketrans(self):
454 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'
455
456 self.assertEqual(self.type2test.maketrans(b'abc', b'xyz'), transtable)
457 self.assertRaises(ValueError, self.type2test.maketrans, b'abc', b'xyzq')
458 self.assertRaises(TypeError, self.type2test.maketrans, 'abc', 'def')
459
Christian Heimes510711d2008-01-30 11:57:58 +0000460
461class BytesTest(BaseBytesTest):
462 type2test = bytes
463
Antoine Pitrou2f89aa62008-08-02 21:02:48 +0000464 def test_buffer_is_readonly(self):
Antoine Pitrou47d305d2008-08-16 23:28:44 +0000465 fd = os.dup(sys.stdin.fileno())
466 with open(fd, "rb", buffering=0) as f:
Antoine Pitrou2f89aa62008-08-02 21:02:48 +0000467 self.assertRaises(TypeError, f.readinto, b"")
468
Benjamin Petersonc15a0732008-08-26 16:46:47 +0000469 def test_custom(self):
470 class A:
471 def __bytes__(self):
472 return b'abc'
473 self.assertEqual(bytes(A()), b'abc')
474 class A: pass
475 self.assertRaises(TypeError, bytes, A())
476 class A:
477 def __bytes__(self):
478 return None
479 self.assertRaises(TypeError, bytes, A())
480
Antoine Pitrou2f89aa62008-08-02 21:02:48 +0000481
Christian Heimes510711d2008-01-30 11:57:58 +0000482class ByteArrayTest(BaseBytesTest):
483 type2test = bytearray
Guido van Rossumebea9be2007-04-09 00:49:13 +0000484
Guido van Rossum4dfe8a12006-04-22 23:28:04 +0000485 def test_nohash(self):
Guido van Rossum254348e2007-11-21 19:29:53 +0000486 self.assertRaises(TypeError, hash, bytearray())
Guido van Rossum4dfe8a12006-04-22 23:28:04 +0000487
Guido van Rossum254348e2007-11-21 19:29:53 +0000488 def test_bytearray_api(self):
Guido van Rossum75d6f1a2007-05-24 17:52:00 +0000489 short_sample = b"Hello world\n"
Guido van Rossum98297ee2007-11-06 21:34:58 +0000490 sample = short_sample + b"\0"*(20 - len(short_sample))
Guido van Rossumd624f182006-04-24 13:47:05 +0000491 tfn = tempfile.mktemp()
492 try:
493 # Prepare
494 with open(tfn, "wb") as f:
495 f.write(short_sample)
496 # Test readinto
497 with open(tfn, "rb") as f:
Guido van Rossum254348e2007-11-21 19:29:53 +0000498 b = bytearray(20)
Guido van Rossumd624f182006-04-24 13:47:05 +0000499 n = f.readinto(b)
500 self.assertEqual(n, len(short_sample))
Guido van Rossumc1f779c2007-07-03 08:25:58 +0000501 self.assertEqual(list(b), list(sample))
Guido van Rossumd624f182006-04-24 13:47:05 +0000502 # Test writing in binary mode
503 with open(tfn, "wb") as f:
504 f.write(b)
505 with open(tfn, "rb") as f:
506 self.assertEqual(f.read(), sample)
Guido van Rossum13633bb2007-04-13 18:42:35 +0000507 # Text mode is ambiguous; don't test
Guido van Rossumd624f182006-04-24 13:47:05 +0000508 finally:
509 try:
510 os.remove(tfn)
511 except os.error:
512 pass
513
Neal Norwitz6968b052007-02-27 19:02:19 +0000514 def test_reverse(self):
Guido van Rossum254348e2007-11-21 19:29:53 +0000515 b = bytearray(b'hello')
Neal Norwitz6968b052007-02-27 19:02:19 +0000516 self.assertEqual(b.reverse(), None)
517 self.assertEqual(b, b'olleh')
Guido van Rossum254348e2007-11-21 19:29:53 +0000518 b = bytearray(b'hello1') # test even number of items
Neal Norwitz6968b052007-02-27 19:02:19 +0000519 b.reverse()
520 self.assertEqual(b, b'1olleh')
Guido van Rossum254348e2007-11-21 19:29:53 +0000521 b = bytearray()
Neal Norwitz6968b052007-02-27 19:02:19 +0000522 b.reverse()
523 self.assertFalse(b)
524
Guido van Rossumd624f182006-04-24 13:47:05 +0000525 def test_regexps(self):
526 def by(s):
Guido van Rossum254348e2007-11-21 19:29:53 +0000527 return bytearray(map(ord, s))
Guido van Rossumd624f182006-04-24 13:47:05 +0000528 b = by("Hello, world")
Antoine Pitroufd036452008-08-19 17:56:33 +0000529 self.assertEqual(re.findall(br"\w+", b), [by("Hello"), by("world")])
Guido van Rossumd624f182006-04-24 13:47:05 +0000530
531 def test_setitem(self):
Guido van Rossum254348e2007-11-21 19:29:53 +0000532 b = bytearray([1, 2, 3])
Guido van Rossumd624f182006-04-24 13:47:05 +0000533 b[1] = 100
Guido van Rossum254348e2007-11-21 19:29:53 +0000534 self.assertEqual(b, bytearray([1, 100, 3]))
Guido van Rossumd624f182006-04-24 13:47:05 +0000535 b[-1] = 200
Guido van Rossum254348e2007-11-21 19:29:53 +0000536 self.assertEqual(b, bytearray([1, 100, 200]))
Georg Brandl9a54d7c2008-07-16 23:15:30 +0000537 b[0] = Indexable(10)
Guido van Rossum254348e2007-11-21 19:29:53 +0000538 self.assertEqual(b, bytearray([10, 100, 200]))
Guido van Rossumd624f182006-04-24 13:47:05 +0000539 try:
540 b[3] = 0
541 self.fail("Didn't raise IndexError")
542 except IndexError:
543 pass
544 try:
545 b[-10] = 0
546 self.fail("Didn't raise IndexError")
547 except IndexError:
548 pass
549 try:
550 b[0] = 256
551 self.fail("Didn't raise ValueError")
552 except ValueError:
553 pass
554 try:
Georg Brandl9a54d7c2008-07-16 23:15:30 +0000555 b[0] = Indexable(-1)
Guido van Rossumd624f182006-04-24 13:47:05 +0000556 self.fail("Didn't raise ValueError")
557 except ValueError:
558 pass
559 try:
560 b[0] = None
561 self.fail("Didn't raise TypeError")
562 except TypeError:
563 pass
564
565 def test_delitem(self):
Guido van Rossum254348e2007-11-21 19:29:53 +0000566 b = bytearray(range(10))
Guido van Rossumd624f182006-04-24 13:47:05 +0000567 del b[0]
Guido van Rossum254348e2007-11-21 19:29:53 +0000568 self.assertEqual(b, bytearray(range(1, 10)))
Guido van Rossumd624f182006-04-24 13:47:05 +0000569 del b[-1]
Guido van Rossum254348e2007-11-21 19:29:53 +0000570 self.assertEqual(b, bytearray(range(1, 9)))
Guido van Rossumd624f182006-04-24 13:47:05 +0000571 del b[4]
Guido van Rossum254348e2007-11-21 19:29:53 +0000572 self.assertEqual(b, bytearray([1, 2, 3, 4, 6, 7, 8]))
Guido van Rossumd624f182006-04-24 13:47:05 +0000573
574 def test_setslice(self):
Guido van Rossum254348e2007-11-21 19:29:53 +0000575 b = bytearray(range(10))
Guido van Rossumd624f182006-04-24 13:47:05 +0000576 self.assertEqual(list(b), list(range(10)))
577
Guido van Rossum254348e2007-11-21 19:29:53 +0000578 b[0:5] = bytearray([1, 1, 1, 1, 1])
579 self.assertEqual(b, bytearray([1, 1, 1, 1, 1, 5, 6, 7, 8, 9]))
Guido van Rossumd624f182006-04-24 13:47:05 +0000580
581 del b[0:-5]
Guido van Rossum254348e2007-11-21 19:29:53 +0000582 self.assertEqual(b, bytearray([5, 6, 7, 8, 9]))
Guido van Rossumd624f182006-04-24 13:47:05 +0000583
Guido van Rossum254348e2007-11-21 19:29:53 +0000584 b[0:0] = bytearray([0, 1, 2, 3, 4])
585 self.assertEqual(b, bytearray(range(10)))
Guido van Rossumd624f182006-04-24 13:47:05 +0000586
Guido van Rossum254348e2007-11-21 19:29:53 +0000587 b[-7:-3] = bytearray([100, 101])
588 self.assertEqual(b, bytearray([0, 1, 2, 100, 101, 7, 8, 9]))
Guido van Rossumd624f182006-04-24 13:47:05 +0000589
590 b[3:5] = [3, 4, 5, 6]
Guido van Rossum254348e2007-11-21 19:29:53 +0000591 self.assertEqual(b, bytearray(range(10)))
Guido van Rossumad7d8d12007-04-13 01:39:34 +0000592
Thomas Wouters9a6e62b2006-08-23 23:20:29 +0000593 b[3:0] = [42, 42, 42]
Guido van Rossum254348e2007-11-21 19:29:53 +0000594 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 +0000595
Thomas Wouters376446d2006-12-19 08:30:14 +0000596 def test_extended_set_del_slice(self):
597 indices = (0, None, 1, 3, 19, 300, -1, -2, -31, -300)
598 for start in indices:
599 for stop in indices:
600 # Skip invalid step 0
601 for step in indices[1:]:
602 L = list(range(255))
Guido van Rossum254348e2007-11-21 19:29:53 +0000603 b = bytearray(L)
Thomas Wouters376446d2006-12-19 08:30:14 +0000604 # Make sure we have a slice of exactly the right length,
605 # but with different data.
606 data = L[start:stop:step]
607 data.reverse()
608 L[start:stop:step] = data
609 b[start:stop:step] = data
Guido van Rossum254348e2007-11-21 19:29:53 +0000610 self.assertEquals(b, bytearray(L))
Guido van Rossumad7d8d12007-04-13 01:39:34 +0000611
Thomas Wouters376446d2006-12-19 08:30:14 +0000612 del L[start:stop:step]
613 del b[start:stop:step]
Guido van Rossum254348e2007-11-21 19:29:53 +0000614 self.assertEquals(b, bytearray(L))
Thomas Wouters376446d2006-12-19 08:30:14 +0000615
Guido van Rossumd624f182006-04-24 13:47:05 +0000616 def test_setslice_trap(self):
617 # This test verifies that we correctly handle assigning self
618 # to a slice of self (the old Lambert Meertens trap).
Guido van Rossum254348e2007-11-21 19:29:53 +0000619 b = bytearray(range(256))
Guido van Rossumd624f182006-04-24 13:47:05 +0000620 b[8:] = b
Guido van Rossum254348e2007-11-21 19:29:53 +0000621 self.assertEqual(b, bytearray(list(range(8)) + list(range(256))))
Guido van Rossumd624f182006-04-24 13:47:05 +0000622
Guido van Rossum13e57212006-04-27 22:54:26 +0000623 def test_iconcat(self):
Guido van Rossum254348e2007-11-21 19:29:53 +0000624 b = bytearray(b"abc")
Guido van Rossum13e57212006-04-27 22:54:26 +0000625 b1 = b
Guido van Rossum9c627722007-08-27 18:31:48 +0000626 b += b"def"
627 self.assertEqual(b, b"abcdef")
Guido van Rossum13e57212006-04-27 22:54:26 +0000628 self.assertEqual(b, b1)
629 self.failUnless(b is b1)
Guido van Rossum98297ee2007-11-06 21:34:58 +0000630 b += b"xyz"
Guido van Rossumad7d8d12007-04-13 01:39:34 +0000631 self.assertEqual(b, b"abcdefxyz")
632 try:
Guido van Rossumef87d6e2007-05-02 19:09:54 +0000633 b += ""
Guido van Rossumad7d8d12007-04-13 01:39:34 +0000634 except TypeError:
635 pass
636 else:
637 self.fail("bytes += unicode didn't raise TypeError")
Guido van Rossum13e57212006-04-27 22:54:26 +0000638
639 def test_irepeat(self):
Guido van Rossum254348e2007-11-21 19:29:53 +0000640 b = bytearray(b"abc")
Guido van Rossum13e57212006-04-27 22:54:26 +0000641 b1 = b
642 b *= 3
Guido van Rossum9c627722007-08-27 18:31:48 +0000643 self.assertEqual(b, b"abcabcabc")
Guido van Rossum13e57212006-04-27 22:54:26 +0000644 self.assertEqual(b, b1)
645 self.failUnless(b is b1)
646
647 def test_irepeat_1char(self):
Guido van Rossum254348e2007-11-21 19:29:53 +0000648 b = bytearray(b"x")
Guido van Rossum13e57212006-04-27 22:54:26 +0000649 b1 = b
650 b *= 100
Guido van Rossum98297ee2007-11-06 21:34:58 +0000651 self.assertEqual(b, b"x"*100)
Guido van Rossum13e57212006-04-27 22:54:26 +0000652 self.assertEqual(b, b1)
653 self.failUnless(b is b1)
654
Guido van Rossum20188312006-05-05 15:15:40 +0000655 def test_alloc(self):
Guido van Rossum254348e2007-11-21 19:29:53 +0000656 b = bytearray()
Guido van Rossum20188312006-05-05 15:15:40 +0000657 alloc = b.__alloc__()
658 self.assert_(alloc >= 0)
659 seq = [alloc]
660 for i in range(100):
Guido van Rossum9c627722007-08-27 18:31:48 +0000661 b += b"x"
Guido van Rossum20188312006-05-05 15:15:40 +0000662 alloc = b.__alloc__()
663 self.assert_(alloc >= len(b))
664 if alloc not in seq:
665 seq.append(alloc)
Guido van Rossum20188312006-05-05 15:15:40 +0000666
Neal Norwitz6968b052007-02-27 19:02:19 +0000667 def test_extend(self):
668 orig = b'hello'
Guido van Rossum254348e2007-11-21 19:29:53 +0000669 a = bytearray(orig)
Neal Norwitz6968b052007-02-27 19:02:19 +0000670 a.extend(a)
671 self.assertEqual(a, orig + orig)
672 self.assertEqual(a[5:], orig)
Alexandre Vassalotti09121e82007-12-04 05:51:13 +0000673 a = bytearray(b'')
674 # Test iterators that don't have a __length_hint__
675 a.extend(map(int, orig * 25))
676 a.extend(int(x) for x in orig * 25)
677 self.assertEqual(a, orig * 50)
678 self.assertEqual(a[-5:], orig)
679 a = bytearray(b'')
680 a.extend(iter(map(int, orig * 50)))
681 self.assertEqual(a, orig * 50)
682 self.assertEqual(a[-5:], orig)
683 a = bytearray(b'')
684 a.extend(list(map(int, orig * 50)))
685 self.assertEqual(a, orig * 50)
686 self.assertEqual(a[-5:], orig)
687 a = bytearray(b'')
688 self.assertRaises(ValueError, a.extend, [0, 1, 2, 256])
689 self.assertRaises(ValueError, a.extend, [0, 1, 2, -1])
690 self.assertEqual(len(a), 0)
Georg Brandl9a54d7c2008-07-16 23:15:30 +0000691 a = bytearray(b'')
692 a.extend([Indexable(ord('a'))])
693 self.assertEqual(a, b'a')
Guido van Rossumad7d8d12007-04-13 01:39:34 +0000694
Neal Norwitz6968b052007-02-27 19:02:19 +0000695 def test_remove(self):
Guido van Rossum254348e2007-11-21 19:29:53 +0000696 b = bytearray(b'hello')
Neal Norwitz6968b052007-02-27 19:02:19 +0000697 b.remove(ord('l'))
698 self.assertEqual(b, b'helo')
699 b.remove(ord('l'))
700 self.assertEqual(b, b'heo')
701 self.assertRaises(ValueError, lambda: b.remove(ord('l')))
702 self.assertRaises(ValueError, lambda: b.remove(400))
Gregory P. Smith60d241f2007-10-16 06:31:30 +0000703 self.assertRaises(TypeError, lambda: b.remove('e'))
Neal Norwitz6968b052007-02-27 19:02:19 +0000704 # remove first and last
705 b.remove(ord('o'))
706 b.remove(ord('h'))
707 self.assertEqual(b, b'e')
Gregory P. Smith60d241f2007-10-16 06:31:30 +0000708 self.assertRaises(TypeError, lambda: b.remove(b'e'))
Georg Brandl9a54d7c2008-07-16 23:15:30 +0000709 b.remove(Indexable(ord('e')))
710 self.assertEqual(b, b'')
Neal Norwitz6968b052007-02-27 19:02:19 +0000711
712 def test_pop(self):
Guido van Rossum254348e2007-11-21 19:29:53 +0000713 b = bytearray(b'world')
Neal Norwitz6968b052007-02-27 19:02:19 +0000714 self.assertEqual(b.pop(), ord('d'))
715 self.assertEqual(b.pop(0), ord('w'))
716 self.assertEqual(b.pop(-2), ord('r'))
717 self.assertRaises(IndexError, lambda: b.pop(10))
Guido van Rossum254348e2007-11-21 19:29:53 +0000718 self.assertRaises(OverflowError, lambda: bytearray().pop())
Neal Norwitz6968b052007-02-27 19:02:19 +0000719
720 def test_nosort(self):
Guido van Rossum254348e2007-11-21 19:29:53 +0000721 self.assertRaises(AttributeError, lambda: bytearray().sort())
Neal Norwitz6968b052007-02-27 19:02:19 +0000722
Neal Norwitz6968b052007-02-27 19:02:19 +0000723 def test_append(self):
Guido van Rossum254348e2007-11-21 19:29:53 +0000724 b = bytearray(b'hell')
Neal Norwitz6968b052007-02-27 19:02:19 +0000725 b.append(ord('o'))
726 self.assertEqual(b, b'hello')
727 self.assertEqual(b.append(100), None)
Guido van Rossum254348e2007-11-21 19:29:53 +0000728 b = bytearray()
Neal Norwitz6968b052007-02-27 19:02:19 +0000729 b.append(ord('A'))
730 self.assertEqual(len(b), 1)
Gregory P. Smith60d241f2007-10-16 06:31:30 +0000731 self.assertRaises(TypeError, lambda: b.append(b'o'))
Georg Brandl9a54d7c2008-07-16 23:15:30 +0000732 b = bytearray()
733 b.append(Indexable(ord('A')))
734 self.assertEqual(b, b'A')
Neal Norwitz6968b052007-02-27 19:02:19 +0000735
736 def test_insert(self):
Guido van Rossum254348e2007-11-21 19:29:53 +0000737 b = bytearray(b'msssspp')
Neal Norwitz6968b052007-02-27 19:02:19 +0000738 b.insert(1, ord('i'))
739 b.insert(4, ord('i'))
740 b.insert(-2, ord('i'))
741 b.insert(1000, ord('i'))
742 self.assertEqual(b, b'mississippi')
Gregory P. Smith60d241f2007-10-16 06:31:30 +0000743 self.assertRaises(TypeError, lambda: b.insert(0, b'1'))
Georg Brandl9a54d7c2008-07-16 23:15:30 +0000744 b = bytearray()
745 b.insert(0, Indexable(ord('A')))
746 self.assertEqual(b, b'A')
Neal Norwitz6968b052007-02-27 19:02:19 +0000747
Benjamin Peterson0f3641c2008-11-19 22:05:52 +0000748 def test_copied(self):
749 # Issue 4348. Make sure that operations that don't mutate the array
750 # copy the bytes.
751 b = bytearray(b'abc')
Amaury Forgeot d'Arcb0c29162008-11-22 22:18:04 +0000752 self.assertFalse(b is b.replace(b'abc', b'cde', 0))
Benjamin Peterson0f3641c2008-11-19 22:05:52 +0000753
754 t = bytearray([i for i in range(256)])
755 x = bytearray(b'')
756 self.assertFalse(x is x.translate(t))
757
Guido van Rossum254348e2007-11-21 19:29:53 +0000758 def test_partition_bytearray_doesnt_share_nullstring(self):
759 a, b, c = bytearray(b"x").partition(b"y")
Guido van Rossum98297ee2007-11-06 21:34:58 +0000760 self.assertEqual(b, b"")
761 self.assertEqual(c, b"")
762 self.assert_(b is not c)
763 b += b"!"
764 self.assertEqual(c, b"")
Guido van Rossum254348e2007-11-21 19:29:53 +0000765 a, b, c = bytearray(b"x").partition(b"y")
Guido van Rossum98297ee2007-11-06 21:34:58 +0000766 self.assertEqual(b, b"")
767 self.assertEqual(c, b"")
768 # Same for rpartition
Guido van Rossum254348e2007-11-21 19:29:53 +0000769 b, c, a = bytearray(b"x").rpartition(b"y")
Guido van Rossum98297ee2007-11-06 21:34:58 +0000770 self.assertEqual(b, b"")
771 self.assertEqual(c, b"")
772 self.assert_(b is not c)
773 b += b"!"
774 self.assertEqual(c, b"")
Guido van Rossum254348e2007-11-21 19:29:53 +0000775 c, b, a = bytearray(b"x").rpartition(b"y")
Guido van Rossum98297ee2007-11-06 21:34:58 +0000776 self.assertEqual(b, b"")
777 self.assertEqual(c, b"")
778
Antoine Pitrou5504e892008-12-06 21:27:53 +0000779 def test_resize_forbidden(self):
780 # #4509: can't resize a bytearray when there are buffer exports, even
781 # if it wouldn't reallocate the underlying buffer.
782 # Furthermore, no destructive changes to the buffer may be applied
783 # before raising the error.
784 b = bytearray(range(10))
785 v = memoryview(b)
786 def resize(n):
787 b[1:-1] = range(n + 1, 2*n - 1)
788 resize(10)
789 orig = b[:]
790 self.assertRaises(BufferError, resize, 11)
791 self.assertEquals(b, orig)
792 self.assertRaises(BufferError, resize, 9)
793 self.assertEquals(b, orig)
794 self.assertRaises(BufferError, resize, 0)
795 self.assertEquals(b, orig)
796 # Other operations implying resize
797 self.assertRaises(BufferError, b.pop, 0)
798 self.assertEquals(b, orig)
799 self.assertRaises(BufferError, b.remove, b[1])
800 self.assertEquals(b, orig)
801 def delitem():
802 del b[1]
803 self.assertRaises(BufferError, delitem)
804 self.assertEquals(b, orig)
805 # deleting a non-contiguous slice
806 def delslice():
807 b[1:-1:2] = b""
808 self.assertRaises(BufferError, delslice)
809 self.assertEquals(b, orig)
Guido van Rossum98297ee2007-11-06 21:34:58 +0000810
Christian Heimes510711d2008-01-30 11:57:58 +0000811class AssortedBytesTest(unittest.TestCase):
812 #
813 # Test various combinations of bytes and bytearray
814 #
815
816 def setUp(self):
817 self.warning_filters = warnings.filters[:]
818
819 def tearDown(self):
820 warnings.filters = self.warning_filters
821
822 def test_repr_str(self):
823 warnings.simplefilter('ignore', BytesWarning)
824 for f in str, repr:
825 self.assertEqual(f(bytearray()), "bytearray(b'')")
826 self.assertEqual(f(bytearray([0])), "bytearray(b'\\x00')")
827 self.assertEqual(f(bytearray([0, 1, 254, 255])),
828 "bytearray(b'\\x00\\x01\\xfe\\xff')")
829 self.assertEqual(f(b"abc"), "b'abc'")
830 self.assertEqual(f(b"'"), '''b"'"''') # '''
831 self.assertEqual(f(b"'\""), r"""b'\'"'""") # '
832
833 def test_compare_bytes_to_bytearray(self):
834 self.assertEqual(b"abc" == bytes(b"abc"), True)
835 self.assertEqual(b"ab" != bytes(b"abc"), True)
836 self.assertEqual(b"ab" <= bytes(b"abc"), True)
837 self.assertEqual(b"ab" < bytes(b"abc"), True)
838 self.assertEqual(b"abc" >= bytes(b"ab"), True)
839 self.assertEqual(b"abc" > bytes(b"ab"), True)
840
841 self.assertEqual(b"abc" != bytes(b"abc"), False)
842 self.assertEqual(b"ab" == bytes(b"abc"), False)
843 self.assertEqual(b"ab" > bytes(b"abc"), False)
844 self.assertEqual(b"ab" >= bytes(b"abc"), False)
845 self.assertEqual(b"abc" < bytes(b"ab"), False)
846 self.assertEqual(b"abc" <= bytes(b"ab"), False)
847
848 self.assertEqual(bytes(b"abc") == b"abc", True)
849 self.assertEqual(bytes(b"ab") != b"abc", True)
850 self.assertEqual(bytes(b"ab") <= b"abc", True)
851 self.assertEqual(bytes(b"ab") < b"abc", True)
852 self.assertEqual(bytes(b"abc") >= b"ab", True)
853 self.assertEqual(bytes(b"abc") > b"ab", True)
854
855 self.assertEqual(bytes(b"abc") != b"abc", False)
856 self.assertEqual(bytes(b"ab") == b"abc", False)
857 self.assertEqual(bytes(b"ab") > b"abc", False)
858 self.assertEqual(bytes(b"ab") >= b"abc", False)
859 self.assertEqual(bytes(b"abc") < b"ab", False)
860 self.assertEqual(bytes(b"abc") <= b"ab", False)
861
862 def test_doc(self):
863 self.failUnless(bytearray.__doc__ != None)
864 self.failUnless(bytearray.__doc__.startswith("bytearray("), bytearray.__doc__)
865 self.failUnless(bytes.__doc__ != None)
866 self.failUnless(bytes.__doc__.startswith("bytes("), bytes.__doc__)
867
868 def test_from_bytearray(self):
869 sample = bytes(b"Hello world\n\x80\x81\xfe\xff")
870 buf = memoryview(sample)
871 b = bytearray(buf)
872 self.assertEqual(b, bytearray(sample))
873
874 def test_to_str(self):
875 warnings.simplefilter('ignore', BytesWarning)
876 self.assertEqual(str(b''), "b''")
877 self.assertEqual(str(b'x'), "b'x'")
878 self.assertEqual(str(b'\x80'), "b'\\x80'")
879 self.assertEqual(str(bytearray(b'')), "bytearray(b'')")
880 self.assertEqual(str(bytearray(b'x')), "bytearray(b'x')")
881 self.assertEqual(str(bytearray(b'\x80')), "bytearray(b'\\x80')")
882
883 def test_literal(self):
884 tests = [
885 (b"Wonderful spam", "Wonderful spam"),
886 (br"Wonderful spam too", "Wonderful spam too"),
887 (b"\xaa\x00\000\200", "\xaa\x00\000\200"),
888 (br"\xaa\x00\000\200", r"\xaa\x00\000\200"),
889 ]
890 for b, s in tests:
891 self.assertEqual(b, bytearray(s, 'latin-1'))
892 for c in range(128, 256):
893 self.assertRaises(SyntaxError, eval,
894 'b"%s"' % chr(c))
895
896 def test_translate(self):
897 b = b'hello'
Georg Brandlccc47b62008-12-28 11:44:14 +0000898 ba = bytearray(b)
Christian Heimes510711d2008-01-30 11:57:58 +0000899 rosetta = bytearray(range(0, 256))
900 rosetta[ord('o')] = ord('e')
901 c = b.translate(rosetta, b'l')
902 self.assertEqual(b, b'hello')
903 self.assertEqual(c, b'hee')
Georg Brandlccc47b62008-12-28 11:44:14 +0000904 c = ba.translate(rosetta, b'l')
905 self.assertEqual(ba, b'hello')
906 self.assertEqual(c, b'hee')
907 c = b.translate(None, b'e')
908 self.assertEqual(c, b'hllo')
909 c = ba.translate(None, b'e')
910 self.assertEqual(c, b'hllo')
911 self.assertRaises(TypeError, b.translate, None, None)
912 self.assertRaises(TypeError, ba.translate, None, None)
Christian Heimes510711d2008-01-30 11:57:58 +0000913
914 def test_split_bytearray(self):
915 self.assertEqual(b'a b'.split(memoryview(b' ')), [b'a', b'b'])
916
917 def test_rsplit_bytearray(self):
918 self.assertEqual(b'a b'.rsplit(memoryview(b' ')), [b'a', b'b'])
919
Georg Brandleb2c9642008-05-30 12:05:02 +0000920 def test_return_self(self):
921 # bytearray.replace must always return a new bytearray
922 b = bytearray()
923 self.failIf(b.replace(b'', b'') is b)
924
Barry Warsaw9e9dcd62008-10-17 01:50:37 +0000925 def test_compare(self):
926 if sys.flags.bytes_warning:
927 warnings.simplefilter('error', BytesWarning)
928 self.assertRaises(BytesWarning, operator.eq, b'', '')
929 self.assertRaises(BytesWarning, operator.ne, b'', '')
930 self.assertRaises(BytesWarning, operator.eq, bytearray(b''), '')
931 self.assertRaises(BytesWarning, operator.ne, bytearray(b''), '')
932 else:
933 # raise test.support.TestSkipped("BytesWarning is needed for this test: use -bb option")
934 pass
935
Guido van Rossumd624f182006-04-24 13:47:05 +0000936 # Optimizations:
Guido van Rossume06b6b82006-04-23 07:43:54 +0000937 # __iter__? (optimization)
Guido van Rossumd624f182006-04-24 13:47:05 +0000938 # __reversed__? (optimization)
939
Guido van Rossumad7d8d12007-04-13 01:39:34 +0000940 # XXX More string methods? (Those that don't use character properties)
941
Neal Norwitz6968b052007-02-27 19:02:19 +0000942 # There are tests in string_tests.py that are more
943 # comprehensive for things like split, partition, etc.
944 # Unfortunately they are all bundled with tests that
945 # are not appropriate for bytes
Guido van Rossume06b6b82006-04-23 07:43:54 +0000946
Guido van Rossum254348e2007-11-21 19:29:53 +0000947 # I've started porting some of those into bytearray_tests.py, we should port
Gregory P. Smith60d241f2007-10-16 06:31:30 +0000948 # the rest that make sense (the code can be cleaned up to use modern
949 # unittest methods at the same time).
950
Guido van Rossum254348e2007-11-21 19:29:53 +0000951class BytearrayPEP3137Test(unittest.TestCase,
Gregory P. Smith60d241f2007-10-16 06:31:30 +0000952 test.buffer_tests.MixinBytesBufferCommonTests):
953 def marshal(self, x):
Guido van Rossum254348e2007-11-21 19:29:53 +0000954 return bytearray(x)
Gregory P. Smith60d241f2007-10-16 06:31:30 +0000955
956 def test_returns_new_copy(self):
957 val = self.marshal(b'1234')
958 # On immutable types these MAY return a reference to themselves
Guido van Rossum254348e2007-11-21 19:29:53 +0000959 # but on mutable types like bytearray they MUST return a new copy.
Gregory P. Smith60d241f2007-10-16 06:31:30 +0000960 for methname in ('zfill', 'rjust', 'ljust', 'center'):
961 method = getattr(val, methname)
962 newval = method(3)
963 self.assertEqual(val, newval)
964 self.assertTrue(val is not newval,
965 methname+' returned self on a mutable object')
966
Guido van Rossum4dfe8a12006-04-22 23:28:04 +0000967
Christian Heimes510711d2008-01-30 11:57:58 +0000968class FixedStringTest(test.string_tests.BaseTest):
Georg Brandlc7885542007-03-06 19:16:20 +0000969
Guido van Rossum9c627722007-08-27 18:31:48 +0000970 def fixtype(self, obj):
971 if isinstance(obj, str):
972 return obj.encode("utf-8")
973 return super().fixtype(obj)
974
Georg Brandlc7885542007-03-06 19:16:20 +0000975 # Currently the bytes containment testing uses a single integer
976 # value. This may not be the final design, but until then the
977 # bytes section with in a bytes containment not valid
978 def test_contains(self):
979 pass
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000980 def test_expandtabs(self):
981 pass
982 def test_upper(self):
983 pass
984 def test_lower(self):
985 pass
Georg Brandlc7885542007-03-06 19:16:20 +0000986
Christian Heimes510711d2008-01-30 11:57:58 +0000987class ByteArrayAsStringTest(FixedStringTest):
988 type2test = bytearray
989
990class BytesAsStringTest(FixedStringTest):
991 type2test = bytes
992
Georg Brandlc7885542007-03-06 19:16:20 +0000993
Guido van Rossum254348e2007-11-21 19:29:53 +0000994class ByteArraySubclass(bytearray):
Guido van Rossuma6c04be2007-11-03 00:24:24 +0000995 pass
996
Guido van Rossum254348e2007-11-21 19:29:53 +0000997class ByteArraySubclassTest(unittest.TestCase):
Guido van Rossuma6c04be2007-11-03 00:24:24 +0000998
999 def test_basic(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001000 self.assert_(issubclass(ByteArraySubclass, bytearray))
1001 self.assert_(isinstance(ByteArraySubclass(), bytearray))
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001002
1003 a, b = b"abcd", b"efgh"
Guido van Rossum254348e2007-11-21 19:29:53 +00001004 _a, _b = ByteArraySubclass(a), ByteArraySubclass(b)
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001005
1006 # test comparison operators with subclass instances
1007 self.assert_(_a == _a)
1008 self.assert_(_a != _b)
1009 self.assert_(_a < _b)
1010 self.assert_(_a <= _b)
1011 self.assert_(_b >= _a)
1012 self.assert_(_b > _a)
1013 self.assert_(_a is not a)
1014
1015 # test concat of subclass instances
1016 self.assertEqual(a + b, _a + _b)
1017 self.assertEqual(a + b, a + _b)
1018 self.assertEqual(a + b, _a + b)
1019
1020 # test repeat
1021 self.assert_(a*5 == _a*5)
1022
1023 def test_join(self):
1024 # Make sure join returns a NEW object for single item sequences
1025 # involving a subclass.
1026 # Make sure that it is of the appropriate type.
Guido van Rossum254348e2007-11-21 19:29:53 +00001027 s1 = ByteArraySubclass(b"abcd")
1028 s2 = bytearray().join([s1])
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001029 self.assert_(s1 is not s2)
Guido van Rossum254348e2007-11-21 19:29:53 +00001030 self.assert_(type(s2) is bytearray, type(s2))
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001031
1032 # Test reverse, calling join on subclass
1033 s3 = s1.join([b"abcd"])
Guido van Rossum254348e2007-11-21 19:29:53 +00001034 self.assert_(type(s3) is bytearray)
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001035
1036 def test_pickle(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001037 a = ByteArraySubclass(b"abcd")
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001038 a.x = 10
Guido van Rossum254348e2007-11-21 19:29:53 +00001039 a.y = ByteArraySubclass(b"efgh")
Hirokazu Yamamotod0d0b652008-10-23 00:38:15 +00001040 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001041 b = pickle.loads(pickle.dumps(a, proto))
1042 self.assertNotEqual(id(a), id(b))
1043 self.assertEqual(a, b)
1044 self.assertEqual(a.x, b.x)
1045 self.assertEqual(a.y, b.y)
1046 self.assertEqual(type(a), type(b))
1047 self.assertEqual(type(a.y), type(b.y))
1048
1049 def test_copy(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001050 a = ByteArraySubclass(b"abcd")
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001051 a.x = 10
Guido van Rossum254348e2007-11-21 19:29:53 +00001052 a.y = ByteArraySubclass(b"efgh")
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001053 for copy_method in (copy.copy, copy.deepcopy):
1054 b = copy_method(a)
1055 self.assertNotEqual(id(a), id(b))
1056 self.assertEqual(a, b)
1057 self.assertEqual(a.x, b.x)
1058 self.assertEqual(a.y, b.y)
1059 self.assertEqual(type(a), type(b))
1060 self.assertEqual(type(a.y), type(b.y))
1061
1062 def test_init_override(self):
Guido van Rossum254348e2007-11-21 19:29:53 +00001063 class subclass(bytearray):
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001064 def __init__(self, newarg=1, *args, **kwargs):
Guido van Rossum254348e2007-11-21 19:29:53 +00001065 bytearray.__init__(self, *args, **kwargs)
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001066 x = subclass(4, source=b"abcd")
1067 self.assertEqual(x, b"abcd")
1068 x = subclass(newarg=4, source=b"abcd")
1069 self.assertEqual(x, b"abcd")
1070
1071
Guido van Rossum4dfe8a12006-04-22 23:28:04 +00001072def test_main():
Benjamin Petersonee8712c2008-05-20 21:35:26 +00001073 test.support.run_unittest(BytesTest)
1074 test.support.run_unittest(ByteArrayTest)
1075 test.support.run_unittest(AssortedBytesTest)
1076 test.support.run_unittest(BytesAsStringTest)
1077 test.support.run_unittest(ByteArrayAsStringTest)
1078 test.support.run_unittest(ByteArraySubclassTest)
1079 test.support.run_unittest(BytearrayPEP3137Test)
Guido van Rossum4dfe8a12006-04-22 23:28:04 +00001080
1081if __name__ == "__main__":
Guido van Rossuma6c04be2007-11-03 00:24:24 +00001082 test_main()