home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 July / maximum-cd-2011-07.iso / DiscContents / LibO_3.3.2_Win_x86_install_multi.exe / libreoffice1.cab / test_zipfile.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  38.7 KB  |  1,097 lines
  1. # We can test part of the module without zlib.
  2. try:
  3.     import zlib
  4. except ImportError:
  5.     zlib = None
  6.  
  7. import zipfile, os, unittest, sys, shutil, struct
  8.  
  9. from StringIO import StringIO
  10. from tempfile import TemporaryFile
  11. from random import randint, random
  12.  
  13. import test.test_support as support
  14. from test.test_support import TESTFN, run_unittest
  15.  
  16. TESTFN2 = TESTFN + "2"
  17. FIXEDTEST_SIZE = 1000
  18.  
  19. SMALL_TEST_DATA = [('_ziptest1', '1q2w3e4r5t'),
  20.                    ('ziptest2dir/_ziptest2', 'qawsedrftg'),
  21.                    ('/ziptest2dir/ziptest3dir/_ziptest3', 'azsxdcfvgb'),
  22.                    ('ziptest2dir/ziptest3dir/ziptest4dir/_ziptest3', '6y7u8i9o0p')]
  23.  
  24. class TestsWithSourceFile(unittest.TestCase):
  25.     def setUp(self):
  26.         self.line_gen = ["Zipfile test line %d. random float: %f" % (i, random())
  27.                           for i in xrange(FIXEDTEST_SIZE)]
  28.         self.data = '\n'.join(self.line_gen) + '\n'
  29.  
  30.         # Make a source file with some lines
  31.         fp = open(TESTFN, "wb")
  32.         fp.write(self.data)
  33.         fp.close()
  34.  
  35.     def makeTestArchive(self, f, compression):
  36.         # Create the ZIP archive
  37.         zipfp = zipfile.ZipFile(f, "w", compression)
  38.         zipfp.write(TESTFN, "another"+os.extsep+"name")
  39.         zipfp.write(TESTFN, TESTFN)
  40.         zipfp.writestr("strfile", self.data)
  41.         zipfp.close()
  42.  
  43.     def zipTest(self, f, compression):
  44.         self.makeTestArchive(f, compression)
  45.  
  46.         # Read the ZIP archive
  47.         zipfp = zipfile.ZipFile(f, "r", compression)
  48.         self.assertEqual(zipfp.read(TESTFN), self.data)
  49.         self.assertEqual(zipfp.read("another"+os.extsep+"name"), self.data)
  50.         self.assertEqual(zipfp.read("strfile"), self.data)
  51.  
  52.         # Print the ZIP directory
  53.         fp = StringIO()
  54.         stdout = sys.stdout
  55.         try:
  56.             sys.stdout = fp
  57.  
  58.             zipfp.printdir()
  59.         finally:
  60.             sys.stdout = stdout
  61.  
  62.         directory = fp.getvalue()
  63.         lines = directory.splitlines()
  64.         self.assertEquals(len(lines), 4) # Number of files + header
  65.  
  66.         self.assert_('File Name' in lines[0])
  67.         self.assert_('Modified' in lines[0])
  68.         self.assert_('Size' in lines[0])
  69.  
  70.         fn, date, time, size = lines[1].split()
  71.         self.assertEquals(fn, 'another.name')
  72.         # XXX: timestamp is not tested
  73.         self.assertEquals(size, str(len(self.data)))
  74.  
  75.         # Check the namelist
  76.         names = zipfp.namelist()
  77.         self.assertEquals(len(names), 3)
  78.         self.assert_(TESTFN in names)
  79.         self.assert_("another"+os.extsep+"name" in names)
  80.         self.assert_("strfile" in names)
  81.  
  82.         # Check infolist
  83.         infos = zipfp.infolist()
  84.         names = [ i.filename for i in infos ]
  85.         self.assertEquals(len(names), 3)
  86.         self.assert_(TESTFN in names)
  87.         self.assert_("another"+os.extsep+"name" in names)
  88.         self.assert_("strfile" in names)
  89.         for i in infos:
  90.             self.assertEquals(i.file_size, len(self.data))
  91.  
  92.         # check getinfo
  93.         for nm in (TESTFN, "another"+os.extsep+"name", "strfile"):
  94.             info = zipfp.getinfo(nm)
  95.             self.assertEquals(info.filename, nm)
  96.             self.assertEquals(info.file_size, len(self.data))
  97.  
  98.         # Check that testzip doesn't raise an exception
  99.         zipfp.testzip()
  100.         zipfp.close()
  101.  
  102.     def testStored(self):
  103.         for f in (TESTFN2, TemporaryFile(), StringIO()):
  104.             self.zipTest(f, zipfile.ZIP_STORED)
  105.  
  106.     def zipOpenTest(self, f, compression):
  107.         self.makeTestArchive(f, compression)
  108.  
  109.         # Read the ZIP archive
  110.         zipfp = zipfile.ZipFile(f, "r", compression)
  111.         zipdata1 = []
  112.         zipopen1 = zipfp.open(TESTFN)
  113.         while 1:
  114.             read_data = zipopen1.read(256)
  115.             if not read_data:
  116.                 break
  117.             zipdata1.append(read_data)
  118.  
  119.         zipdata2 = []
  120.         zipopen2 = zipfp.open("another"+os.extsep+"name")
  121.         while 1:
  122.             read_data = zipopen2.read(256)
  123.             if not read_data:
  124.                 break
  125.             zipdata2.append(read_data)
  126.  
  127.         self.assertEqual(''.join(zipdata1), self.data)
  128.         self.assertEqual(''.join(zipdata2), self.data)
  129.         zipfp.close()
  130.  
  131.     def testOpenStored(self):
  132.         for f in (TESTFN2, TemporaryFile(), StringIO()):
  133.             self.zipOpenTest(f, zipfile.ZIP_STORED)
  134.  
  135.     def testOpenViaZipInfo(self):
  136.         # Create the ZIP archive
  137.         zipfp = zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED)
  138.         zipfp.writestr("name", "foo")
  139.         zipfp.writestr("name", "bar")
  140.         zipfp.close()
  141.  
  142.         zipfp = zipfile.ZipFile(TESTFN2, "r")
  143.         infos = zipfp.infolist()
  144.         data = ""
  145.         for info in infos:
  146.             data += zipfp.open(info).read()
  147.         self.assert_(data == "foobar" or data == "barfoo")
  148.         data = ""
  149.         for info in infos:
  150.             data += zipfp.read(info)
  151.         self.assert_(data == "foobar" or data == "barfoo")
  152.         zipfp.close()
  153.  
  154.     def zipRandomOpenTest(self, f, compression):
  155.         self.makeTestArchive(f, compression)
  156.  
  157.         # Read the ZIP archive
  158.         zipfp = zipfile.ZipFile(f, "r", compression)
  159.         zipdata1 = []
  160.         zipopen1 = zipfp.open(TESTFN)
  161.         while 1:
  162.             read_data = zipopen1.read(randint(1, 1024))
  163.             if not read_data:
  164.                 break
  165.             zipdata1.append(read_data)
  166.  
  167.         self.assertEqual(''.join(zipdata1), self.data)
  168.         zipfp.close()
  169.  
  170.     def testRandomOpenStored(self):
  171.         for f in (TESTFN2, TemporaryFile(), StringIO()):
  172.             self.zipRandomOpenTest(f, zipfile.ZIP_STORED)
  173.  
  174.     def zipReadlineTest(self, f, compression):
  175.         self.makeTestArchive(f, compression)
  176.  
  177.         # Read the ZIP archive
  178.         zipfp = zipfile.ZipFile(f, "r")
  179.         zipopen = zipfp.open(TESTFN)
  180.         for line in self.line_gen:
  181.             linedata = zipopen.readline()
  182.             self.assertEqual(linedata, line + '\n')
  183.  
  184.         zipfp.close()
  185.  
  186.     def zipReadlinesTest(self, f, compression):
  187.         self.makeTestArchive(f, compression)
  188.  
  189.         # Read the ZIP archive
  190.         zipfp = zipfile.ZipFile(f, "r")
  191.         ziplines = zipfp.open(TESTFN).readlines()
  192.         for line, zipline in zip(self.line_gen, ziplines):
  193.             self.assertEqual(zipline, line + '\n')
  194.  
  195.         zipfp.close()
  196.  
  197.     def zipIterlinesTest(self, f, compression):
  198.         self.makeTestArchive(f, compression)
  199.  
  200.         # Read the ZIP archive
  201.         zipfp = zipfile.ZipFile(f, "r")
  202.         for line, zipline in zip(self.line_gen, zipfp.open(TESTFN)):
  203.             self.assertEqual(zipline, line + '\n')
  204.  
  205.         zipfp.close()
  206.  
  207.     def testReadlineStored(self):
  208.         for f in (TESTFN2, TemporaryFile(), StringIO()):
  209.             self.zipReadlineTest(f, zipfile.ZIP_STORED)
  210.  
  211.     def testReadlinesStored(self):
  212.         for f in (TESTFN2, TemporaryFile(), StringIO()):
  213.             self.zipReadlinesTest(f, zipfile.ZIP_STORED)
  214.  
  215.     def testIterlinesStored(self):
  216.         for f in (TESTFN2, TemporaryFile(), StringIO()):
  217.             self.zipIterlinesTest(f, zipfile.ZIP_STORED)
  218.  
  219.     if zlib:
  220.         def testDeflated(self):
  221.             for f in (TESTFN2, TemporaryFile(), StringIO()):
  222.                 self.zipTest(f, zipfile.ZIP_DEFLATED)
  223.  
  224.         def testOpenDeflated(self):
  225.             for f in (TESTFN2, TemporaryFile(), StringIO()):
  226.                 self.zipOpenTest(f, zipfile.ZIP_DEFLATED)
  227.  
  228.         def testRandomOpenDeflated(self):
  229.             for f in (TESTFN2, TemporaryFile(), StringIO()):
  230.                 self.zipRandomOpenTest(f, zipfile.ZIP_DEFLATED)
  231.  
  232.         def testReadlineDeflated(self):
  233.             for f in (TESTFN2, TemporaryFile(), StringIO()):
  234.                 self.zipReadlineTest(f, zipfile.ZIP_DEFLATED)
  235.  
  236.         def testReadlinesDeflated(self):
  237.             for f in (TESTFN2, TemporaryFile(), StringIO()):
  238.                 self.zipReadlinesTest(f, zipfile.ZIP_DEFLATED)
  239.  
  240.         def testIterlinesDeflated(self):
  241.             for f in (TESTFN2, TemporaryFile(), StringIO()):
  242.                 self.zipIterlinesTest(f, zipfile.ZIP_DEFLATED)
  243.  
  244.         def testLowCompression(self):
  245.             # Checks for cases where compressed data is larger than original
  246.             # Create the ZIP archive
  247.             zipfp = zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_DEFLATED)
  248.             zipfp.writestr("strfile", '12')
  249.             zipfp.close()
  250.  
  251.             # Get an open object for strfile
  252.             zipfp = zipfile.ZipFile(TESTFN2, "r", zipfile.ZIP_DEFLATED)
  253.             openobj = zipfp.open("strfile")
  254.             self.assertEqual(openobj.read(1), '1')
  255.             self.assertEqual(openobj.read(1), '2')
  256.  
  257.     def testAbsoluteArcnames(self):
  258.         zipfp = zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED)
  259.         zipfp.write(TESTFN, "/absolute")
  260.         zipfp.close()
  261.  
  262.         zipfp = zipfile.ZipFile(TESTFN2, "r", zipfile.ZIP_STORED)
  263.         self.assertEqual(zipfp.namelist(), ["absolute"])
  264.         zipfp.close()
  265.  
  266.     def testAppendToZipFile(self):
  267.         # Test appending to an existing zipfile
  268.         zipfp = zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED)
  269.         zipfp.write(TESTFN, TESTFN)
  270.         zipfp.close()
  271.         zipfp = zipfile.ZipFile(TESTFN2, "a", zipfile.ZIP_STORED)
  272.         zipfp.writestr("strfile", self.data)
  273.         self.assertEqual(zipfp.namelist(), [TESTFN, "strfile"])
  274.         zipfp.close()
  275.  
  276.     def testAppendToNonZipFile(self):
  277.         # Test appending to an existing file that is not a zipfile
  278.         # NOTE: this test fails if len(d) < 22 because of the first
  279.         # line "fpin.seek(-22, 2)" in _EndRecData
  280.         d = 'I am not a ZipFile!'*10
  281.         f = file(TESTFN2, 'wb')
  282.         f.write(d)
  283.         f.close()
  284.         zipfp = zipfile.ZipFile(TESTFN2, "a", zipfile.ZIP_STORED)
  285.         zipfp.write(TESTFN, TESTFN)
  286.         zipfp.close()
  287.  
  288.         f = file(TESTFN2, 'rb')
  289.         f.seek(len(d))
  290.         zipfp = zipfile.ZipFile(f, "r")
  291.         self.assertEqual(zipfp.namelist(), [TESTFN])
  292.         zipfp.close()
  293.         f.close()
  294.  
  295.     def test_WriteDefaultName(self):
  296.         # Check that calling ZipFile.write without arcname specified produces the expected result
  297.         zipfp = zipfile.ZipFile(TESTFN2, "w")
  298.         zipfp.write(TESTFN)
  299.         self.assertEqual(zipfp.read(TESTFN), file(TESTFN).read())
  300.         zipfp.close()
  301.  
  302.     def test_PerFileCompression(self):
  303.         # Check that files within a Zip archive can have different compression options
  304.         zipfp = zipfile.ZipFile(TESTFN2, "w")
  305.         zipfp.write(TESTFN, 'storeme', zipfile.ZIP_STORED)
  306.         zipfp.write(TESTFN, 'deflateme', zipfile.ZIP_DEFLATED)
  307.         sinfo = zipfp.getinfo('storeme')
  308.         dinfo = zipfp.getinfo('deflateme')
  309.         self.assertEqual(sinfo.compress_type, zipfile.ZIP_STORED)
  310.         self.assertEqual(dinfo.compress_type, zipfile.ZIP_DEFLATED)
  311.         zipfp.close()
  312.  
  313.     def test_WriteToReadonly(self):
  314.         # Check that trying to call write() on a readonly ZipFile object
  315.         # raises a RuntimeError
  316.         zipf = zipfile.ZipFile(TESTFN2, mode="w")
  317.         zipf.writestr("somefile.txt", "bogus")
  318.         zipf.close()
  319.         zipf = zipfile.ZipFile(TESTFN2, mode="r")
  320.         self.assertRaises(RuntimeError, zipf.write, TESTFN)
  321.         zipf.close()
  322.  
  323.     def testExtract(self):
  324.         zipfp = zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED)
  325.         for fpath, fdata in SMALL_TEST_DATA:
  326.             zipfp.writestr(fpath, fdata)
  327.         zipfp.close()
  328.  
  329.         zipfp = zipfile.ZipFile(TESTFN2, "r")
  330.         for fpath, fdata in SMALL_TEST_DATA:
  331.             writtenfile = zipfp.extract(fpath)
  332.  
  333.             # make sure it was written to the right place
  334.             if os.path.isabs(fpath):
  335.                 correctfile = os.path.join(os.getcwd(), fpath[1:])
  336.             else:
  337.                 correctfile = os.path.join(os.getcwd(), fpath)
  338.             correctfile = os.path.normpath(correctfile)
  339.  
  340.             self.assertEqual(writtenfile, correctfile)
  341.  
  342.             # make sure correct data is in correct file
  343.             self.assertEqual(fdata, file(writtenfile, "rb").read())
  344.  
  345.             os.remove(writtenfile)
  346.  
  347.         zipfp.close()
  348.  
  349.         # remove the test file subdirectories
  350.         shutil.rmtree(os.path.join(os.getcwd(), 'ziptest2dir'))
  351.  
  352.     def testExtractAll(self):
  353.         zipfp = zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED)
  354.         for fpath, fdata in SMALL_TEST_DATA:
  355.             zipfp.writestr(fpath, fdata)
  356.         zipfp.close()
  357.  
  358.         zipfp = zipfile.ZipFile(TESTFN2, "r")
  359.         zipfp.extractall()
  360.         for fpath, fdata in SMALL_TEST_DATA:
  361.             if os.path.isabs(fpath):
  362.                 outfile = os.path.join(os.getcwd(), fpath[1:])
  363.             else:
  364.                 outfile = os.path.join(os.getcwd(), fpath)
  365.  
  366.             self.assertEqual(fdata, file(outfile, "rb").read())
  367.  
  368.             os.remove(outfile)
  369.  
  370.         zipfp.close()
  371.  
  372.         # remove the test file subdirectories
  373.         shutil.rmtree(os.path.join(os.getcwd(), 'ziptest2dir'))
  374.  
  375.     def zip_test_writestr_permissions(self, f, compression):
  376.         # Make sure that writestr creates files with mode 0600,
  377.         # when it is passed a name rather than a ZipInfo instance.
  378.  
  379.         self.makeTestArchive(f, compression)
  380.         zipfp = zipfile.ZipFile(f, "r")
  381.         zinfo = zipfp.getinfo('strfile')
  382.         self.assertEqual(zinfo.external_attr, 0600 << 16)
  383.  
  384.     def test_writestr_permissions(self):
  385.         for f in (TESTFN2, TemporaryFile(), StringIO()):
  386.             self.zip_test_writestr_permissions(f, zipfile.ZIP_STORED)
  387.  
  388.     def tearDown(self):
  389.         os.remove(TESTFN)
  390.         os.remove(TESTFN2)
  391.  
  392. class TestZip64InSmallFiles(unittest.TestCase):
  393.     # These tests test the ZIP64 functionality without using large files,
  394.     # see test_zipfile64 for proper tests.
  395.  
  396.     def setUp(self):
  397.         self._limit = zipfile.ZIP64_LIMIT
  398.         zipfile.ZIP64_LIMIT = 5
  399.  
  400.         line_gen = ("Test of zipfile line %d." % i for i in range(0, FIXEDTEST_SIZE))
  401.         self.data = '\n'.join(line_gen)
  402.  
  403.         # Make a source file with some lines
  404.         fp = open(TESTFN, "wb")
  405.         fp.write(self.data)
  406.         fp.close()
  407.  
  408.     def largeFileExceptionTest(self, f, compression):
  409.         zipfp = zipfile.ZipFile(f, "w", compression)
  410.         self.assertRaises(zipfile.LargeZipFile,
  411.                 zipfp.write, TESTFN, "another"+os.extsep+"name")
  412.         zipfp.close()
  413.  
  414.     def largeFileExceptionTest2(self, f, compression):
  415.         zipfp = zipfile.ZipFile(f, "w", compression)
  416.         self.assertRaises(zipfile.LargeZipFile,
  417.                 zipfp.writestr, "another"+os.extsep+"name", self.data)
  418.         zipfp.close()
  419.  
  420.     def testLargeFileException(self):
  421.         for f in (TESTFN2, TemporaryFile(), StringIO()):
  422.             self.largeFileExceptionTest(f, zipfile.ZIP_STORED)
  423.             self.largeFileExceptionTest2(f, zipfile.ZIP_STORED)
  424.  
  425.     def zipTest(self, f, compression):
  426.         # Create the ZIP archive
  427.         zipfp = zipfile.ZipFile(f, "w", compression, allowZip64=True)
  428.         zipfp.write(TESTFN, "another"+os.extsep+"name")
  429.         zipfp.write(TESTFN, TESTFN)
  430.         zipfp.writestr("strfile", self.data)
  431.         zipfp.close()
  432.  
  433.         # Read the ZIP archive
  434.         zipfp = zipfile.ZipFile(f, "r", compression)
  435.         self.assertEqual(zipfp.read(TESTFN), self.data)
  436.         self.assertEqual(zipfp.read("another"+os.extsep+"name"), self.data)
  437.         self.assertEqual(zipfp.read("strfile"), self.data)
  438.  
  439.         # Print the ZIP directory
  440.         fp = StringIO()
  441.         stdout = sys.stdout
  442.         try:
  443.             sys.stdout = fp
  444.  
  445.             zipfp.printdir()
  446.         finally:
  447.             sys.stdout = stdout
  448.  
  449.         directory = fp.getvalue()
  450.         lines = directory.splitlines()
  451.         self.assertEquals(len(lines), 4) # Number of files + header
  452.  
  453.         self.assert_('File Name' in lines[0])
  454.         self.assert_('Modified' in lines[0])
  455.         self.assert_('Size' in lines[0])
  456.  
  457.         fn, date, time, size = lines[1].split()
  458.         self.assertEquals(fn, 'another.name')
  459.         # XXX: timestamp is not tested
  460.         self.assertEquals(size, str(len(self.data)))
  461.  
  462.         # Check the namelist
  463.         names = zipfp.namelist()
  464.         self.assertEquals(len(names), 3)
  465.         self.assert_(TESTFN in names)
  466.         self.assert_("another"+os.extsep+"name" in names)
  467.         self.assert_("strfile" in names)
  468.  
  469.         # Check infolist
  470.         infos = zipfp.infolist()
  471.         names = [ i.filename for i in infos ]
  472.         self.assertEquals(len(names), 3)
  473.         self.assert_(TESTFN in names)
  474.         self.assert_("another"+os.extsep+"name" in names)
  475.         self.assert_("strfile" in names)
  476.         for i in infos:
  477.             self.assertEquals(i.file_size, len(self.data))
  478.  
  479.         # check getinfo
  480.         for nm in (TESTFN, "another"+os.extsep+"name", "strfile"):
  481.             info = zipfp.getinfo(nm)
  482.             self.assertEquals(info.filename, nm)
  483.             self.assertEquals(info.file_size, len(self.data))
  484.  
  485.         # Check that testzip doesn't raise an exception
  486.         zipfp.testzip()
  487.  
  488.  
  489.         zipfp.close()
  490.  
  491.     def testStored(self):
  492.         for f in (TESTFN2, TemporaryFile(), StringIO()):
  493.             self.zipTest(f, zipfile.ZIP_STORED)
  494.  
  495.  
  496.     if zlib:
  497.         def testDeflated(self):
  498.             for f in (TESTFN2, TemporaryFile(), StringIO()):
  499.                 self.zipTest(f, zipfile.ZIP_DEFLATED)
  500.  
  501.     def testAbsoluteArcnames(self):
  502.         zipfp = zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED, allowZip64=True)
  503.         zipfp.write(TESTFN, "/absolute")
  504.         zipfp.close()
  505.  
  506.         zipfp = zipfile.ZipFile(TESTFN2, "r", zipfile.ZIP_STORED)
  507.         self.assertEqual(zipfp.namelist(), ["absolute"])
  508.         zipfp.close()
  509.  
  510.     def tearDown(self):
  511.         zipfile.ZIP64_LIMIT = self._limit
  512.         os.remove(TESTFN)
  513.         os.remove(TESTFN2)
  514.  
  515. class PyZipFileTests(unittest.TestCase):
  516.     def testWritePyfile(self):
  517.         zipfp  = zipfile.PyZipFile(TemporaryFile(), "w")
  518.         fn = __file__
  519.         if fn.endswith('.pyc') or fn.endswith('.pyo'):
  520.             fn = fn[:-1]
  521.  
  522.         zipfp.writepy(fn)
  523.  
  524.         bn = os.path.basename(fn)
  525.         self.assert_(bn not in zipfp.namelist())
  526.         self.assert_(bn + 'o' in zipfp.namelist() or bn + 'c' in zipfp.namelist())
  527.         zipfp.close()
  528.  
  529.  
  530.         zipfp  = zipfile.PyZipFile(TemporaryFile(), "w")
  531.         fn = __file__
  532.         if fn.endswith('.pyc') or fn.endswith('.pyo'):
  533.             fn = fn[:-1]
  534.  
  535.         zipfp.writepy(fn, "testpackage")
  536.  
  537.         bn = "%s/%s"%("testpackage", os.path.basename(fn))
  538.         self.assert_(bn not in zipfp.namelist())
  539.         self.assert_(bn + 'o' in zipfp.namelist() or bn + 'c' in zipfp.namelist())
  540.         zipfp.close()
  541.  
  542.     def testWritePythonPackage(self):
  543.         import email
  544.         packagedir = os.path.dirname(email.__file__)
  545.  
  546.         zipfp  = zipfile.PyZipFile(TemporaryFile(), "w")
  547.         zipfp.writepy(packagedir)
  548.  
  549.         # Check for a couple of modules at different levels of the hieararchy
  550.         names = zipfp.namelist()
  551.         self.assert_('email/__init__.pyo' in names or 'email/__init__.pyc' in names)
  552.         self.assert_('email/mime/text.pyo' in names or 'email/mime/text.pyc' in names)
  553.  
  554.     def testWritePythonDirectory(self):
  555.         os.mkdir(TESTFN2)
  556.         try:
  557.             fp = open(os.path.join(TESTFN2, "mod1.py"), "w")
  558.             fp.write("print 42\n")
  559.             fp.close()
  560.  
  561.             fp = open(os.path.join(TESTFN2, "mod2.py"), "w")
  562.             fp.write("print 42 * 42\n")
  563.             fp.close()
  564.  
  565.             fp = open(os.path.join(TESTFN2, "mod2.txt"), "w")
  566.             fp.write("bla bla bla\n")
  567.             fp.close()
  568.  
  569.             zipfp  = zipfile.PyZipFile(TemporaryFile(), "w")
  570.             zipfp.writepy(TESTFN2)
  571.  
  572.             names = zipfp.namelist()
  573.             self.assert_('mod1.pyc' in names or 'mod1.pyo' in names)
  574.             self.assert_('mod2.pyc' in names or 'mod2.pyo' in names)
  575.             self.assert_('mod2.txt' not in names)
  576.  
  577.         finally:
  578.             shutil.rmtree(TESTFN2)
  579.  
  580.     def testWriteNonPyfile(self):
  581.         zipfp  = zipfile.PyZipFile(TemporaryFile(), "w")
  582.         file(TESTFN, 'w').write('most definitely not a python file')
  583.         self.assertRaises(RuntimeError, zipfp.writepy, TESTFN)
  584.         os.remove(TESTFN)
  585.  
  586.  
  587. class OtherTests(unittest.TestCase):
  588.     def testUnicodeFilenames(self):
  589.         zf = zipfile.ZipFile(TESTFN, "w")
  590.         zf.writestr(u"foo.txt", "Test for unicode filename")
  591.         zf.writestr(u"\xf6.txt", "Test for unicode filename")
  592.         self.assertTrue(isinstance(zf.infolist()[0].filename, unicode))
  593.         zf.close()
  594.         zf = zipfile.ZipFile(TESTFN, "r")
  595.         self.assertEqual(zf.filelist[0].filename, "foo.txt")
  596.         self.assertEqual(zf.filelist[1].filename, u"\xf6.txt")
  597.         zf.close()
  598.  
  599.     def testCreateNonExistentFileForAppend(self):
  600.         if os.path.exists(TESTFN):
  601.             os.unlink(TESTFN)
  602.  
  603.         filename = 'testfile.txt'
  604.         content = 'hello, world. this is some content.'
  605.  
  606.         try:
  607.             zf = zipfile.ZipFile(TESTFN, 'a')
  608.             zf.writestr(filename, content)
  609.             zf.close()
  610.         except IOError, (errno, errmsg):
  611.             self.fail('Could not append data to a non-existent zip file.')
  612.  
  613.         self.assert_(os.path.exists(TESTFN))
  614.  
  615.         zf = zipfile.ZipFile(TESTFN, 'r')
  616.         self.assertEqual(zf.read(filename), content)
  617.         zf.close()
  618.  
  619.     def testCloseErroneousFile(self):
  620.         # This test checks that the ZipFile constructor closes the file object
  621.         # it opens if there's an error in the file.  If it doesn't, the traceback
  622.         # holds a reference to the ZipFile object and, indirectly, the file object.
  623.         # On Windows, this causes the os.unlink() call to fail because the
  624.         # underlying file is still open.  This is SF bug #412214.
  625.         #
  626.         fp = open(TESTFN, "w")
  627.         fp.write("this is not a legal zip file\n")
  628.         fp.close()
  629.         try:
  630.             zf = zipfile.ZipFile(TESTFN)
  631.         except zipfile.BadZipfile:
  632.             pass
  633.  
  634.     def testIsZipErroneousFile(self):
  635.         # This test checks that the is_zipfile function correctly identifies
  636.         # a file that is not a zip file
  637.         fp = open(TESTFN, "w")
  638.         fp.write("this is not a legal zip file\n")
  639.         fp.close()
  640.         chk = zipfile.is_zipfile(TESTFN)
  641.         self.assert_(chk is False)
  642.  
  643.     def testIsZipValidFile(self):
  644.         # This test checks that the is_zipfile function correctly identifies
  645.         # a file that is a zip file
  646.         zipf = zipfile.ZipFile(TESTFN, mode="w")
  647.         zipf.writestr("foo.txt", "O, for a Muse of Fire!")
  648.         zipf.close()
  649.         chk = zipfile.is_zipfile(TESTFN)
  650.         self.assert_(chk is True)
  651.  
  652.     def testNonExistentFileRaisesIOError(self):
  653.         # make sure we don't raise an AttributeError when a partially-constructed
  654.         # ZipFile instance is finalized; this tests for regression on SF tracker
  655.         # bug #403871.
  656.  
  657.         # The bug we're testing for caused an AttributeError to be raised
  658.         # when a ZipFile instance was created for a file that did not
  659.         # exist; the .fp member was not initialized but was needed by the
  660.         # __del__() method.  Since the AttributeError is in the __del__(),
  661.         # it is ignored, but the user should be sufficiently annoyed by
  662.         # the message on the output that regression will be noticed
  663.         # quickly.
  664.         self.assertRaises(IOError, zipfile.ZipFile, TESTFN)
  665.  
  666.     def testClosedZipRaisesRuntimeError(self):
  667.         # Verify that testzip() doesn't swallow inappropriate exceptions.
  668.         data = StringIO()
  669.         zipf = zipfile.ZipFile(data, mode="w")
  670.         zipf.writestr("foo.txt", "O, for a Muse of Fire!")
  671.         zipf.close()
  672.  
  673.         # This is correct; calling .read on a closed ZipFile should throw
  674.         # a RuntimeError, and so should calling .testzip.  An earlier
  675.         # version of .testzip would swallow this exception (and any other)
  676.         # and report that the first file in the archive was corrupt.
  677.         self.assertRaises(RuntimeError, zipf.read, "foo.txt")
  678.         self.assertRaises(RuntimeError, zipf.open, "foo.txt")
  679.         self.assertRaises(RuntimeError, zipf.testzip)
  680.         self.assertRaises(RuntimeError, zipf.writestr, "bogus.txt", "bogus")
  681.         file(TESTFN, 'w').write('zipfile test data')
  682.         self.assertRaises(RuntimeError, zipf.write, TESTFN)
  683.  
  684.     def test_BadConstructorMode(self):
  685.         # Check that bad modes passed to ZipFile constructor are caught
  686.         self.assertRaises(RuntimeError, zipfile.ZipFile, TESTFN, "q")
  687.  
  688.     def test_BadOpenMode(self):
  689.         # Check that bad modes passed to ZipFile.open are caught
  690.         zipf = zipfile.ZipFile(TESTFN, mode="w")
  691.         zipf.writestr("foo.txt", "O, for a Muse of Fire!")
  692.         zipf.close()
  693.         zipf = zipfile.ZipFile(TESTFN, mode="r")
  694.         # read the data to make sure the file is there
  695.         zipf.read("foo.txt")
  696.         self.assertRaises(RuntimeError, zipf.open, "foo.txt", "q")
  697.         zipf.close()
  698.  
  699.     def test_Read0(self):
  700.         # Check that calling read(0) on a ZipExtFile object returns an empty
  701.         # string and doesn't advance file pointer
  702.         zipf = zipfile.ZipFile(TESTFN, mode="w")
  703.         zipf.writestr("foo.txt", "O, for a Muse of Fire!")
  704.         # read the data to make sure the file is there
  705.         f = zipf.open("foo.txt")
  706.         for i in xrange(FIXEDTEST_SIZE):
  707.             self.assertEqual(f.read(0), '')
  708.  
  709.         self.assertEqual(f.read(), "O, for a Muse of Fire!")
  710.         zipf.close()
  711.  
  712.     def test_OpenNonexistentItem(self):
  713.         # Check that attempting to call open() for an item that doesn't
  714.         # exist in the archive raises a RuntimeError
  715.         zipf = zipfile.ZipFile(TESTFN, mode="w")
  716.         self.assertRaises(KeyError, zipf.open, "foo.txt", "r")
  717.  
  718.     def test_BadCompressionMode(self):
  719.         # Check that bad compression methods passed to ZipFile.open are caught
  720.         self.assertRaises(RuntimeError, zipfile.ZipFile, TESTFN, "w", -1)
  721.  
  722.     def test_NullByteInFilename(self):
  723.         # Check that a filename containing a null byte is properly terminated
  724.         zipf = zipfile.ZipFile(TESTFN, mode="w")
  725.         zipf.writestr("foo.txt\x00qqq", "O, for a Muse of Fire!")
  726.         self.assertEqual(zipf.namelist(), ['foo.txt'])
  727.  
  728.     def test_StructSizes(self):
  729.         # check that ZIP internal structure sizes are calculated correctly
  730.         self.assertEqual(zipfile.sizeEndCentDir, 22)
  731.         self.assertEqual(zipfile.sizeCentralDir, 46)
  732.         self.assertEqual(zipfile.sizeEndCentDir64, 56)
  733.         self.assertEqual(zipfile.sizeEndCentDir64Locator, 20)
  734.  
  735.     def testComments(self):
  736.         # This test checks that comments on the archive are handled properly
  737.  
  738.         # check default comment is empty
  739.         zipf = zipfile.ZipFile(TESTFN, mode="w")
  740.         self.assertEqual(zipf.comment, '')
  741.         zipf.writestr("foo.txt", "O, for a Muse of Fire!")
  742.         zipf.close()
  743.         zipfr = zipfile.ZipFile(TESTFN, mode="r")
  744.         self.assertEqual(zipfr.comment, '')
  745.         zipfr.close()
  746.  
  747.         # check a simple short comment
  748.         comment = 'Bravely taking to his feet, he beat a very brave retreat.'
  749.         zipf = zipfile.ZipFile(TESTFN, mode="w")
  750.         zipf.comment = comment
  751.         zipf.writestr("foo.txt", "O, for a Muse of Fire!")
  752.         zipf.close()
  753.         zipfr = zipfile.ZipFile(TESTFN, mode="r")
  754.         self.assertEqual(zipfr.comment, comment)
  755.         zipfr.close()
  756.  
  757.         # check a comment of max length
  758.         comment2 = ''.join(['%d' % (i**3 % 10) for i in xrange((1 << 16)-1)])
  759.         zipf = zipfile.ZipFile(TESTFN, mode="w")
  760.         zipf.comment = comment2
  761.         zipf.writestr("foo.txt", "O, for a Muse of Fire!")
  762.         zipf.close()
  763.         zipfr = zipfile.ZipFile(TESTFN, mode="r")
  764.         self.assertEqual(zipfr.comment, comment2)
  765.         zipfr.close()
  766.  
  767.         # check a comment that is too long is truncated
  768.         zipf = zipfile.ZipFile(TESTFN, mode="w")
  769.         zipf.comment = comment2 + 'oops'
  770.         zipf.writestr("foo.txt", "O, for a Muse of Fire!")
  771.         zipf.close()
  772.         zipfr = zipfile.ZipFile(TESTFN, mode="r")
  773.         self.assertEqual(zipfr.comment, comment2)
  774.         zipfr.close()
  775.  
  776.     def tearDown(self):
  777.         support.unlink(TESTFN)
  778.         support.unlink(TESTFN2)
  779.  
  780. class DecryptionTests(unittest.TestCase):
  781.     # This test checks that ZIP decryption works. Since the library does not
  782.     # support encryption at the moment, we use a pre-generated encrypted
  783.     # ZIP file
  784.  
  785.     data = (
  786.     'PK\x03\x04\x14\x00\x01\x00\x00\x00n\x92i.#y\xef?&\x00\x00\x00\x1a\x00'
  787.     '\x00\x00\x08\x00\x00\x00test.txt\xfa\x10\xa0gly|\xfa-\xc5\xc0=\xf9y'
  788.     '\x18\xe0\xa8r\xb3Z}Lg\xbc\xae\xf9|\x9b\x19\xe4\x8b\xba\xbb)\x8c\xb0\xdbl'
  789.     'PK\x01\x02\x14\x00\x14\x00\x01\x00\x00\x00n\x92i.#y\xef?&\x00\x00\x00'
  790.     '\x1a\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x01\x00 \x00\xb6\x81'
  791.     '\x00\x00\x00\x00test.txtPK\x05\x06\x00\x00\x00\x00\x01\x00\x01\x006\x00'
  792.     '\x00\x00L\x00\x00\x00\x00\x00' )
  793.     data2 = (
  794.     'PK\x03\x04\x14\x00\t\x00\x08\x00\xcf}38xu\xaa\xb2\x14\x00\x00\x00\x00\x02'
  795.     '\x00\x00\x04\x00\x15\x00zeroUT\t\x00\x03\xd6\x8b\x92G\xda\x8b\x92GUx\x04'
  796.     '\x00\xe8\x03\xe8\x03\xc7<M\xb5a\xceX\xa3Y&\x8b{oE\xd7\x9d\x8c\x98\x02\xc0'
  797.     'PK\x07\x08xu\xaa\xb2\x14\x00\x00\x00\x00\x02\x00\x00PK\x01\x02\x17\x03'
  798.     '\x14\x00\t\x00\x08\x00\xcf}38xu\xaa\xb2\x14\x00\x00\x00\x00\x02\x00\x00'
  799.     '\x04\x00\r\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x00\x00\x00\x00ze'
  800.     'roUT\x05\x00\x03\xd6\x8b\x92GUx\x00\x00PK\x05\x06\x00\x00\x00\x00\x01'
  801.     '\x00\x01\x00?\x00\x00\x00[\x00\x00\x00\x00\x00' )
  802.  
  803.     plain = 'zipfile.py encryption test'
  804.     plain2 = '\x00'*512
  805.  
  806.     def setUp(self):
  807.         fp = open(TESTFN, "wb")
  808.         fp.write(self.data)
  809.         fp.close()
  810.         self.zip = zipfile.ZipFile(TESTFN, "r")
  811.         fp = open(TESTFN2, "wb")
  812.         fp.write(self.data2)
  813.         fp.close()
  814.         self.zip2 = zipfile.ZipFile(TESTFN2, "r")
  815.  
  816.     def tearDown(self):
  817.         self.zip.close()
  818.         os.unlink(TESTFN)
  819.         self.zip2.close()
  820.         os.unlink(TESTFN2)
  821.  
  822.     def testNoPassword(self):
  823.         # Reading the encrypted file without password
  824.         # must generate a RunTime exception
  825.         self.assertRaises(RuntimeError, self.zip.read, "test.txt")
  826.         self.assertRaises(RuntimeError, self.zip2.read, "zero")
  827.  
  828.     def testBadPassword(self):
  829.         self.zip.setpassword("perl")
  830.         self.assertRaises(RuntimeError, self.zip.read, "test.txt")
  831.         self.zip2.setpassword("perl")
  832.         self.assertRaises(RuntimeError, self.zip2.read, "zero")
  833.  
  834.     def testGoodPassword(self):
  835.         self.zip.setpassword("python")
  836.         self.assertEquals(self.zip.read("test.txt"), self.plain)
  837.         self.zip2.setpassword("12345")
  838.         self.assertEquals(self.zip2.read("zero"), self.plain2)
  839.  
  840.  
  841. class TestsWithRandomBinaryFiles(unittest.TestCase):
  842.     def setUp(self):
  843.         datacount = randint(16, 64)*1024 + randint(1, 1024)
  844.         self.data = ''.join((struct.pack('<f', random()*randint(-1000, 1000)) for i in xrange(datacount)))
  845.  
  846.         # Make a source file with some lines
  847.         fp = open(TESTFN, "wb")
  848.         fp.write(self.data)
  849.         fp.close()
  850.  
  851.     def tearDown(self):
  852.         support.unlink(TESTFN)
  853.         support.unlink(TESTFN2)
  854.  
  855.     def makeTestArchive(self, f, compression):
  856.         # Create the ZIP archive
  857.         zipfp = zipfile.ZipFile(f, "w", compression)
  858.         zipfp.write(TESTFN, "another"+os.extsep+"name")
  859.         zipfp.write(TESTFN, TESTFN)
  860.         zipfp.close()
  861.  
  862.     def zipTest(self, f, compression):
  863.         self.makeTestArchive(f, compression)
  864.  
  865.         # Read the ZIP archive
  866.         zipfp = zipfile.ZipFile(f, "r", compression)
  867.         testdata = zipfp.read(TESTFN)
  868.         self.assertEqual(len(testdata), len(self.data))
  869.         self.assertEqual(testdata, self.data)
  870.         self.assertEqual(zipfp.read("another"+os.extsep+"name"), self.data)
  871.         zipfp.close()
  872.  
  873.     def testStored(self):
  874.         for f in (TESTFN2, TemporaryFile(), StringIO()):
  875.             self.zipTest(f, zipfile.ZIP_STORED)
  876.  
  877.     def zipOpenTest(self, f, compression):
  878.         self.makeTestArchive(f, compression)
  879.  
  880.         # Read the ZIP archive
  881.         zipfp = zipfile.ZipFile(f, "r", compression)
  882.         zipdata1 = []
  883.         zipopen1 = zipfp.open(TESTFN)
  884.         while 1:
  885.             read_data = zipopen1.read(256)
  886.             if not read_data:
  887.                 break
  888.             zipdata1.append(read_data)
  889.  
  890.         zipdata2 = []
  891.         zipopen2 = zipfp.open("another"+os.extsep+"name")
  892.         while 1:
  893.             read_data = zipopen2.read(256)
  894.             if not read_data:
  895.                 break
  896.             zipdata2.append(read_data)
  897.  
  898.         testdata1 = ''.join(zipdata1)
  899.         self.assertEqual(len(testdata1), len(self.data))
  900.         self.assertEqual(testdata1, self.data)
  901.  
  902.         testdata2 = ''.join(zipdata2)
  903.         self.assertEqual(len(testdata1), len(self.data))
  904.         self.assertEqual(testdata1, self.data)
  905.         zipfp.close()
  906.  
  907.     def testOpenStored(self):
  908.         for f in (TESTFN2, TemporaryFile(), StringIO()):
  909.             self.zipOpenTest(f, zipfile.ZIP_STORED)
  910.  
  911.     def zipRandomOpenTest(self, f, compression):
  912.         self.makeTestArchive(f, compression)
  913.  
  914.         # Read the ZIP archive
  915.         zipfp = zipfile.ZipFile(f, "r", compression)
  916.         zipdata1 = []
  917.         zipopen1 = zipfp.open(TESTFN)
  918.         while 1:
  919.             read_data = zipopen1.read(randint(1, 1024))
  920.             if not read_data:
  921.                 break
  922.             zipdata1.append(read_data)
  923.  
  924.         testdata = ''.join(zipdata1)
  925.         self.assertEqual(len(testdata), len(self.data))
  926.         self.assertEqual(testdata, self.data)
  927.         zipfp.close()
  928.  
  929.     def testRandomOpenStored(self):
  930.         for f in (TESTFN2, TemporaryFile(), StringIO()):
  931.             self.zipRandomOpenTest(f, zipfile.ZIP_STORED)
  932.  
  933. class TestsWithMultipleOpens(unittest.TestCase):
  934.     def setUp(self):
  935.         # Create the ZIP archive
  936.         zipfp = zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_DEFLATED)
  937.         zipfp.writestr('ones', '1'*FIXEDTEST_SIZE)
  938.         zipfp.writestr('twos', '2'*FIXEDTEST_SIZE)
  939.         zipfp.close()
  940.  
  941.     def testSameFile(self):
  942.         # Verify that (when the ZipFile is in control of creating file objects)
  943.         # multiple open() calls can be made without interfering with each other.
  944.         zipf = zipfile.ZipFile(TESTFN2, mode="r")
  945.         zopen1 = zipf.open('ones')
  946.         zopen2 = zipf.open('ones')
  947.         data1 = zopen1.read(500)
  948.         data2 = zopen2.read(500)
  949.         data1 += zopen1.read(500)
  950.         data2 += zopen2.read(500)
  951.         self.assertEqual(data1, data2)
  952.         zipf.close()
  953.  
  954.     def testDifferentFile(self):
  955.         # Verify that (when the ZipFile is in control of creating file objects)
  956.         # multiple open() calls can be made without interfering with each other.
  957.         zipf = zipfile.ZipFile(TESTFN2, mode="r")
  958.         zopen1 = zipf.open('ones')
  959.         zopen2 = zipf.open('twos')
  960.         data1 = zopen1.read(500)
  961.         data2 = zopen2.read(500)
  962.         data1 += zopen1.read(500)
  963.         data2 += zopen2.read(500)
  964.         self.assertEqual(data1, '1'*FIXEDTEST_SIZE)
  965.         self.assertEqual(data2, '2'*FIXEDTEST_SIZE)
  966.         zipf.close()
  967.  
  968.     def testInterleaved(self):
  969.         # Verify that (when the ZipFile is in control of creating file objects)
  970.         # multiple open() calls can be made without interfering with each other.
  971.         zipf = zipfile.ZipFile(TESTFN2, mode="r")
  972.         zopen1 = zipf.open('ones')
  973.         data1 = zopen1.read(500)
  974.         zopen2 = zipf.open('twos')
  975.         data2 = zopen2.read(500)
  976.         data1 += zopen1.read(500)
  977.         data2 += zopen2.read(500)
  978.         self.assertEqual(data1, '1'*FIXEDTEST_SIZE)
  979.         self.assertEqual(data2, '2'*FIXEDTEST_SIZE)
  980.         zipf.close()
  981.  
  982.     def tearDown(self):
  983.         os.remove(TESTFN2)
  984.  
  985.  
  986. class UniversalNewlineTests(unittest.TestCase):
  987.     def setUp(self):
  988.         self.line_gen = ["Test of zipfile line %d." % i for i in xrange(FIXEDTEST_SIZE)]
  989.         self.seps = ('\r', '\r\n', '\n')
  990.         self.arcdata, self.arcfiles = {}, {}
  991.         for n, s in enumerate(self.seps):
  992.             self.arcdata[s] = s.join(self.line_gen) + s
  993.             self.arcfiles[s] = '%s-%d' % (TESTFN, n)
  994.             open(self.arcfiles[s], "wb").write(self.arcdata[s])
  995.  
  996.     def makeTestArchive(self, f, compression):
  997.         # Create the ZIP archive
  998.         zipfp = zipfile.ZipFile(f, "w", compression)
  999.         for fn in self.arcfiles.values():
  1000.             zipfp.write(fn, fn)
  1001.         zipfp.close()
  1002.  
  1003.     def readTest(self, f, compression):
  1004.         self.makeTestArchive(f, compression)
  1005.  
  1006.         # Read the ZIP archive
  1007.         zipfp = zipfile.ZipFile(f, "r")
  1008.         for sep, fn in self.arcfiles.items():
  1009.             zipdata = zipfp.open(fn, "rU").read()
  1010.             self.assertEqual(self.arcdata[sep], zipdata)
  1011.  
  1012.         zipfp.close()
  1013.  
  1014.     def readlineTest(self, f, compression):
  1015.         self.makeTestArchive(f, compression)
  1016.  
  1017.         # Read the ZIP archive
  1018.         zipfp = zipfile.ZipFile(f, "r")
  1019.         for sep, fn in self.arcfiles.items():
  1020.             zipopen = zipfp.open(fn, "rU")
  1021.             for line in self.line_gen:
  1022.                 linedata = zipopen.readline()
  1023.                 self.assertEqual(linedata, line + '\n')
  1024.  
  1025.         zipfp.close()
  1026.  
  1027.     def readlinesTest(self, f, compression):
  1028.         self.makeTestArchive(f, compression)
  1029.  
  1030.         # Read the ZIP archive
  1031.         zipfp = zipfile.ZipFile(f, "r")
  1032.         for sep, fn in self.arcfiles.items():
  1033.             ziplines = zipfp.open(fn, "rU").readlines()
  1034.             for line, zipline in zip(self.line_gen, ziplines):
  1035.                 self.assertEqual(zipline, line + '\n')
  1036.  
  1037.         zipfp.close()
  1038.  
  1039.     def iterlinesTest(self, f, compression):
  1040.         self.makeTestArchive(f, compression)
  1041.  
  1042.         # Read the ZIP archive
  1043.         zipfp = zipfile.ZipFile(f, "r")
  1044.         for sep, fn in self.arcfiles.items():
  1045.             for line, zipline in zip(self.line_gen, zipfp.open(fn, "rU")):
  1046.                 self.assertEqual(zipline, line + '\n')
  1047.  
  1048.         zipfp.close()
  1049.  
  1050.     def testReadStored(self):
  1051.         for f in (TESTFN2, TemporaryFile(), StringIO()):
  1052.             self.readTest(f, zipfile.ZIP_STORED)
  1053.  
  1054.     def testReadlineStored(self):
  1055.         for f in (TESTFN2, TemporaryFile(), StringIO()):
  1056.             self.readlineTest(f, zipfile.ZIP_STORED)
  1057.  
  1058.     def testReadlinesStored(self):
  1059.         for f in (TESTFN2, TemporaryFile(), StringIO()):
  1060.             self.readlinesTest(f, zipfile.ZIP_STORED)
  1061.  
  1062.     def testIterlinesStored(self):
  1063.         for f in (TESTFN2, TemporaryFile(), StringIO()):
  1064.             self.iterlinesTest(f, zipfile.ZIP_STORED)
  1065.  
  1066.     if zlib:
  1067.         def testReadDeflated(self):
  1068.             for f in (TESTFN2, TemporaryFile(), StringIO()):
  1069.                 self.readTest(f, zipfile.ZIP_DEFLATED)
  1070.  
  1071.         def testReadlineDeflated(self):
  1072.             for f in (TESTFN2, TemporaryFile(), StringIO()):
  1073.                 self.readlineTest(f, zipfile.ZIP_DEFLATED)
  1074.  
  1075.         def testReadlinesDeflated(self):
  1076.             for f in (TESTFN2, TemporaryFile(), StringIO()):
  1077.                 self.readlinesTest(f, zipfile.ZIP_DEFLATED)
  1078.  
  1079.         def testIterlinesDeflated(self):
  1080.             for f in (TESTFN2, TemporaryFile(), StringIO()):
  1081.                 self.iterlinesTest(f, zipfile.ZIP_DEFLATED)
  1082.  
  1083.     def tearDown(self):
  1084.         for sep, fn in self.arcfiles.items():
  1085.             os.remove(fn)
  1086.         support.unlink(TESTFN)
  1087.         support.unlink(TESTFN2)
  1088.  
  1089.  
  1090. def test_main():
  1091.     run_unittest(TestsWithSourceFile, TestZip64InSmallFiles, OtherTests,
  1092.                  PyZipFileTests, DecryptionTests, TestsWithMultipleOpens,
  1093.                  UniversalNewlineTests, TestsWithRandomBinaryFiles)
  1094.  
  1095. if __name__ == "__main__":
  1096.     test_main()
  1097.