/Lib/test/test_bytes.py

http://unladen-swallow.googlecode.com/ · Python · 1044 lines · 841 code · 132 blank · 71 comment · 52 complexity · 20a5e52d67b6335e428cb1afcb23fe5e MD5 · raw file

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