/Lib/test/test_bz2.py

http://unladen-swallow.googlecode.com/ · Python · 384 lines · 292 code · 52 blank · 40 comment · 17 complexity · cd848d49910cbe3c04329b264aed1091 MD5 · raw file

  1. #!/usr/bin/python
  2. from test import test_support
  3. from test.test_support import TESTFN
  4. import unittest
  5. from cStringIO import StringIO
  6. import os
  7. import subprocess
  8. import sys
  9. import bz2
  10. from bz2 import BZ2File, BZ2Compressor, BZ2Decompressor
  11. has_cmdline_bunzip2 = sys.platform not in ("win32", "os2emx", "riscos")
  12. class BaseTest(unittest.TestCase):
  13. "Base for other testcases."
  14. TEXT = 'root:x:0:0:root:/root:/bin/bash\nbin:x:1:1:bin:/bin:\ndaemon:x:2:2:daemon:/sbin:\nadm:x:3:4:adm:/var/adm:\nlp:x:4:7:lp:/var/spool/lpd:\nsync:x:5:0:sync:/sbin:/bin/sync\nshutdown:x:6:0:shutdown:/sbin:/sbin/shutdown\nhalt:x:7:0:halt:/sbin:/sbin/halt\nmail:x:8:12:mail:/var/spool/mail:\nnews:x:9:13:news:/var/spool/news:\nuucp:x:10:14:uucp:/var/spool/uucp:\noperator:x:11:0:operator:/root:\ngames:x:12:100:games:/usr/games:\ngopher:x:13:30:gopher:/usr/lib/gopher-data:\nftp:x:14:50:FTP User:/var/ftp:/bin/bash\nnobody:x:65534:65534:Nobody:/home:\npostfix:x:100:101:postfix:/var/spool/postfix:\nniemeyer:x:500:500::/home/niemeyer:/bin/bash\npostgres:x:101:102:PostgreSQL Server:/var/lib/pgsql:/bin/bash\nmysql:x:102:103:MySQL server:/var/lib/mysql:/bin/bash\nwww:x:103:104::/var/www:/bin/false\n'
  15. DATA = 'BZh91AY&SY.\xc8N\x18\x00\x01>_\x80\x00\x10@\x02\xff\xf0\x01\x07n\x00?\xe7\xff\xe00\x01\x99\xaa\x00\xc0\x03F\x86\x8c#&\x83F\x9a\x03\x06\xa6\xd0\xa6\x93M\x0fQ\xa7\xa8\x06\x804hh\x12$\x11\xa4i4\xf14S\xd2<Q\xb5\x0fH\xd3\xd4\xdd\xd5\x87\xbb\xf8\x94\r\x8f\xafI\x12\xe1\xc9\xf8/E\x00pu\x89\x12]\xc9\xbbDL\nQ\x0e\t1\x12\xdf\xa0\xc0\x97\xac2O9\x89\x13\x94\x0e\x1c7\x0ed\x95I\x0c\xaaJ\xa4\x18L\x10\x05#\x9c\xaf\xba\xbc/\x97\x8a#C\xc8\xe1\x8cW\xf9\xe2\xd0\xd6M\xa7\x8bXa<e\x84t\xcbL\xb3\xa7\xd9\xcd\xd1\xcb\x84.\xaf\xb3\xab\xab\xad`n}\xa0lh\tE,\x8eZ\x15\x17VH>\x88\xe5\xcd9gd6\x0b\n\xe9\x9b\xd5\x8a\x99\xf7\x08.K\x8ev\xfb\xf7xw\xbb\xdf\xa1\x92\xf1\xdd|/";\xa2\xba\x9f\xd5\xb1#A\xb6\xf6\xb3o\xc9\xc5y\\\xebO\xe7\x85\x9a\xbc\xb6f8\x952\xd5\xd7"%\x89>V,\xf7\xa6z\xe2\x9f\xa3\xdf\x11\x11"\xd6E)I\xa9\x13^\xca\xf3r\xd0\x03U\x922\xf26\xec\xb6\xed\x8b\xc3U\x13\x9d\xc5\x170\xa4\xfa^\x92\xacDF\x8a\x97\xd6\x19\xfe\xdd\xb8\xbd\x1a\x9a\x19\xa3\x80ankR\x8b\xe5\xd83]\xa9\xc6\x08\x82f\xf6\xb9"6l$\xb8j@\xc0\x8a\xb0l1..\xbak\x83ls\x15\xbc\xf4\xc1\x13\xbe\xf8E\xb8\x9d\r\xa8\x9dk\x84\xd3n\xfa\xacQ\x07\xb1%y\xaav\xb4\x08\xe0z\x1b\x16\xf5\x04\xe9\xcc\xb9\x08z\x1en7.G\xfc]\xc9\x14\xe1B@\xbb!8`'
  16. DATA_CRLF = 'BZh91AY&SY\xaez\xbbN\x00\x01H\xdf\x80\x00\x12@\x02\xff\xf0\x01\x07n\x00?\xe7\xff\xe0@\x01\xbc\xc6`\x86*\x8d=M\xa9\x9a\x86\xd0L@\x0fI\xa6!\xa1\x13\xc8\x88jdi\x8d@\x03@\x1a\x1a\x0c\x0c\x83 \x00\xc4h2\x19\x01\x82D\x84e\t\xe8\x99\x89\x19\x1ah\x00\r\x1a\x11\xaf\x9b\x0fG\xf5(\x1b\x1f?\t\x12\xcf\xb5\xfc\x95E\x00ps\x89\x12^\xa4\xdd\xa2&\x05(\x87\x04\x98\x89u\xe40%\xb6\x19\'\x8c\xc4\x89\xca\x07\x0e\x1b!\x91UIFU%C\x994!DI\xd2\xfa\xf0\xf1N8W\xde\x13A\xf5\x9cr%?\x9f3;I45A\xd1\x8bT\xb1<l\xba\xcb_\xc00xY\x17r\x17\x88\x08\x08@\xa0\ry@\x10\x04$)`\xf2\xce\x89z\xb0s\xec\x9b.iW\x9d\x81\xb5-+t\x9f\x1a\'\x97dB\xf5x\xb5\xbe.[.\xd7\x0e\x81\xe7\x08\x1cN`\x88\x10\xca\x87\xc3!"\x80\x92R\xa1/\xd1\xc0\xe6mf\xac\xbd\x99\xcca\xb3\x8780>\xa4\xc7\x8d\x1a\\"\xad\xa1\xabyBg\x15\xb9l\x88\x88\x91k"\x94\xa4\xd4\x89\xae*\xa6\x0b\x10\x0c\xd6\xd4m\xe86\xec\xb5j\x8a\x86j\';\xca.\x01I\xf2\xaaJ\xe8\x88\x8cU+t3\xfb\x0c\n\xa33\x13r2\r\x16\xe0\xb3(\xbf\x1d\x83r\xe7M\xf0D\x1365\xd8\x88\xd3\xa4\x92\xcb2\x06\x04\\\xc1\xb0\xea//\xbek&\xd8\xe6+t\xe5\xa1\x13\xada\x16\xder5"w]\xa2i\xb7[\x97R \xe2IT\xcd;Z\x04dk4\xad\x8a\t\xd3\x81z\x10\xf1:^`\xab\x1f\xc5\xdc\x91N\x14$+\x9e\xae\xd3\x80'
  17. if has_cmdline_bunzip2:
  18. def decompress(self, data):
  19. pop = subprocess.Popen("bunzip2", shell=True,
  20. stdin=subprocess.PIPE,
  21. stdout=subprocess.PIPE,
  22. stderr=subprocess.STDOUT)
  23. pop.stdin.write(data)
  24. pop.stdin.close()
  25. ret = pop.stdout.read()
  26. pop.stdout.close()
  27. if pop.wait() != 0:
  28. ret = bz2.decompress(data)
  29. return ret
  30. else:
  31. # bunzip2 isn't available to run on Windows.
  32. def decompress(self, data):
  33. return bz2.decompress(data)
  34. class BZ2FileTest(BaseTest):
  35. "Test BZ2File type miscellaneous methods."
  36. def setUp(self):
  37. self.filename = TESTFN
  38. def tearDown(self):
  39. if os.path.isfile(self.filename):
  40. os.unlink(self.filename)
  41. def createTempFile(self, crlf=0):
  42. f = open(self.filename, "wb")
  43. if crlf:
  44. data = self.DATA_CRLF
  45. else:
  46. data = self.DATA
  47. f.write(data)
  48. f.close()
  49. def testRead(self):
  50. # "Test BZ2File.read()"
  51. self.createTempFile()
  52. bz2f = BZ2File(self.filename)
  53. self.assertRaises(TypeError, bz2f.read, None)
  54. self.assertEqual(bz2f.read(), self.TEXT)
  55. bz2f.close()
  56. def testReadChunk10(self):
  57. # "Test BZ2File.read() in chunks of 10 bytes"
  58. self.createTempFile()
  59. bz2f = BZ2File(self.filename)
  60. text = ''
  61. while 1:
  62. str = bz2f.read(10)
  63. if not str:
  64. break
  65. text += str
  66. self.assertEqual(text, text)
  67. bz2f.close()
  68. def testRead100(self):
  69. # "Test BZ2File.read(100)"
  70. self.createTempFile()
  71. bz2f = BZ2File(self.filename)
  72. self.assertEqual(bz2f.read(100), self.TEXT[:100])
  73. bz2f.close()
  74. def testReadLine(self):
  75. # "Test BZ2File.readline()"
  76. self.createTempFile()
  77. bz2f = BZ2File(self.filename)
  78. self.assertRaises(TypeError, bz2f.readline, None)
  79. sio = StringIO(self.TEXT)
  80. for line in sio.readlines():
  81. self.assertEqual(bz2f.readline(), line)
  82. bz2f.close()
  83. def testReadLines(self):
  84. # "Test BZ2File.readlines()"
  85. self.createTempFile()
  86. bz2f = BZ2File(self.filename)
  87. self.assertRaises(TypeError, bz2f.readlines, None)
  88. sio = StringIO(self.TEXT)
  89. self.assertEqual(bz2f.readlines(), sio.readlines())
  90. bz2f.close()
  91. def testIterator(self):
  92. # "Test iter(BZ2File)"
  93. self.createTempFile()
  94. bz2f = BZ2File(self.filename)
  95. sio = StringIO(self.TEXT)
  96. self.assertEqual(list(iter(bz2f)), sio.readlines())
  97. bz2f.close()
  98. def testClosedIteratorDeadlock(self):
  99. # "Test that iteration on a closed bz2file releases the lock."
  100. # http://bugs.python.org/issue3309
  101. self.createTempFile()
  102. bz2f = BZ2File(self.filename)
  103. bz2f.close()
  104. self.assertRaises(ValueError, bz2f.next)
  105. # This call will deadlock of the above .next call failed to
  106. # release the lock.
  107. self.assertRaises(ValueError, bz2f.readlines)
  108. def testXReadLines(self):
  109. # "Test BZ2File.xreadlines()"
  110. self.createTempFile()
  111. bz2f = BZ2File(self.filename)
  112. sio = StringIO(self.TEXT)
  113. self.assertEqual(list(bz2f.xreadlines()), sio.readlines())
  114. bz2f.close()
  115. def testUniversalNewlinesLF(self):
  116. # "Test BZ2File.read() with universal newlines (\\n)"
  117. self.createTempFile()
  118. bz2f = BZ2File(self.filename, "rU")
  119. self.assertEqual(bz2f.read(), self.TEXT)
  120. self.assertEqual(bz2f.newlines, "\n")
  121. bz2f.close()
  122. def testUniversalNewlinesCRLF(self):
  123. # "Test BZ2File.read() with universal newlines (\\r\\n)"
  124. self.createTempFile(crlf=1)
  125. bz2f = BZ2File(self.filename, "rU")
  126. self.assertEqual(bz2f.read(), self.TEXT)
  127. self.assertEqual(bz2f.newlines, "\r\n")
  128. bz2f.close()
  129. def testWrite(self):
  130. # "Test BZ2File.write()"
  131. bz2f = BZ2File(self.filename, "w")
  132. self.assertRaises(TypeError, bz2f.write)
  133. bz2f.write(self.TEXT)
  134. bz2f.close()
  135. f = open(self.filename, 'rb')
  136. self.assertEqual(self.decompress(f.read()), self.TEXT)
  137. f.close()
  138. def testWriteChunks10(self):
  139. # "Test BZ2File.write() with chunks of 10 bytes"
  140. bz2f = BZ2File(self.filename, "w")
  141. n = 0
  142. while 1:
  143. str = self.TEXT[n*10:(n+1)*10]
  144. if not str:
  145. break
  146. bz2f.write(str)
  147. n += 1
  148. bz2f.close()
  149. f = open(self.filename, 'rb')
  150. self.assertEqual(self.decompress(f.read()), self.TEXT)
  151. f.close()
  152. def testWriteLines(self):
  153. # "Test BZ2File.writelines()"
  154. bz2f = BZ2File(self.filename, "w")
  155. self.assertRaises(TypeError, bz2f.writelines)
  156. sio = StringIO(self.TEXT)
  157. bz2f.writelines(sio.readlines())
  158. bz2f.close()
  159. # patch #1535500
  160. self.assertRaises(ValueError, bz2f.writelines, ["a"])
  161. f = open(self.filename, 'rb')
  162. self.assertEqual(self.decompress(f.read()), self.TEXT)
  163. f.close()
  164. def testWriteMethodsOnReadOnlyFile(self):
  165. bz2f = BZ2File(self.filename, "w")
  166. bz2f.write("abc")
  167. bz2f.close()
  168. bz2f = BZ2File(self.filename, "r")
  169. self.assertRaises(IOError, bz2f.write, "a")
  170. self.assertRaises(IOError, bz2f.writelines, ["a"])
  171. def testSeekForward(self):
  172. # "Test BZ2File.seek(150, 0)"
  173. self.createTempFile()
  174. bz2f = BZ2File(self.filename)
  175. self.assertRaises(TypeError, bz2f.seek)
  176. bz2f.seek(150)
  177. self.assertEqual(bz2f.read(), self.TEXT[150:])
  178. bz2f.close()
  179. def testSeekBackwards(self):
  180. # "Test BZ2File.seek(-150, 1)"
  181. self.createTempFile()
  182. bz2f = BZ2File(self.filename)
  183. bz2f.read(500)
  184. bz2f.seek(-150, 1)
  185. self.assertEqual(bz2f.read(), self.TEXT[500-150:])
  186. bz2f.close()
  187. def testSeekBackwardsFromEnd(self):
  188. # "Test BZ2File.seek(-150, 2)"
  189. self.createTempFile()
  190. bz2f = BZ2File(self.filename)
  191. bz2f.seek(-150, 2)
  192. self.assertEqual(bz2f.read(), self.TEXT[len(self.TEXT)-150:])
  193. bz2f.close()
  194. def testSeekPostEnd(self):
  195. # "Test BZ2File.seek(150000)"
  196. self.createTempFile()
  197. bz2f = BZ2File(self.filename)
  198. bz2f.seek(150000)
  199. self.assertEqual(bz2f.tell(), len(self.TEXT))
  200. self.assertEqual(bz2f.read(), "")
  201. bz2f.close()
  202. def testSeekPostEndTwice(self):
  203. # "Test BZ2File.seek(150000) twice"
  204. self.createTempFile()
  205. bz2f = BZ2File(self.filename)
  206. bz2f.seek(150000)
  207. bz2f.seek(150000)
  208. self.assertEqual(bz2f.tell(), len(self.TEXT))
  209. self.assertEqual(bz2f.read(), "")
  210. bz2f.close()
  211. def testSeekPreStart(self):
  212. # "Test BZ2File.seek(-150, 0)"
  213. self.createTempFile()
  214. bz2f = BZ2File(self.filename)
  215. bz2f.seek(-150)
  216. self.assertEqual(bz2f.tell(), 0)
  217. self.assertEqual(bz2f.read(), self.TEXT)
  218. bz2f.close()
  219. def testOpenDel(self):
  220. # "Test opening and deleting a file many times"
  221. self.createTempFile()
  222. for i in xrange(10000):
  223. o = BZ2File(self.filename)
  224. del o
  225. def testOpenNonexistent(self):
  226. # "Test opening a nonexistent file"
  227. self.assertRaises(IOError, BZ2File, "/non/existent")
  228. def testModeU(self):
  229. # Bug #1194181: bz2.BZ2File opened for write with mode "U"
  230. self.createTempFile()
  231. bz2f = BZ2File(self.filename, "U")
  232. bz2f.close()
  233. f = file(self.filename)
  234. f.seek(0, 2)
  235. self.assertEqual(f.tell(), len(self.DATA))
  236. f.close()
  237. def testBug1191043(self):
  238. # readlines() for files containing no newline
  239. data = 'BZh91AY&SY\xd9b\x89]\x00\x00\x00\x03\x80\x04\x00\x02\x00\x0c\x00 \x00!\x9ah3M\x13<]\xc9\x14\xe1BCe\x8a%t'
  240. f = open(self.filename, "wb")
  241. f.write(data)
  242. f.close()
  243. bz2f = BZ2File(self.filename)
  244. lines = bz2f.readlines()
  245. bz2f.close()
  246. self.assertEqual(lines, ['Test'])
  247. bz2f = BZ2File(self.filename)
  248. xlines = list(bz2f.xreadlines())
  249. bz2f.close()
  250. self.assertEqual(xlines, ['Test'])
  251. class BZ2CompressorTest(BaseTest):
  252. def testCompress(self):
  253. # "Test BZ2Compressor.compress()/flush()"
  254. bz2c = BZ2Compressor()
  255. self.assertRaises(TypeError, bz2c.compress)
  256. data = bz2c.compress(self.TEXT)
  257. data += bz2c.flush()
  258. self.assertEqual(self.decompress(data), self.TEXT)
  259. def testCompressChunks10(self):
  260. # "Test BZ2Compressor.compress()/flush() with chunks of 10 bytes"
  261. bz2c = BZ2Compressor()
  262. n = 0
  263. data = ''
  264. while 1:
  265. str = self.TEXT[n*10:(n+1)*10]
  266. if not str:
  267. break
  268. data += bz2c.compress(str)
  269. n += 1
  270. data += bz2c.flush()
  271. self.assertEqual(self.decompress(data), self.TEXT)
  272. class BZ2DecompressorTest(BaseTest):
  273. def test_Constructor(self):
  274. self.assertRaises(TypeError, BZ2Decompressor, 42)
  275. def testDecompress(self):
  276. # "Test BZ2Decompressor.decompress()"
  277. bz2d = BZ2Decompressor()
  278. self.assertRaises(TypeError, bz2d.decompress)
  279. text = bz2d.decompress(self.DATA)
  280. self.assertEqual(text, self.TEXT)
  281. def testDecompressChunks10(self):
  282. # "Test BZ2Decompressor.decompress() with chunks of 10 bytes"
  283. bz2d = BZ2Decompressor()
  284. text = ''
  285. n = 0
  286. while 1:
  287. str = self.DATA[n*10:(n+1)*10]
  288. if not str:
  289. break
  290. text += bz2d.decompress(str)
  291. n += 1
  292. self.assertEqual(text, self.TEXT)
  293. def testDecompressUnusedData(self):
  294. # "Test BZ2Decompressor.decompress() with unused data"
  295. bz2d = BZ2Decompressor()
  296. unused_data = "this is unused data"
  297. text = bz2d.decompress(self.DATA+unused_data)
  298. self.assertEqual(text, self.TEXT)
  299. self.assertEqual(bz2d.unused_data, unused_data)
  300. def testEOFError(self):
  301. # "Calling BZ2Decompressor.decompress() after EOS must raise EOFError"
  302. bz2d = BZ2Decompressor()
  303. text = bz2d.decompress(self.DATA)
  304. self.assertRaises(EOFError, bz2d.decompress, "anything")
  305. class FuncTest(BaseTest):
  306. "Test module functions"
  307. def testCompress(self):
  308. # "Test compress() function"
  309. data = bz2.compress(self.TEXT)
  310. self.assertEqual(self.decompress(data), self.TEXT)
  311. def testDecompress(self):
  312. # "Test decompress() function"
  313. text = bz2.decompress(self.DATA)
  314. self.assertEqual(text, self.TEXT)
  315. def testDecompressEmpty(self):
  316. # "Test decompress() function with empty string"
  317. text = bz2.decompress("")
  318. self.assertEqual(text, "")
  319. def testDecompressIncomplete(self):
  320. # "Test decompress() function with incomplete data"
  321. self.assertRaises(ValueError, bz2.decompress, self.DATA[:-10])
  322. def test_main():
  323. test_support.run_unittest(
  324. BZ2FileTest,
  325. BZ2CompressorTest,
  326. BZ2DecompressorTest,
  327. FuncTest
  328. )
  329. test_support.reap_children()
  330. if __name__ == '__main__':
  331. test_main()
  332. # vim:ts=4:sw=4