home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 June / maximum-cd-2011-06.iso / DiscContents / LibO_3.3.1_Win_x86_install_multi.exe / libreoffice1.cab / test_bz2.py < prev    next >
Encoding:
Python Source  |  2011-02-15  |  14.8 KB  |  385 lines
  1. #!/usr/bin/python
  2. from test import test_support
  3. from test.test_support import TESTFN
  4.  
  5. import unittest
  6. from cStringIO import StringIO
  7. import os
  8. import subprocess
  9. import sys
  10.  
  11. import bz2
  12. from bz2 import BZ2File, BZ2Compressor, BZ2Decompressor
  13.  
  14. has_cmdline_bunzip2 = sys.platform not in ("win32", "os2emx", "riscos")
  15.  
  16. class BaseTest(unittest.TestCase):
  17.     "Base for other testcases."
  18.     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'
  19.     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`'
  20.     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'
  21.  
  22.     if has_cmdline_bunzip2:
  23.         def decompress(self, data):
  24.             pop = subprocess.Popen("bunzip2", shell=True,
  25.                                    stdin=subprocess.PIPE,
  26.                                    stdout=subprocess.PIPE,
  27.                                    stderr=subprocess.STDOUT)
  28.             pop.stdin.write(data)
  29.             pop.stdin.close()
  30.             ret = pop.stdout.read()
  31.             pop.stdout.close()
  32.             if pop.wait() != 0:
  33.                 ret = bz2.decompress(data)
  34.             return ret
  35.  
  36.     else:
  37.         # bunzip2 isn't available to run on Windows.
  38.         def decompress(self, data):
  39.             return bz2.decompress(data)
  40.  
  41. class BZ2FileTest(BaseTest):
  42.     "Test BZ2File type miscellaneous methods."
  43.  
  44.     def setUp(self):
  45.         self.filename = TESTFN
  46.  
  47.     def tearDown(self):
  48.         if os.path.isfile(self.filename):
  49.             os.unlink(self.filename)
  50.  
  51.     def createTempFile(self, crlf=0):
  52.         f = open(self.filename, "wb")
  53.         if crlf:
  54.             data = self.DATA_CRLF
  55.         else:
  56.             data = self.DATA
  57.         f.write(data)
  58.         f.close()
  59.  
  60.     def testRead(self):
  61.         # "Test BZ2File.read()"
  62.         self.createTempFile()
  63.         bz2f = BZ2File(self.filename)
  64.         self.assertRaises(TypeError, bz2f.read, None)
  65.         self.assertEqual(bz2f.read(), self.TEXT)
  66.         bz2f.close()
  67.  
  68.     def testReadChunk10(self):
  69.         # "Test BZ2File.read() in chunks of 10 bytes"
  70.         self.createTempFile()
  71.         bz2f = BZ2File(self.filename)
  72.         text = ''
  73.         while 1:
  74.             str = bz2f.read(10)
  75.             if not str:
  76.                 break
  77.             text += str
  78.         self.assertEqual(text, text)
  79.         bz2f.close()
  80.  
  81.     def testRead100(self):
  82.         # "Test BZ2File.read(100)"
  83.         self.createTempFile()
  84.         bz2f = BZ2File(self.filename)
  85.         self.assertEqual(bz2f.read(100), self.TEXT[:100])
  86.         bz2f.close()
  87.  
  88.     def testReadLine(self):
  89.         # "Test BZ2File.readline()"
  90.         self.createTempFile()
  91.         bz2f = BZ2File(self.filename)
  92.         self.assertRaises(TypeError, bz2f.readline, None)
  93.         sio = StringIO(self.TEXT)
  94.         for line in sio.readlines():
  95.             self.assertEqual(bz2f.readline(), line)
  96.         bz2f.close()
  97.  
  98.     def testReadLines(self):
  99.         # "Test BZ2File.readlines()"
  100.         self.createTempFile()
  101.         bz2f = BZ2File(self.filename)
  102.         self.assertRaises(TypeError, bz2f.readlines, None)
  103.         sio = StringIO(self.TEXT)
  104.         self.assertEqual(bz2f.readlines(), sio.readlines())
  105.         bz2f.close()
  106.  
  107.     def testIterator(self):
  108.         # "Test iter(BZ2File)"
  109.         self.createTempFile()
  110.         bz2f = BZ2File(self.filename)
  111.         sio = StringIO(self.TEXT)
  112.         self.assertEqual(list(iter(bz2f)), sio.readlines())
  113.         bz2f.close()
  114.  
  115.     def testClosedIteratorDeadlock(self):
  116.         # "Test that iteration on a closed bz2file releases the lock."
  117.         # http://bugs.python.org/issue3309
  118.         self.createTempFile()
  119.         bz2f = BZ2File(self.filename)
  120.         bz2f.close()
  121.         self.assertRaises(ValueError, bz2f.next)
  122.         # This call will deadlock of the above .next call failed to
  123.         # release the lock.
  124.         self.assertRaises(ValueError, bz2f.readlines)
  125.  
  126.     def testXReadLines(self):
  127.         # "Test BZ2File.xreadlines()"
  128.         self.createTempFile()
  129.         bz2f = BZ2File(self.filename)
  130.         sio = StringIO(self.TEXT)
  131.         self.assertEqual(list(bz2f.xreadlines()), sio.readlines())
  132.         bz2f.close()
  133.  
  134.     def testUniversalNewlinesLF(self):
  135.         # "Test BZ2File.read() with universal newlines (\\n)"
  136.         self.createTempFile()
  137.         bz2f = BZ2File(self.filename, "rU")
  138.         self.assertEqual(bz2f.read(), self.TEXT)
  139.         self.assertEqual(bz2f.newlines, "\n")
  140.         bz2f.close()
  141.  
  142.     def testUniversalNewlinesCRLF(self):
  143.         # "Test BZ2File.read() with universal newlines (\\r\\n)"
  144.         self.createTempFile(crlf=1)
  145.         bz2f = BZ2File(self.filename, "rU")
  146.         self.assertEqual(bz2f.read(), self.TEXT)
  147.         self.assertEqual(bz2f.newlines, "\r\n")
  148.         bz2f.close()
  149.  
  150.     def testWrite(self):
  151.         # "Test BZ2File.write()"
  152.         bz2f = BZ2File(self.filename, "w")
  153.         self.assertRaises(TypeError, bz2f.write)
  154.         bz2f.write(self.TEXT)
  155.         bz2f.close()
  156.         f = open(self.filename, 'rb')
  157.         self.assertEqual(self.decompress(f.read()), self.TEXT)
  158.         f.close()
  159.  
  160.     def testWriteChunks10(self):
  161.         # "Test BZ2File.write() with chunks of 10 bytes"
  162.         bz2f = BZ2File(self.filename, "w")
  163.         n = 0
  164.         while 1:
  165.             str = self.TEXT[n*10:(n+1)*10]
  166.             if not str:
  167.                 break
  168.             bz2f.write(str)
  169.             n += 1
  170.         bz2f.close()
  171.         f = open(self.filename, 'rb')
  172.         self.assertEqual(self.decompress(f.read()), self.TEXT)
  173.         f.close()
  174.  
  175.     def testWriteLines(self):
  176.         # "Test BZ2File.writelines()"
  177.         bz2f = BZ2File(self.filename, "w")
  178.         self.assertRaises(TypeError, bz2f.writelines)
  179.         sio = StringIO(self.TEXT)
  180.         bz2f.writelines(sio.readlines())
  181.         bz2f.close()
  182.         # patch #1535500
  183.         self.assertRaises(ValueError, bz2f.writelines, ["a"])
  184.         f = open(self.filename, 'rb')
  185.         self.assertEqual(self.decompress(f.read()), self.TEXT)
  186.         f.close()
  187.  
  188.     def testWriteMethodsOnReadOnlyFile(self):
  189.         bz2f = BZ2File(self.filename, "w")
  190.         bz2f.write("abc")
  191.         bz2f.close()
  192.  
  193.         bz2f = BZ2File(self.filename, "r")
  194.         self.assertRaises(IOError, bz2f.write, "a")
  195.         self.assertRaises(IOError, bz2f.writelines, ["a"])
  196.  
  197.     def testSeekForward(self):
  198.         # "Test BZ2File.seek(150, 0)"
  199.         self.createTempFile()
  200.         bz2f = BZ2File(self.filename)
  201.         self.assertRaises(TypeError, bz2f.seek)
  202.         bz2f.seek(150)
  203.         self.assertEqual(bz2f.read(), self.TEXT[150:])
  204.         bz2f.close()
  205.  
  206.     def testSeekBackwards(self):
  207.         # "Test BZ2File.seek(-150, 1)"
  208.         self.createTempFile()
  209.         bz2f = BZ2File(self.filename)
  210.         bz2f.read(500)
  211.         bz2f.seek(-150, 1)
  212.         self.assertEqual(bz2f.read(), self.TEXT[500-150:])
  213.         bz2f.close()
  214.  
  215.     def testSeekBackwardsFromEnd(self):
  216.         # "Test BZ2File.seek(-150, 2)"
  217.         self.createTempFile()
  218.         bz2f = BZ2File(self.filename)
  219.         bz2f.seek(-150, 2)
  220.         self.assertEqual(bz2f.read(), self.TEXT[len(self.TEXT)-150:])
  221.         bz2f.close()
  222.  
  223.     def testSeekPostEnd(self):
  224.         # "Test BZ2File.seek(150000)"
  225.         self.createTempFile()
  226.         bz2f = BZ2File(self.filename)
  227.         bz2f.seek(150000)
  228.         self.assertEqual(bz2f.tell(), len(self.TEXT))
  229.         self.assertEqual(bz2f.read(), "")
  230.         bz2f.close()
  231.  
  232.     def testSeekPostEndTwice(self):
  233.         # "Test BZ2File.seek(150000) twice"
  234.         self.createTempFile()
  235.         bz2f = BZ2File(self.filename)
  236.         bz2f.seek(150000)
  237.         bz2f.seek(150000)
  238.         self.assertEqual(bz2f.tell(), len(self.TEXT))
  239.         self.assertEqual(bz2f.read(), "")
  240.         bz2f.close()
  241.  
  242.     def testSeekPreStart(self):
  243.         # "Test BZ2File.seek(-150, 0)"
  244.         self.createTempFile()
  245.         bz2f = BZ2File(self.filename)
  246.         bz2f.seek(-150)
  247.         self.assertEqual(bz2f.tell(), 0)
  248.         self.assertEqual(bz2f.read(), self.TEXT)
  249.         bz2f.close()
  250.  
  251.     def testOpenDel(self):
  252.         # "Test opening and deleting a file many times"
  253.         self.createTempFile()
  254.         for i in xrange(10000):
  255.             o = BZ2File(self.filename)
  256.             del o
  257.  
  258.     def testOpenNonexistent(self):
  259.         # "Test opening a nonexistent file"
  260.         self.assertRaises(IOError, BZ2File, "/non/existent")
  261.  
  262.     def testModeU(self):
  263.         # Bug #1194181: bz2.BZ2File opened for write with mode "U"
  264.         self.createTempFile()
  265.         bz2f = BZ2File(self.filename, "U")
  266.         bz2f.close()
  267.         f = file(self.filename)
  268.         f.seek(0, 2)
  269.         self.assertEqual(f.tell(), len(self.DATA))
  270.         f.close()
  271.  
  272.     def testBug1191043(self):
  273.         # readlines() for files containing no newline
  274.         data = 'BZh91AY&SY\xd9b\x89]\x00\x00\x00\x03\x80\x04\x00\x02\x00\x0c\x00 \x00!\x9ah3M\x13<]\xc9\x14\xe1BCe\x8a%t'
  275.         f = open(self.filename, "wb")
  276.         f.write(data)
  277.         f.close()
  278.         bz2f = BZ2File(self.filename)
  279.         lines = bz2f.readlines()
  280.         bz2f.close()
  281.         self.assertEqual(lines, ['Test'])
  282.         bz2f = BZ2File(self.filename)
  283.         xlines = list(bz2f.xreadlines())
  284.         bz2f.close()
  285.         self.assertEqual(xlines, ['Test'])
  286.  
  287.  
  288. class BZ2CompressorTest(BaseTest):
  289.     def testCompress(self):
  290.         # "Test BZ2Compressor.compress()/flush()"
  291.         bz2c = BZ2Compressor()
  292.         self.assertRaises(TypeError, bz2c.compress)
  293.         data = bz2c.compress(self.TEXT)
  294.         data += bz2c.flush()
  295.         self.assertEqual(self.decompress(data), self.TEXT)
  296.  
  297.     def testCompressChunks10(self):
  298.         # "Test BZ2Compressor.compress()/flush() with chunks of 10 bytes"
  299.         bz2c = BZ2Compressor()
  300.         n = 0
  301.         data = ''
  302.         while 1:
  303.             str = self.TEXT[n*10:(n+1)*10]
  304.             if not str:
  305.                 break
  306.             data += bz2c.compress(str)
  307.             n += 1
  308.         data += bz2c.flush()
  309.         self.assertEqual(self.decompress(data), self.TEXT)
  310.  
  311. class BZ2DecompressorTest(BaseTest):
  312.     def test_Constructor(self):
  313.         self.assertRaises(TypeError, BZ2Decompressor, 42)
  314.  
  315.     def testDecompress(self):
  316.         # "Test BZ2Decompressor.decompress()"
  317.         bz2d = BZ2Decompressor()
  318.         self.assertRaises(TypeError, bz2d.decompress)
  319.         text = bz2d.decompress(self.DATA)
  320.         self.assertEqual(text, self.TEXT)
  321.  
  322.     def testDecompressChunks10(self):
  323.         # "Test BZ2Decompressor.decompress() with chunks of 10 bytes"
  324.         bz2d = BZ2Decompressor()
  325.         text = ''
  326.         n = 0
  327.         while 1:
  328.             str = self.DATA[n*10:(n+1)*10]
  329.             if not str:
  330.                 break
  331.             text += bz2d.decompress(str)
  332.             n += 1
  333.         self.assertEqual(text, self.TEXT)
  334.  
  335.     def testDecompressUnusedData(self):
  336.         # "Test BZ2Decompressor.decompress() with unused data"
  337.         bz2d = BZ2Decompressor()
  338.         unused_data = "this is unused data"
  339.         text = bz2d.decompress(self.DATA+unused_data)
  340.         self.assertEqual(text, self.TEXT)
  341.         self.assertEqual(bz2d.unused_data, unused_data)
  342.  
  343.     def testEOFError(self):
  344.         # "Calling BZ2Decompressor.decompress() after EOS must raise EOFError"
  345.         bz2d = BZ2Decompressor()
  346.         text = bz2d.decompress(self.DATA)
  347.         self.assertRaises(EOFError, bz2d.decompress, "anything")
  348.  
  349.  
  350. class FuncTest(BaseTest):
  351.     "Test module functions"
  352.  
  353.     def testCompress(self):
  354.         # "Test compress() function"
  355.         data = bz2.compress(self.TEXT)
  356.         self.assertEqual(self.decompress(data), self.TEXT)
  357.  
  358.     def testDecompress(self):
  359.         # "Test decompress() function"
  360.         text = bz2.decompress(self.DATA)
  361.         self.assertEqual(text, self.TEXT)
  362.  
  363.     def testDecompressEmpty(self):
  364.         # "Test decompress() function with empty string"
  365.         text = bz2.decompress("")
  366.         self.assertEqual(text, "")
  367.  
  368.     def testDecompressIncomplete(self):
  369.         # "Test decompress() function with incomplete data"
  370.         self.assertRaises(ValueError, bz2.decompress, self.DATA[:-10])
  371.  
  372. def test_main():
  373.     test_support.run_unittest(
  374.         BZ2FileTest,
  375.         BZ2CompressorTest,
  376.         BZ2DecompressorTest,
  377.         FuncTest
  378.     )
  379.     test_support.reap_children()
  380.  
  381. if __name__ == '__main__':
  382.     test_main()
  383.  
  384. # vim:ts=4:sw=4
  385.