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