1 # Tests of the full ZIP64 functionality of zipfile

     2 # The test_support.requires call is the only reason for keeping this separate

     3 # from test_zipfile

     4 from test import test_support

     5 

     6 # XXX(nnorwitz): disable this test by looking for extra largfile resource

     7 # which doesn't exist.  This test takes over 30 minutes to run in general

     8 # and requires more disk space than most of the buildbots.

     9 test_support.requires(

    10         'extralargefile',

    11         'test requires loads of disk-space bytes and a long time to run'

    12     )

    13 

    14 # We can test part of the module without zlib.

    15 try:

    16     import zlib

    17 except ImportError:

    18     zlib = None

    19 

    20 import zipfile, os, unittest

    21 import time

    22 import sys

    23 

    24 from tempfile import TemporaryFile

    25 

    26 from test.test_support import TESTFN, run_unittest

    27 

    28 TESTFN2 = TESTFN + "2"

    29 

    30 # How much time in seconds can pass before we print a 'Still working' message.

    31 _PRINT_WORKING_MSG_INTERVAL = 5 * 60

    32 

    33 class TestsWithSourceFile(unittest.TestCase):

    34     def setUp(self):

    35         # Create test data.

    36         # xrange() is important here -- don't want to create immortal space

    37         # for a million ints.

    38         line_gen = ("Test of zipfile line %d." % i for i in xrange(1000000))

    39         self.data = '\n'.join(line_gen)

    40 

    41         # And write it to a file.

    42         fp = open(TESTFN, "wb")

    43         fp.write(self.data)

    44         fp.close()

    45 

    46     def zipTest(self, f, compression):

    47         # Create the ZIP archive.

    48         zipfp = zipfile.ZipFile(f, "w", compression, allowZip64=True)

    49 

    50         # It will contain enough copies of self.data to reach about 6GB of

    51         # raw data to store.

    52         filecount = 6*1024**3 // len(self.data)

    53 

    54         next_time = time.time() + _PRINT_WORKING_MSG_INTERVAL

    55         for num in range(filecount):

    56             zipfp.writestr("testfn%d" % num, self.data)

    57             # Print still working message since this test can be really slow

    58             if next_time <= time.time():

    59                 next_time = time.time() + _PRINT_WORKING_MSG_INTERVAL

    60                 print >>sys.__stdout__, (

    61                    '  zipTest still writing %d of %d, be patient...' %

    62                    (num, filecount))

    63                 sys.__stdout__.flush()

    64         zipfp.close()

    65 

    66         # Read the ZIP archive

    67         zipfp = zipfile.ZipFile(f, "r", compression)

    68         for num in range(filecount):

    69             self.assertEqual(zipfp.read("testfn%d" % num), self.data)

    70             # Print still working message since this test can be really slow

    71             if next_time <= time.time():

    72                 next_time = time.time() + _PRINT_WORKING_MSG_INTERVAL

    73                 print >>sys.__stdout__, (

    74                    '  zipTest still reading %d of %d, be patient...' %

    75                    (num, filecount))

    76                 sys.__stdout__.flush()

    77         zipfp.close()

    78 

    79     def testStored(self):

    80         # Try the temp file first.  If we do TESTFN2 first, then it hogs

    81         # gigabytes of disk space for the duration of the test.

    82         for f in TemporaryFile(), TESTFN2:

    83             self.zipTest(f, zipfile.ZIP_STORED)

    84 

    85     if zlib:

    86         def testDeflated(self):

    87             # Try the temp file first.  If we do TESTFN2 first, then it hogs

    88             # gigabytes of disk space for the duration of the test.

    89             for f in TemporaryFile(), TESTFN2:

    90                 self.zipTest(f, zipfile.ZIP_DEFLATED)

    91 

    92     def tearDown(self):

    93         for fname in TESTFN, TESTFN2:

    94             if os.path.exists(fname):

    95                 os.remove(fname)

    96 

    97 

    98 class OtherTests(unittest.TestCase):

    99     def testMoreThan64kFiles(self):

   100         # This test checks that more than 64k files can be added to an archive,

   101         # and that the resulting archive can be read properly by ZipFile

   102         zipf = zipfile.ZipFile(TESTFN, mode="w")

   103         zipf.debug = 100

   104         numfiles = (1 << 16) * 3/2

   105         for i in xrange(numfiles):

   106             zipf.writestr("foo%08d" % i, "%d" % (i**3 % 57))

   107         self.assertEqual(len(zipf.namelist()), numfiles)

   108         zipf.close()

   109 

   110         zipf2 = zipfile.ZipFile(TESTFN, mode="r")

   111         self.assertEqual(len(zipf2.namelist()), numfiles)

   112         for i in xrange(numfiles):

   113             self.assertEqual(zipf2.read("foo%08d" % i), "%d" % (i**3 % 57))

   114         zipf.close()

   115 

   116     def tearDown(self):

   117         test_support.unlink(TESTFN)

   118         test_support.unlink(TESTFN2)

   119 

   120 def test_main():

   121     run_unittest(TestsWithSourceFile, OtherTests)

   122 

   123 if __name__ == "__main__":

   124     test_main()