text: import contextlib
  import io
  import os
  import sys
  import importlib.util
  import time
  import struct
  import zipfile
  import unittest
  
  
  from tempfile import TemporaryFile
  from random import randint, random, getrandbits
  
  from test.support import (TESTFN, findfile, unlink, rmtree,
                            requires_zlib, requires_bz2, requires_lzma,
                            captured_stdout, check_warnings)
  
  TESTFN2 = TESTFN + "2"
  TESTFNDIR = TESTFN + "d"
  FIXEDTEST_SIZE = 1000
  DATAFILES_DIR = 'zipfile_datafiles'
  
  SMALL_TEST_DATA = [('_ziptest1', '1q2w3e4r5t'),
                     ('ziptest2dir/_ziptest2', 'qawsedrftg'),
                     ('ziptest2dir/ziptest3dir/_ziptest3', 'azsxdcfvgb'),
                     ('ziptest2dir/ziptest3dir/ziptest4dir/_ziptest3', '6y7u8i9o0p')]
  
  def getrandbytes(size):
      return getrandbits(8 * size).to_bytes(size, 'little')
  
  def get_files(test):
      yield TESTFN2
      with TemporaryFile() as f:
          yield f
          test.assertFalse(f.closed)
      with io.BytesIO() as f:
          yield f
          test.assertFalse(f.closed)
  
  def openU(zipfp, fn):
      with check_warnings(('', DeprecationWarning)):
          return zipfp.open(fn, 'rU')
  
  class AbstractTestsWithSourceFile:
      @classmethod
      def setUpClass(cls):
          cls.line_gen = [bytes("Zipfile test line %d. random float: %f\n" %
                                (i, random()), "ascii")
                          for i in range(FIXEDTEST_SIZE)]
          cls.data = b''.join(cls.line_gen)
  
      def setUp(self):
          # Make a source file with some lines
          with open(TESTFN, "wb") as fp:
              fp.write(self.data)
  
      def make_test_archive(self, f, compression):
          # Create the ZIP archive
          with zipfile.ZipFile(f, "w", compression) as zipfp:
              zipfp.write(TESTFN, "another.name")
              zipfp.write(TESTFN, TESTFN)
              zipfp.writestr("strfile", self.data)
  
      def zip_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r", compression) as zipfp:
              self.assertEqual(zipfp.read(TESTFN), self.data)
              self.assertEqual(zipfp.read("another.name"), self.data)
              self.assertEqual(zipfp.read("strfile"), self.data)
  
              # Print the ZIP directory
              fp = io.StringIO()
              zipfp.printdir(file=fp)
              directory = fp.getvalue()
              lines = directory.splitlines()
              self.assertEqual(len(lines), 4) # Number of files + header
  
              self.assertIn('File Name', lines[0])
              self.assertIn('Modified', lines[0])
              self.assertIn('Size', lines[0])
  
              fn, date, time_, size = lines[1].split()
              self.assertEqual(fn, 'another.name')
              self.assertTrue(time.strptime(date, '%Y-%m-%d'))
              self.assertTrue(time.strptime(time_, '%H:%M:%S'))
              self.assertEqual(size, str(len(self.data)))
  
              # Check the namelist
              names = zipfp.namelist()
              self.assertEqual(len(names), 3)
              self.assertIn(TESTFN, names)
              self.assertIn("another.name", names)
              self.assertIn("strfile", names)
  
              # Check infolist
              infos = zipfp.infolist()
              names = [i.filename for i in infos]
              self.assertEqual(len(names), 3)
              self.assertIn(TESTFN, names)
              self.assertIn("another.name", names)
              self.assertIn("strfile", names)
              for i in infos:
                  self.assertEqual(i.file_size, len(self.data))
  
              # check getinfo
              for nm in (TESTFN, "another.name", "strfile"):
                  info = zipfp.getinfo(nm)
                  self.assertEqual(info.filename, nm)
                  self.assertEqual(info.file_size, len(self.data))
  
              # Check that testzip doesn't raise an exception
              zipfp.testzip()
  
      def test_basic(self):
          for f in get_files(self):
              self.zip_test(f, self.compression)
  
      def zip_open_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r", compression) as zipfp:
              zipdata1 = []
              with zipfp.open(TESTFN) as zipopen1:
                  while True:
                      read_data = zipopen1.read(256)
                      if not read_data:
                          break
                      zipdata1.append(read_data)
  
              zipdata2 = []
              with zipfp.open("another.name") as zipopen2:
                  while True:
                      read_data = zipopen2.read(256)
                      if not read_data:
                          break
                      zipdata2.append(read_data)
  
              self.assertEqual(b''.join(zipdata1), self.data)
              self.assertEqual(b''.join(zipdata2), self.data)
  
      def test_open(self):
          for f in get_files(self):
              self.zip_open_test(f, self.compression)
  
      def zip_random_open_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r", compression) as zipfp:
              zipdata1 = []
              with zipfp.open(TESTFN) as zipopen1:
                  while True:
                      read_data = zipopen1.read(randint(1, 1024))
                      if not read_data:
                          break
                      zipdata1.append(read_data)
  
              self.assertEqual(b''.join(zipdata1), self.data)
  
      def test_random_open(self):
          for f in get_files(self):
              self.zip_random_open_test(f, self.compression)
  
      def zip_read1_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r") as zipfp, \
               zipfp.open(TESTFN) as zipopen:
              zipdata = []
              while True:
                  read_data = zipopen.read1(-1)
                  if not read_data:
                      break
                  zipdata.append(read_data)
  
          self.assertEqual(b''.join(zipdata), self.data)
  
      def test_read1(self):
          for f in get_files(self):
              self.zip_read1_test(f, self.compression)
  
      def zip_read1_10_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r") as zipfp, \
               zipfp.open(TESTFN) as zipopen:
              zipdata = []
              while True:
                  read_data = zipopen.read1(10)
                  self.assertLessEqual(len(read_data), 10)
                  if not read_data:
                      break
                  zipdata.append(read_data)
  
          self.assertEqual(b''.join(zipdata), self.data)
  
      def test_read1_10(self):
          for f in get_files(self):
              self.zip_read1_10_test(f, self.compression)
  
      def zip_readline_read_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r") as zipfp, \
               zipfp.open(TESTFN) as zipopen:
              data = b''
              while True:
                  read = zipopen.readline()
                  if not read:
                      break
                  data += read
  
                  read = zipopen.read(100)
                  if not read:
                      break
                  data += read
  
          self.assertEqual(data, self.data)
  
      def test_readline_read(self):
          # Issue #7610: calls to readline() interleaved with calls to read().
          for f in get_files(self):
              self.zip_readline_read_test(f, self.compression)
  
      def zip_readline_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r") as zipfp:
              with zipfp.open(TESTFN) as zipopen:
                  for line in self.line_gen:
                      linedata = zipopen.readline()
                      self.assertEqual(linedata, line)
  
      def test_readline(self):
          for f in get_files(self):
              self.zip_readline_test(f, self.compression)
  
      def zip_readlines_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r") as zipfp:
              with zipfp.open(TESTFN) as zipopen:
                  ziplines = zipopen.readlines()
              for line, zipline in zip(self.line_gen, ziplines):
                  self.assertEqual(zipline, line)
  
      def test_readlines(self):
          for f in get_files(self):
              self.zip_readlines_test(f, self.compression)
  
      def zip_iterlines_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r") as zipfp:
              with zipfp.open(TESTFN) as zipopen:
                  for line, zipline in zip(self.line_gen, zipopen):
                      self.assertEqual(zipline, line)
  
      def test_iterlines(self):
          for f in get_files(self):
              self.zip_iterlines_test(f, self.compression)
  
      def test_low_compression(self):
          """Check for cases where compressed data is larger than original."""
          # Create the ZIP archive
          with zipfile.ZipFile(TESTFN2, "w", self.compression) as zipfp:
              zipfp.writestr("strfile", '12')
  
          # Get an open object for strfile
          with zipfile.ZipFile(TESTFN2, "r", self.compression) as zipfp:
              with zipfp.open("strfile") as openobj:
                  self.assertEqual(openobj.read(1), b'1')
                  self.assertEqual(openobj.read(1), b'2')
  
      def test_writestr_compression(self):
          zipfp = zipfile.ZipFile(TESTFN2, "w")
          zipfp.writestr("b.txt", "hello world", compress_type=self.compression)
          info = zipfp.getinfo('b.txt')
          self.assertEqual(info.compress_type, self.compression)
  
      def test_read_return_size(self):
          # Issue #9837: ZipExtFile.read() shouldn't return more bytes
          # than requested.
          for test_size in (1, 4095, 4096, 4097, 16384):
              file_size = test_size + 1
              junk = getrandbytes(file_size)
              with zipfile.ZipFile(io.BytesIO(), "w", self.compression) as zipf:
                  zipf.writestr('foo', junk)
                  with zipf.open('foo', 'r') as fp:
                      buf = fp.read(test_size)
                      self.assertEqual(len(buf), test_size)
  
      def test_truncated_zipfile(self):
          fp = io.BytesIO()
          with zipfile.ZipFile(fp, mode='w') as zipf:
              zipf.writestr('strfile', self.data, compress_type=self.compression)
              end_offset = fp.tell()
          zipfiledata = fp.getvalue()
  
          fp = io.BytesIO(zipfiledata)
          with zipfile.ZipFile(fp) as zipf:
              with zipf.open('strfile') as zipopen:
                  fp.truncate(end_offset - 20)
                  with self.assertRaises(EOFError):
                      zipopen.read()
  
          fp = io.BytesIO(zipfiledata)
          with zipfile.ZipFile(fp) as zipf:
              with zipf.open('strfile') as zipopen:
                  fp.truncate(end_offset - 20)
                  with self.assertRaises(EOFError):
                      while zipopen.read(100):
                          pass
  
          fp = io.BytesIO(zipfiledata)
          with zipfile.ZipFile(fp) as zipf:
              with zipf.open('strfile') as zipopen:
                  fp.truncate(end_offset - 20)
                  with self.assertRaises(EOFError):
                      while zipopen.read1(100):
                          pass
  
      def test_repr(self):
          fname = 'file.name'
          for f in get_files(self):
              with zipfile.ZipFile(f, 'w', self.compression) as zipfp:
                  zipfp.write(TESTFN, fname)
                  r = repr(zipfp)
                  self.assertIn("mode='w'", r)
  
              with zipfile.ZipFile(f, 'r') as zipfp:
                  r = repr(zipfp)
                  if isinstance(f, str):
                      self.assertIn('filename=%r' % f, r)
                  else:
                      self.assertIn('file=%r' % f, r)
                  self.assertIn("mode='r'", r)
                  r = repr(zipfp.getinfo(fname))
                  self.assertIn('filename=%r' % fname, r)
                  self.assertIn('filemode=', r)
                  self.assertIn('file_size=', r)
                  if self.compression != zipfile.ZIP_STORED:
                      self.assertIn('compress_type=', r)
                      self.assertIn('compress_size=', r)
                  with zipfp.open(fname) as zipopen:
                      r = repr(zipopen)
                      self.assertIn('name=%r' % fname, r)
                      self.assertIn("mode='r'", r)
                      if self.compression != zipfile.ZIP_STORED:
                          self.assertIn('compress_type=', r)
                  self.assertIn('[closed]', repr(zipopen))
              self.assertIn('[closed]', repr(zipfp))
  
      def tearDown(self):
          unlink(TESTFN)
          unlink(TESTFN2)
  
  
  class StoredTestsWithSourceFile(AbstractTestsWithSourceFile,
                                  unittest.TestCase):
      compression = zipfile.ZIP_STORED
      test_low_compression = None
  
      def zip_test_writestr_permissions(self, f, compression):
          # Make sure that writestr creates files with mode 0600,
          # when it is passed a name rather than a ZipInfo instance.
  
          self.make_test_archive(f, compression)
          with zipfile.ZipFile(f, "r") as zipfp:
              zinfo = zipfp.getinfo('strfile')
              self.assertEqual(zinfo.external_attr, 0o600 << 16)
  
      def test_writestr_permissions(self):
          for f in get_files(self):
              self.zip_test_writestr_permissions(f, zipfile.ZIP_STORED)
  
      def test_absolute_arcnames(self):
          with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
              zipfp.write(TESTFN, "/absolute")
  
          with zipfile.ZipFile(TESTFN2, "r", zipfile.ZIP_STORED) as zipfp:
              self.assertEqual(zipfp.namelist(), ["absolute"])
  
      def test_append_to_zip_file(self):
          """Test appending to an existing zipfile."""
          with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
              zipfp.write(TESTFN, TESTFN)
  
          with zipfile.ZipFile(TESTFN2, "a", zipfile.ZIP_STORED) as zipfp:
              zipfp.writestr("strfile", self.data)
              self.assertEqual(zipfp.namelist(), [TESTFN, "strfile"])
  
      def test_append_to_non_zip_file(self):
          """Test appending to an existing file that is not a zipfile."""
          # NOTE: this test fails if len(d) < 22 because of the first
          # line "fpin.seek(-22, 2)" in _EndRecData
          data = b'I am not a ZipFile!'*10
          with open(TESTFN2, 'wb') as f:
              f.write(data)
  
          with zipfile.ZipFile(TESTFN2, "a", zipfile.ZIP_STORED) as zipfp:
              zipfp.write(TESTFN, TESTFN)
  
          with open(TESTFN2, 'rb') as f:
              f.seek(len(data))
              with zipfile.ZipFile(f, "r") as zipfp:
                  self.assertEqual(zipfp.namelist(), [TESTFN])
  
      def test_ignores_newline_at_end(self):
          with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
              zipfp.write(TESTFN, TESTFN)
          with open(TESTFN2, 'a') as f:
              f.write("\r\n\00\00\00")
          with zipfile.ZipFile(TESTFN2, "r") as zipfp:
              self.assertIsInstance(zipfp, zipfile.ZipFile)
  
      def test_ignores_stuff_appended_past_comments(self):
          with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
              zipfp.comment = b"this is a comment"
              zipfp.write(TESTFN, TESTFN)
          with open(TESTFN2, 'a') as f:
              f.write("abcdef\r\n")
          with zipfile.ZipFile(TESTFN2, "r") as zipfp:
              self.assertIsInstance(zipfp, zipfile.ZipFile)
              self.assertEqual(zipfp.comment, b"this is a comment")
  
      def test_write_default_name(self):
          """Check that calling ZipFile.write without arcname specified
          produces the expected result."""
          with zipfile.ZipFile(TESTFN2, "w") as zipfp:
              zipfp.write(TESTFN)
              with open(TESTFN, "rb") as f:
                  self.assertEqual(zipfp.read(TESTFN), f.read())
  
      def test_write_to_readonly(self):
          """Check that trying to call write() on a readonly ZipFile object
          raises a RuntimeError."""
          with zipfile.ZipFile(TESTFN2, mode="w") as zipfp:
              zipfp.writestr("somefile.txt", "bogus")
  
          with zipfile.ZipFile(TESTFN2, mode="r") as zipfp:
              self.assertRaises(RuntimeError, zipfp.write, TESTFN)
  
      def test_add_file_before_1980(self):
          # Set atime and mtime to 1970-01-01
          os.utime(TESTFN, (0, 0))
          with zipfile.ZipFile(TESTFN2, "w") as zipfp:
              self.assertRaises(ValueError, zipfp.write, TESTFN)
  
  
  @requires_zlib
  class DeflateTestsWithSourceFile(AbstractTestsWithSourceFile,
                                   unittest.TestCase):
      compression = zipfile.ZIP_DEFLATED
  
      def test_per_file_compression(self):
          """Check that files within a Zip archive can have different
          compression options."""
          with zipfile.ZipFile(TESTFN2, "w") as zipfp:
              zipfp.write(TESTFN, 'storeme', zipfile.ZIP_STORED)
              zipfp.write(TESTFN, 'deflateme', zipfile.ZIP_DEFLATED)
              sinfo = zipfp.getinfo('storeme')
              dinfo = zipfp.getinfo('deflateme')
              self.assertEqual(sinfo.compress_type, zipfile.ZIP_STORED)
              self.assertEqual(dinfo.compress_type, zipfile.ZIP_DEFLATED)
  
  @requires_bz2
  class Bzip2TestsWithSourceFile(AbstractTestsWithSourceFile,
                                 unittest.TestCase):
      compression = zipfile.ZIP_BZIP2
  
  @requires_lzma
  class LzmaTestsWithSourceFile(AbstractTestsWithSourceFile,
                                unittest.TestCase):
      compression = zipfile.ZIP_LZMA
  
  
  class AbstractTestZip64InSmallFiles:
      # These tests test the ZIP64 functionality without using large files,
      # see test_zipfile64 for proper tests.
  
      @classmethod
      def setUpClass(cls):
          line_gen = (bytes("Test of zipfile line %d." % i, "ascii")
                      for i in range(0, FIXEDTEST_SIZE))
          cls.data = b'\n'.join(line_gen)
  
      def setUp(self):
          self._limit = zipfile.ZIP64_LIMIT
          self._filecount_limit = zipfile.ZIP_FILECOUNT_LIMIT
          zipfile.ZIP64_LIMIT = 1000
          zipfile.ZIP_FILECOUNT_LIMIT = 9
  
          # Make a source file with some lines
          with open(TESTFN, "wb") as fp:
              fp.write(self.data)
  
      def zip_test(self, f, compression):
          # Create the ZIP archive
          with zipfile.ZipFile(f, "w", compression, allowZip64=True) as zipfp:
              zipfp.write(TESTFN, "another.name")
              zipfp.write(TESTFN, TESTFN)
              zipfp.writestr("strfile", self.data)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r", compression) as zipfp:
              self.assertEqual(zipfp.read(TESTFN), self.data)
              self.assertEqual(zipfp.read("another.name"), self.data)
              self.assertEqual(zipfp.read("strfile"), self.data)
  
              # Print the ZIP directory
              fp = io.StringIO()
              zipfp.printdir(fp)
  
              directory = fp.getvalue()
              lines = directory.splitlines()
              self.assertEqual(len(lines), 4) # Number of files + header
  
              self.assertIn('File Name', lines[0])
              self.assertIn('Modified', lines[0])
              self.assertIn('Size', lines[0])
  
              fn, date, time_, size = lines[1].split()
              self.assertEqual(fn, 'another.name')
              self.assertTrue(time.strptime(date, '%Y-%m-%d'))
              self.assertTrue(time.strptime(time_, '%H:%M:%S'))
              self.assertEqual(size, str(len(self.data)))
  
              # Check the namelist
              names = zipfp.namelist()
              self.assertEqual(len(names), 3)
              self.assertIn(TESTFN, names)
              self.assertIn("another.name", names)
              self.assertIn("strfile", names)
  
              # Check infolist
              infos = zipfp.infolist()
              names = [i.filename for i in infos]
              self.assertEqual(len(names), 3)
              self.assertIn(TESTFN, names)
              self.assertIn("another.name", names)
              self.assertIn("strfile", names)
              for i in infos:
                  self.assertEqual(i.file_size, len(self.data))
  
              # check getinfo
              for nm in (TESTFN, "another.name", "strfile"):
                  info = zipfp.getinfo(nm)
                  self.assertEqual(info.filename, nm)
                  self.assertEqual(info.file_size, len(self.data))
  
              # Check that testzip doesn't raise an exception
              zipfp.testzip()
  
      def test_basic(self):
          for f in get_files(self):
              self.zip_test(f, self.compression)
  
      def test_too_many_files(self):
          # This test checks that more than 64k files can be added to an archive,
          # and that the resulting archive can be read properly by ZipFile
          zipf = zipfile.ZipFile(TESTFN, "w", self.compression,
                                 allowZip64=True)
          zipf.debug = 100
          numfiles = 15
          for i in range(numfiles):
              zipf.writestr("foo%08d" % i, "%d" % (i**3 % 57))
          self.assertEqual(len(zipf.namelist()), numfiles)
          zipf.close()
  
          zipf2 = zipfile.ZipFile(TESTFN, "r", self.compression)
          self.assertEqual(len(zipf2.namelist()), numfiles)
          for i in range(numfiles):
              content = zipf2.read("foo%08d" % i).decode('ascii')
              self.assertEqual(content, "%d" % (i**3 % 57))
          zipf2.close()
  
      def test_too_many_files_append(self):
          zipf = zipfile.ZipFile(TESTFN, "w", self.compression,
                                 allowZip64=False)
          zipf.debug = 100
          numfiles = 9
          for i in range(numfiles):
              zipf.writestr("foo%08d" % i, "%d" % (i**3 % 57))
          self.assertEqual(len(zipf.namelist()), numfiles)
          with self.assertRaises(zipfile.LargeZipFile):
              zipf.writestr("foo%08d" % numfiles, b'')
          self.assertEqual(len(zipf.namelist()), numfiles)
          zipf.close()
  
          zipf = zipfile.ZipFile(TESTFN, "a", self.compression,
                                 allowZip64=False)
          zipf.debug = 100
          self.assertEqual(len(zipf.namelist()), numfiles)
          with self.assertRaises(zipfile.LargeZipFile):
              zipf.writestr("foo%08d" % numfiles, b'')
          self.assertEqual(len(zipf.namelist()), numfiles)
          zipf.close()
  
          zipf = zipfile.ZipFile(TESTFN, "a", self.compression,
                                 allowZip64=True)
          zipf.debug = 100
          self.assertEqual(len(zipf.namelist()), numfiles)
          numfiles2 = 15
          for i in range(numfiles, numfiles2):
              zipf.writestr("foo%08d" % i, "%d" % (i**3 % 57))
          self.assertEqual(len(zipf.namelist()), numfiles2)
          zipf.close()
  
          zipf2 = zipfile.ZipFile(TESTFN, "r", self.compression)
          self.assertEqual(len(zipf2.namelist()), numfiles2)
          for i in range(numfiles2):
              content = zipf2.read("foo%08d" % i).decode('ascii')
              self.assertEqual(content, "%d" % (i**3 % 57))
          zipf2.close()
  
      def tearDown(self):
          zipfile.ZIP64_LIMIT = self._limit
          zipfile.ZIP_FILECOUNT_LIMIT = self._filecount_limit
          unlink(TESTFN)
          unlink(TESTFN2)
  
  
  class StoredTestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
                                    unittest.TestCase):
      compression = zipfile.ZIP_STORED
  
      def large_file_exception_test(self, f, compression):
          with zipfile.ZipFile(f, "w", compression, allowZip64=False) as zipfp:
              self.assertRaises(zipfile.LargeZipFile,
                                zipfp.write, TESTFN, "another.name")
  
      def large_file_exception_test2(self, f, compression):
          with zipfile.ZipFile(f, "w", compression, allowZip64=False) as zipfp:
              self.assertRaises(zipfile.LargeZipFile,
                                zipfp.writestr, "another.name", self.data)
  
      def test_large_file_exception(self):
          for f in get_files(self):
              self.large_file_exception_test(f, zipfile.ZIP_STORED)
              self.large_file_exception_test2(f, zipfile.ZIP_STORED)
  
      def test_absolute_arcnames(self):
          with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED,
                               allowZip64=True) as zipfp:
              zipfp.write(TESTFN, "/absolute")
  
          with zipfile.ZipFile(TESTFN2, "r", zipfile.ZIP_STORED) as zipfp:
              self.assertEqual(zipfp.namelist(), ["absolute"])
  
  @requires_zlib
  class DeflateTestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
                                     unittest.TestCase):
      compression = zipfile.ZIP_DEFLATED
  
  @requires_bz2
  class Bzip2TestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
                                   unittest.TestCase):
      compression = zipfile.ZIP_BZIP2
  
  @requires_lzma
  class LzmaTestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
                                  unittest.TestCase):
      compression = zipfile.ZIP_LZMA
  
  
  class PyZipFileTests(unittest.TestCase):
      def assertCompiledIn(self, name, namelist):
          if name + 'o' not in namelist:
              self.assertIn(name + 'c', namelist)
  
      def requiresWriteAccess(self, path):
          # effective_ids unavailable on windows
          if not os.access(path, os.W_OK,
                           effective_ids=os.access in os.supports_effective_ids):
              self.skipTest('requires write access to the installed location')
          filename = os.path.join(path, 'test_zipfile.try')
          try:
              fd = os.open(filename, os.O_WRONLY | os.O_CREAT)
              os.close(fd)
          except Exception:
              self.skipTest('requires write access to the installed location')
          unlink(filename)
  
      def test_write_pyfile(self):
          self.requiresWriteAccess(os.path.dirname(__file__))
          with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
              fn = __file__
              if fn.endswith('.pyc'):
                  path_split = fn.split(os.sep)
                  if os.altsep is not None:
                      path_split.extend(fn.split(os.altsep))
                  if '__pycache__' in path_split:
                      fn = importlib.util.source_from_cache(fn)
                  else:
                      fn = fn[:-1]
  
              zipfp.writepy(fn)
  
              bn = os.path.basename(fn)
              self.assertNotIn(bn, zipfp.namelist())
              self.assertCompiledIn(bn, zipfp.namelist())
  
          with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
              fn = __file__
              if fn.endswith('.pyc'):
                  fn = fn[:-1]
  
              zipfp.writepy(fn, "testpackage")
  
              bn = "%s/%s" % ("testpackage", os.path.basename(fn))
              self.assertNotIn(bn, zipfp.namelist())
              self.assertCompiledIn(bn, zipfp.namelist())
  
      def test_write_python_package(self):
          import email
          packagedir = os.path.dirname(email.__file__)
          self.requiresWriteAccess(packagedir)
  
          with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
              zipfp.writepy(packagedir)
  
              # Check for a couple of modules at different levels of the
              # hierarchy
              names = zipfp.namelist()
              self.assertCompiledIn('email/__init__.py', names)
              self.assertCompiledIn('email/mime/text.py', names)
  
      def test_write_filtered_python_package(self):
          import test
          packagedir = os.path.dirname(test.__file__)
          self.requiresWriteAccess(packagedir)
  
          with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
  
              # first make sure that the test folder gives error messages
              # (on the badsyntax_... files)
              with captured_stdout() as reportSIO:
                  zipfp.writepy(packagedir)
              reportStr = reportSIO.getvalue()
              self.assertTrue('SyntaxError' in reportStr)
  
              # then check that the filter works on the whole package
              with captured_stdout() as reportSIO:
                  zipfp.writepy(packagedir, filterfunc=lambda whatever: False)
              reportStr = reportSIO.getvalue()
              self.assertTrue('SyntaxError' not in reportStr)
  
              # then check that the filter works on individual files
              def filter(path):
                  return not os.path.basename(path).startswith("bad")
              with captured_stdout() as reportSIO, self.assertWarns(UserWarning):
                  zipfp.writepy(packagedir, filterfunc=filter)
              reportStr = reportSIO.getvalue()
              if reportStr:
                  print(reportStr)
              self.assertTrue('SyntaxError' not in reportStr)
  
      def test_write_with_optimization(self):
          import email
          packagedir = os.path.dirname(email.__file__)
          self.requiresWriteAccess(packagedir)
          optlevel = 1 if __debug__ else 0
          ext = '.pyc'
  
          with TemporaryFile() as t, \
               zipfile.PyZipFile(t, "w", optimize=optlevel) as zipfp:
              zipfp.writepy(packagedir)
  
              names = zipfp.namelist()
              self.assertIn('email/__init__' + ext, names)
              self.assertIn('email/mime/text' + ext, names)
  
      def test_write_python_directory(self):
          os.mkdir(TESTFN2)
          try:
              with open(os.path.join(TESTFN2, "mod1.py"), "w") as fp:
                  fp.write("print(42)\n")
  
              with open(os.path.join(TESTFN2, "mod2.py"), "w") as fp:
                  fp.write("print(42 * 42)\n")
  
              with open(os.path.join(TESTFN2, "mod2.txt"), "w") as fp:
                  fp.write("bla bla bla\n")
  
              with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
                  zipfp.writepy(TESTFN2)
  
                  names = zipfp.namelist()
                  self.assertCompiledIn('mod1.py', names)
                  self.assertCompiledIn('mod2.py', names)
                  self.assertNotIn('mod2.txt', names)
  
          finally:
              rmtree(TESTFN2)
  
      def test_write_python_directory_filtered(self):
          os.mkdir(TESTFN2)
          try:
              with open(os.path.join(TESTFN2, "mod1.py"), "w") as fp:
                  fp.write("print(42)\n")
  
              with open(os.path.join(TESTFN2, "mod2.py"), "w") as fp:
                  fp.write("print(42 * 42)\n")
  
              with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
                  zipfp.writepy(TESTFN2, filterfunc=lambda fn:
                                                    not fn.endswith('mod2.py'))
  
                  names = zipfp.namelist()
                  self.assertCompiledIn('mod1.py', names)
                  self.assertNotIn('mod2.py', names)
  
          finally:
              rmtree(TESTFN2)
  
      def test_write_non_pyfile(self):
          with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
              with open(TESTFN, 'w') as f:
                  f.write('most definitely not a python file')
              self.assertRaises(RuntimeError, zipfp.writepy, TESTFN)
              unlink(TESTFN)
  
      def test_write_pyfile_bad_syntax(self):
          os.mkdir(TESTFN2)
          try:
              with open(os.path.join(TESTFN2, "mod1.py"), "w") as fp:
                  fp.write("Bad syntax in python file\n")
  
              with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
                  # syntax errors are printed to stdout
                  with captured_stdout() as s:
                      zipfp.writepy(os.path.join(TESTFN2, "mod1.py"))
  
                  self.assertIn("SyntaxError", s.getvalue())
  
                  # as it will not have compiled the python file, it will
                  # include the .py file not .pyc
                  names = zipfp.namelist()
                  self.assertIn('mod1.py', names)
                  self.assertNotIn('mod1.pyc', names)
  
          finally:
              rmtree(TESTFN2)
  
  
  class ExtractTests(unittest.TestCase):
      def test_extract(self):
          with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
              for fpath, fdata in SMALL_TEST_DATA:
                  zipfp.writestr(fpath, fdata)
  
          with zipfile.ZipFile(TESTFN2, "r") as zipfp:
              for fpath, fdata in SMALL_TEST_DATA:
                  writtenfile = zipfp.extract(fpath)
  
                  # make sure it was written to the right place
                  correctfile = os.path.join(os.getcwd(), fpath)
                  correctfile = os.path.normpath(correctfile)
  
                  self.assertEqual(writtenfile, correctfile)
  
                  # make sure correct data is in correct file
                  with open(writtenfile, "rb") as f:
                      self.assertEqual(fdata.encode(), f.read())
  
                  unlink(writtenfile)
  
          # remove the test file subdirectories
          rmtree(os.path.join(os.getcwd(), 'ziptest2dir'))
  
      def test_extract_all(self):
          with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
              for fpath, fdata in SMALL_TEST_DATA:
                  zipfp.writestr(fpath, fdata)
  
          with zipfile.ZipFile(TESTFN2, "r") as zipfp:
              zipfp.extractall()
              for fpath, fdata in SMALL_TEST_DATA:
                  outfile = os.path.join(os.getcwd(), fpath)
  
                  with open(outfile, "rb") as f:
                      self.assertEqual(fdata.encode(), f.read())
  
                  unlink(outfile)
  
          # remove the test file subdirectories
          rmtree(os.path.join(os.getcwd(), 'ziptest2dir'))
  
      def check_file(self, filename, content):
          self.assertTrue(os.path.isfile(filename))
          with open(filename, 'rb') as f:
              self.assertEqual(f.read(), content)
  
      def test_sanitize_windows_name(self):
          san = zipfile.ZipFile._sanitize_windows_name
          # Passing pathsep in allows this test to work regardless of platform.
          self.assertEqual(san(r',,?,C:,foo,bar/z', ','), r'_,C_,foo,bar/z')
          self.assertEqual(san(r'a\b,c<d>e|f"g?h*i', ','), r'a\b,c_d_e_f_g_h_i')
          self.assertEqual(san('../../foo../../ba..r', '/'), r'foo/ba..r')
  
      def test_extract_hackers_arcnames_common_cases(self):
          common_hacknames = [
              ('../foo/bar', 'foo/bar'),
              ('foo/../bar', 'foo/bar'),
              ('foo/../../bar', 'foo/bar'),
              ('foo/bar/..', 'foo/bar'),
              ('./../foo/bar', 'foo/bar'),
              ('/foo/bar', 'foo/bar'),
              ('/foo/../bar', 'foo/bar'),
              ('/foo/../../bar', 'foo/bar'),
          ]
          self._test_extract_hackers_arcnames(common_hacknames)
  
      @unittest.skipIf(os.path.sep != '\\', 'Requires \\ as path separator.')
      def test_extract_hackers_arcnames_windows_only(self):
          """Test combination of path fixing and windows name sanitization."""
          windows_hacknames = [
              (r'..\foo\bar', 'foo/bar'),
              (r'..\/foo\/bar', 'foo/bar'),
              (r'foo/\..\/bar', 'foo/bar'),
              (r'foo\/../\bar', 'foo/bar'),
              (r'C:foo/bar', 'foo/bar'),
              (r'C:/foo/bar', 'foo/bar'),
              (r'C://foo/bar', 'foo/bar'),
              (r'C:\foo\bar', 'foo/bar'),
              (r'//conky/mountpoint/foo/bar', 'foo/bar'),
              (r'\\conky\mountpoint\foo\bar', 'foo/bar'),
              (r'///conky/mountpoint/foo/bar', 'conky/mountpoint/foo/bar'),
              (r'\\\conky\mountpoint\foo\bar', 'conky/mountpoint/foo/bar'),
              (r'//conky//mountpoint/foo/bar', 'conky/mountpoint/foo/bar'),
              (r'\\conky\\mountpoint\foo\bar', 'conky/mountpoint/foo/bar'),
              (r'//?/C:/foo/bar', 'foo/bar'),
              (r'\\?\C:\foo\bar', 'foo/bar'),
              (r'C:/../C:/foo/bar', 'C_/foo/bar'),
              (r'a:b\c<d>e|f"g?h*i', 'b/c_d_e_f_g_h_i'),
              ('../../foo../../ba..r', 'foo/ba..r'),
          ]
          self._test_extract_hackers_arcnames(windows_hacknames)
  
      @unittest.skipIf(os.path.sep != '/', r'Requires / as path separator.')
      def test_extract_hackers_arcnames_posix_only(self):
          posix_hacknames = [
              ('//foo/bar', 'foo/bar'),
              ('../../foo../../ba..r', 'foo../ba..r'),
              (r'foo/..\bar', r'foo/..\bar'),
          ]
          self._test_extract_hackers_arcnames(posix_hacknames)
  
      def _test_extract_hackers_arcnames(self, hacknames):
          for arcname, fixedname in hacknames:
              content = b'foobar' + arcname.encode()
              with zipfile.ZipFile(TESTFN2, 'w', zipfile.ZIP_STORED) as zipfp:
                  zinfo = zipfile.ZipInfo()
                  # preserve backslashes
                  zinfo.filename = arcname
                  zinfo.external_attr = 0o600 << 16
                  zipfp.writestr(zinfo, content)
  
              arcname = arcname.replace(os.sep, "/")
              targetpath = os.path.join('target', 'subdir', 'subsub')
              correctfile = os.path.join(targetpath, *fixedname.split('/'))
  
              with zipfile.ZipFile(TESTFN2, 'r') as zipfp:
                  writtenfile = zipfp.extract(arcname, targetpath)
                  self.assertEqual(writtenfile, correctfile,
                                   msg='extract %r: %r != %r' %
                                   (arcname, writtenfile, correctfile))
              self.check_file(correctfile, content)
              rmtree('target')
  
              with zipfile.ZipFile(TESTFN2, 'r') as zipfp:
                  zipfp.extractall(targetpath)
              self.check_file(correctfile, content)
              rmtree('target')
  
              correctfile = os.path.join(os.getcwd(), *fixedname.split('/'))
  
              with zipfile.ZipFile(TESTFN2, 'r') as zipfp:
                  writtenfile = zipfp.extract(arcname)
                  self.assertEqual(writtenfile, correctfile,
                                   msg="extract %r" % arcname)
              self.check_file(correctfile, content)
              rmtree(fixedname.split('/')[0])
  
              with zipfile.ZipFile(TESTFN2, 'r') as zipfp:
                  zipfp.extractall()
              self.check_file(correctfile, content)
              rmtree(fixedname.split('/')[0])
  
              unlink(TESTFN2)
  
  
  class OtherTests(unittest.TestCase):
      def test_open_via_zip_info(self):
          # Create the ZIP archive
          with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
              zipfp.writestr("name", "foo")
              with self.assertWarns(UserWarning):
                  zipfp.writestr("name", "bar")
              self.assertEqual(zipfp.namelist(), ["name"] * 2)
  
          with zipfile.ZipFile(TESTFN2, "r") as zipfp:
              infos = zipfp.infolist()
              data = b""
              for info in infos:
                  with zipfp.open(info) as zipopen:
                      data += zipopen.read()
              self.assertIn(data, {b"foobar", b"barfoo"})
              data = b""
              for info in infos:
                  data += zipfp.read(info)
              self.assertIn(data, {b"foobar", b"barfoo"})
  
      def test_universal_deprecation(self):
          f = io.BytesIO()
          with zipfile.ZipFile(f, "w") as zipfp:
              zipfp.writestr('spam.txt', b'ababagalamaga')
  
          with zipfile.ZipFile(f, "r") as zipfp:
              for mode in 'U', 'rU':
                  with self.assertWarns(DeprecationWarning):
                      zipopen = zipfp.open('spam.txt', mode)
                  zipopen.close()
  
      def test_universal_readaheads(self):
          f = io.BytesIO()
  
          data = b'a\r\n' * 16 * 1024
          with zipfile.ZipFile(f, 'w', zipfile.ZIP_STORED) as zipfp:
              zipfp.writestr(TESTFN, data)
  
          data2 = b''
          with zipfile.ZipFile(f, 'r') as zipfp, \
               openU(zipfp, TESTFN) as zipopen:
              for line in zipopen:
                  data2 += line
  
          self.assertEqual(data, data2.replace(b'\n', b'\r\n'))
  
      def test_writestr_extended_local_header_issue1202(self):
          with zipfile.ZipFile(TESTFN2, 'w') as orig_zip:
              for data in 'abcdefghijklmnop':
                  zinfo = zipfile.ZipInfo(data)
                  zinfo.flag_bits |= 0x08  # Include an extended local header.
                  orig_zip.writestr(zinfo, data)
  
      def test_close(self):
          """Check that the zipfile is closed after the 'with' block."""
          with zipfile.ZipFile(TESTFN2, "w") as zipfp:
              for fpath, fdata in SMALL_TEST_DATA:
                  zipfp.writestr(fpath, fdata)
                  self.assertIsNotNone(zipfp.fp, 'zipfp is not open')
          self.assertIsNone(zipfp.fp, 'zipfp is not closed')
  
          with zipfile.ZipFile(TESTFN2, "r") as zipfp:
              self.assertIsNotNone(zipfp.fp, 'zipfp is not open')
          self.assertIsNone(zipfp.fp, 'zipfp is not closed')
  
      def test_close_on_exception(self):
          """Check that the zipfile is closed if an exception is raised in the
          'with' block."""
          with zipfile.ZipFile(TESTFN2, "w") as zipfp:
              for fpath, fdata in SMALL_TEST_DATA:
                  zipfp.writestr(fpath, fdata)
  
          try:
              with zipfile.ZipFile(TESTFN2, "r") as zipfp2:
                  raise zipfile.BadZipFile()
          except zipfile.BadZipFile:
              self.assertIsNone(zipfp2.fp, 'zipfp is not closed')
  
      def test_unsupported_version(self):
          # File has an extract_version of 120
          data = (b'PK\x03\x04x\x00\x00\x00\x00\x00!p\xa1@\x00\x00\x00\x00\x00\x00'
                  b'\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00xPK\x01\x02x\x03x\x00\x00\x00\x00'
                  b'\x00!p\xa1@\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00'
                  b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x00\x00\x00\x00xPK\x05\x06'
                  b'\x00\x00\x00\x00\x01\x00\x01\x00/\x00\x00\x00\x1f\x00\x00\x00\x00\x00')
  
          self.assertRaises(NotImplementedError, zipfile.ZipFile,
                            io.BytesIO(data), 'r')
  
      @requires_zlib
      def test_read_unicode_filenames(self):
          # bug #10801
          fname = findfile('zip_cp437_header.zip')
          with zipfile.ZipFile(fname) as zipfp:
              for name in zipfp.namelist():
                  zipfp.open(name).close()
  
      def test_write_unicode_filenames(self):
          with zipfile.ZipFile(TESTFN, "w") as zf:
              zf.writestr("foo.txt", "Test for unicode filename")
              zf.writestr("\xf6.txt", "Test for unicode filename")
              self.assertIsInstance(zf.infolist()[0].filename, str)
  
          with zipfile.ZipFile(TESTFN, "r") as zf:
              self.assertEqual(zf.filelist[0].filename, "foo.txt")
              self.assertEqual(zf.filelist[1].filename, "\xf6.txt")
  
      def test_exclusive_create_zip_file(self):
          """Test exclusive creating a new zipfile."""
          unlink(TESTFN2)
          filename = 'testfile.txt'
          content = b'hello, world. this is some content.'
          with zipfile.ZipFile(TESTFN2, "x", zipfile.ZIP_STORED) as zipfp:
              zipfp.writestr(filename, content)
          with self.assertRaises(FileExistsError):
              zipfile.ZipFile(TESTFN2, "x", zipfile.ZIP_STORED)
          with zipfile.ZipFile(TESTFN2, "r") as zipfp:
              self.assertEqual(zipfp.namelist(), [filename])
              self.assertEqual(zipfp.read(filename), content)
  
      def test_create_non_existent_file_for_append(self):
          if os.path.exists(TESTFN):
              os.unlink(TESTFN)
  
          filename = 'testfile.txt'
          content = b'hello, world. this is some content.'
  
          try:
              with zipfile.ZipFile(TESTFN, 'a') as zf:
                  zf.writestr(filename, content)
          except OSError:
              self.fail('Could not append data to a non-existent zip file.')
  
          self.assertTrue(os.path.exists(TESTFN))
  
          with zipfile.ZipFile(TESTFN, 'r') as zf:
              self.assertEqual(zf.read(filename), content)
  
      def test_close_erroneous_file(self):
          # This test checks that the ZipFile constructor closes the file object
          # it opens if there's an error in the file.  If it doesn't, the
          # traceback holds a reference to the ZipFile object and, indirectly,
          # the file object.
          # On Windows, this causes the os.unlink() call to fail because the
          # underlying file is still open.  This is SF bug #412214.
          #
          with open(TESTFN, "w") as fp:
              fp.write("this is not a legal zip file\n")
          try:
              zf = zipfile.ZipFile(TESTFN)
          except zipfile.BadZipFile:
              pass
  
      def test_is_zip_erroneous_file(self):
          """Check that is_zipfile() correctly identifies non-zip files."""
          # - passing a filename
          with open(TESTFN, "w") as fp:
              fp.write("this is not a legal zip file\n")
          self.assertFalse(zipfile.is_zipfile(TESTFN))
          # - passing a file object
          with open(TESTFN, "rb") as fp:
              self.assertFalse(zipfile.is_zipfile(fp))
          # - passing a file-like object
          fp = io.BytesIO()
          fp.write(b"this is not a legal zip file\n")
          self.assertFalse(zipfile.is_zipfile(fp))
          fp.seek(0, 0)
          self.assertFalse(zipfile.is_zipfile(fp))
  
      def test_damaged_zipfile(self):
          """Check that zipfiles with missing bytes at the end raise BadZipFile."""
          # - Create a valid zip file
          fp = io.BytesIO()
          with zipfile.ZipFile(fp, mode="w") as zipf:
              zipf.writestr("foo.txt", b"O, for a Muse of Fire!")
          zipfiledata = fp.getvalue()
  
          # - Now create copies of it missing the last N bytes and make sure
          #   a BadZipFile exception is raised when we try to open it
          for N in range(len(zipfiledata)):
              fp = io.BytesIO(zipfiledata[:N])
              self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, fp)
  
      def test_is_zip_valid_file(self):
          """Check that is_zipfile() correctly identifies zip files."""
          # - passing a filename
          with zipfile.ZipFile(TESTFN, mode="w") as zipf:
              zipf.writestr("foo.txt", b"O, for a Muse of Fire!")
  
          self.assertTrue(zipfile.is_zipfile(TESTFN))
          # - passing a file object
          with open(TESTFN, "rb") as fp:
              self.assertTrue(zipfile.is_zipfile(fp))
              fp.seek(0, 0)
              zip_contents = fp.read()
          # - passing a file-like object
          fp = io.BytesIO()
          fp.write(zip_contents)
          self.assertTrue(zipfile.is_zipfile(fp))
          fp.seek(0, 0)
          self.assertTrue(zipfile.is_zipfile(fp))
  
      def test_non_existent_file_raises_OSError(self):
          # make sure we don't raise an AttributeError when a partially-constructed
          # ZipFile instance is finalized; this tests for regression on SF tracker
          # bug #403871.
  
          # The bug we're testing for caused an AttributeError to be raised
          # when a ZipFile instance was created for a file that did not
          # exist; the .fp member was not initialized but was needed by the
          # __del__() method.  Since the AttributeError is in the __del__(),
          # it is ignored, but the user should be sufficiently annoyed by
          # the message on the output that regression will be noticed
          # quickly.
          self.assertRaises(OSError, zipfile.ZipFile, TESTFN)
  
      def test_empty_file_raises_BadZipFile(self):
          f = open(TESTFN, 'w')
          f.close()
          self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, TESTFN)
  
          with open(TESTFN, 'w') as fp:
              fp.write("short file")
          self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, TESTFN)
  
      def test_closed_zip_raises_RuntimeError(self):
          """Verify that testzip() doesn't swallow inappropriate exceptions."""
          data = io.BytesIO()
          with zipfile.ZipFile(data, mode="w") as zipf:
              zipf.writestr("foo.txt", "O, for a Muse of Fire!")
  
          # This is correct; calling .read on a closed ZipFile should raise
          # a RuntimeError, and so should calling .testzip.  An earlier
          # version of .testzip would swallow this exception (and any other)
          # and report that the first file in the archive was corrupt.
          self.assertRaises(RuntimeError, zipf.read, "foo.txt")
          self.assertRaises(RuntimeError, zipf.open, "foo.txt")
          self.assertRaises(RuntimeError, zipf.testzip)
          self.assertRaises(RuntimeError, zipf.writestr, "bogus.txt", "bogus")
          with open(TESTFN, 'w') as f:
              f.write('zipfile test data')
          self.assertRaises(RuntimeError, zipf.write, TESTFN)
  
      def test_bad_constructor_mode(self):
          """Check that bad modes passed to ZipFile constructor are caught."""
          self.assertRaises(RuntimeError, zipfile.ZipFile, TESTFN, "q")
  
      def test_bad_open_mode(self):
          """Check that bad modes passed to ZipFile.open are caught."""
          with zipfile.ZipFile(TESTFN, mode="w") as zipf:
              zipf.writestr("foo.txt", "O, for a Muse of Fire!")
  
          with zipfile.ZipFile(TESTFN, mode="r") as zipf:
          # read the data to make sure the file is there
              zipf.read("foo.txt")
              self.assertRaises(RuntimeError, zipf.open, "foo.txt", "q")
  
      def test_read0(self):
          """Check that calling read(0) on a ZipExtFile object returns an empty
          string and doesn't advance file pointer."""
          with zipfile.ZipFile(TESTFN, mode="w") as zipf:
              zipf.writestr("foo.txt", "O, for a Muse of Fire!")
              # read the data to make sure the file is there
              with zipf.open("foo.txt") as f:
                  for i in range(FIXEDTEST_SIZE):
                      self.assertEqual(f.read(0), b'')
  
                  self.assertEqual(f.read(), b"O, for a Muse of Fire!")
  
      def test_open_non_existent_item(self):
          """Check that attempting to call open() for an item that doesn't
          exist in the archive raises a RuntimeError."""
          with zipfile.ZipFile(TESTFN, mode="w") as zipf:
              self.assertRaises(KeyError, zipf.open, "foo.txt", "r")
  
      def test_bad_compression_mode(self):
          """Check that bad compression methods passed to ZipFile.open are
          caught."""
          self.assertRaises(RuntimeError, zipfile.ZipFile, TESTFN, "w", -1)
  
      def test_unsupported_compression(self):
          # data is declared as shrunk, but actually deflated
          data = (b'PK\x03\x04.\x00\x00\x00\x01\x00\xe4C\xa1@\x00\x00\x00'
                  b'\x00\x02\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00x\x03\x00PK\x01'
                  b'\x02.\x03.\x00\x00\x00\x01\x00\xe4C\xa1@\x00\x00\x00\x00\x02\x00\x00'
                  b'\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
                  b'\x80\x01\x00\x00\x00\x00xPK\x05\x06\x00\x00\x00\x00\x01\x00\x01\x00'
                  b'/\x00\x00\x00!\x00\x00\x00\x00\x00')
          with zipfile.ZipFile(io.BytesIO(data), 'r') as zipf:
              self.assertRaises(NotImplementedError, zipf.open, 'x')
  
      def test_null_byte_in_filename(self):
          """Check that a filename containing a null byte is properly
          terminated."""
          with zipfile.ZipFile(TESTFN, mode="w") as zipf:
              zipf.writestr("foo.txt\x00qqq", b"O, for a Muse of Fire!")
              self.assertEqual(zipf.namelist(), ['foo.txt'])
  
      def test_struct_sizes(self):
          """Check that ZIP internal structure sizes are calculated correctly."""
          self.assertEqual(zipfile.sizeEndCentDir, 22)
          self.assertEqual(zipfile.sizeCentralDir, 46)
          self.assertEqual(zipfile.sizeEndCentDir64, 56)
          self.assertEqual(zipfile.sizeEndCentDir64Locator, 20)
  
      def test_comments(self):
          """Check that comments on the archive are handled properly."""
  
          # check default comment is empty
          with zipfile.ZipFile(TESTFN, mode="w") as zipf:
              self.assertEqual(zipf.comment, b'')
              zipf.writestr("foo.txt", "O, for a Muse of Fire!")
  
          with zipfile.ZipFile(TESTFN, mode="r") as zipfr:
              self.assertEqual(zipfr.comment, b'')
  
          # check a simple short comment
          comment = b'Bravely taking to his feet, he beat a very brave retreat.'
          with zipfile.ZipFile(TESTFN, mode="w") as zipf:
              zipf.comment = comment
              zipf.writestr("foo.txt", "O, for a Muse of Fire!")
          with zipfile.ZipFile(TESTFN, mode="r") as zipfr:
              self.assertEqual(zipf.comment, comment)
  
          # check a comment of max length
          comment2 = ''.join(['%d' % (i**3 % 10) for i in range((1 << 16)-1)])
          comment2 = comment2.encode("ascii")
          with zipfile.ZipFile(TESTFN, mode="w") as zipf:
              zipf.comment = comment2
              zipf.writestr("foo.txt", "O, for a Muse of Fire!")
  
          with zipfile.ZipFile(TESTFN, mode="r") as zipfr:
              self.assertEqual(zipfr.comment, comment2)
  
          # check a comment that is too long is truncated
          with zipfile.ZipFile(TESTFN, mode="w") as zipf:
              with self.assertWarns(UserWarning):
                  zipf.comment = comment2 + b'oops'
              zipf.writestr("foo.txt", "O, for a Muse of Fire!")
          with zipfile.ZipFile(TESTFN, mode="r") as zipfr:
              self.assertEqual(zipfr.comment, comment2)
  
          # check that comments are correctly modified in append mode
          with zipfile.ZipFile(TESTFN,mode="w") as zipf:
              zipf.comment = b"original comment"
              zipf.writestr("foo.txt", "O, for a Muse of Fire!")
          with zipfile.ZipFile(TESTFN,mode="a") as zipf:
              zipf.comment = b"an updated comment"
          with zipfile.ZipFile(TESTFN,mode="r") as zipf:
              self.assertEqual(zipf.comment, b"an updated comment")
  
          # check that comments are correctly shortened in append mode
          with zipfile.ZipFile(TESTFN,mode="w") as zipf:
              zipf.comment = b"original comment that's longer"
              zipf.writestr("foo.txt", "O, for a Muse of Fire!")
          with zipfile.ZipFile(TESTFN,mode="a") as zipf:
              zipf.comment = b"shorter comment"
          with zipfile.ZipFile(TESTFN,mode="r") as zipf:
              self.assertEqual(zipf.comment, b"shorter comment")
  
      def test_unicode_comment(self):
          with zipfile.ZipFile(TESTFN, "w", zipfile.ZIP_STORED) as zipf:
              zipf.writestr("foo.txt", "O, for a Muse of Fire!")
              with self.assertRaises(TypeError):
                  zipf.comment = "this is an error"
  
      def test_change_comment_in_empty_archive(self):
          with zipfile.ZipFile(TESTFN, "a", zipfile.ZIP_STORED) as zipf:
              self.assertFalse(zipf.filelist)
              zipf.comment = b"this is a comment"
          with zipfile.ZipFile(TESTFN, "r") as zipf:
              self.assertEqual(zipf.comment, b"this is a comment")
  
      def test_change_comment_in_nonempty_archive(self):
          with zipfile.ZipFile(TESTFN, "w", zipfile.ZIP_STORED) as zipf:
              zipf.writestr("foo.txt", "O, for a Muse of Fire!")
          with zipfile.ZipFile(TESTFN, "a", zipfile.ZIP_STORED) as zipf:
              self.assertTrue(zipf.filelist)
              zipf.comment = b"this is a comment"
          with zipfile.ZipFile(TESTFN, "r") as zipf:
              self.assertEqual(zipf.comment, b"this is a comment")
  
      def test_empty_zipfile(self):
          # Check that creating a file in 'w' or 'a' mode and closing without
          # adding any files to the archives creates a valid empty ZIP file
          zipf = zipfile.ZipFile(TESTFN, mode="w")
          zipf.close()
          try:
              zipf = zipfile.ZipFile(TESTFN, mode="r")
          except zipfile.BadZipFile:
              self.fail("Unable to create empty ZIP file in 'w' mode")
  
          zipf = zipfile.ZipFile(TESTFN, mode="a")
          zipf.close()
          try:
              zipf = zipfile.ZipFile(TESTFN, mode="r")
          except:
              self.fail("Unable to create empty ZIP file in 'a' mode")
  
      def test_open_empty_file(self):
          # Issue 1710703: Check that opening a file with less than 22 bytes
          # raises a BadZipFile exception (rather than the previously unhelpful
          # OSError)
          f = open(TESTFN, 'w')
          f.close()
          self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, TESTFN, 'r')
  
      def test_create_zipinfo_before_1980(self):
          self.assertRaises(ValueError,
                            zipfile.ZipInfo, 'seventies', (1979, 1, 1, 0, 0, 0))
  
      def test_zipfile_with_short_extra_field(self):
          """If an extra field in the header is less than 4 bytes, skip it."""
          zipdata = (
              b'PK\x03\x04\x14\x00\x00\x00\x00\x00\x93\x9b\xad@\x8b\x9e'
              b'\xd9\xd3\x01\x00\x00\x00\x01\x00\x00\x00\x03\x00\x03\x00ab'
              b'c\x00\x00\x00APK\x01\x02\x14\x03\x14\x00\x00\x00\x00'
              b'\x00\x93\x9b\xad@\x8b\x9e\xd9\xd3\x01\x00\x00\x00\x01\x00\x00'
              b'\x00\x03\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x00'
              b'\x00\x00\x00abc\x00\x00PK\x05\x06\x00\x00\x00\x00'
              b'\x01\x00\x01\x003\x00\x00\x00%\x00\x00\x00\x00\x00'
          )
          with zipfile.ZipFile(io.BytesIO(zipdata), 'r') as zipf:
              # testzip returns the name of the first corrupt file, or None
              self.assertIsNone(zipf.testzip())
  
      def tearDown(self):
          unlink(TESTFN)
          unlink(TESTFN2)
  
  
  class AbstractBadCrcTests:
      def test_testzip_with_bad_crc(self):
          """Tests that files with bad CRCs return their name from testzip."""
          zipdata = self.zip_with_bad_crc
  
          with zipfile.ZipFile(io.BytesIO(zipdata), mode="r") as zipf:
              # testzip returns the name of the first corrupt file, or None
              self.assertEqual('afile', zipf.testzip())
  
      def test_read_with_bad_crc(self):
          """Tests that files with bad CRCs raise a BadZipFile exception when read."""
          zipdata = self.zip_with_bad_crc
  
          # Using ZipFile.read()
          with zipfile.ZipFile(io.BytesIO(zipdata), mode="r") as zipf:
              self.assertRaises(zipfile.BadZipFile, zipf.read, 'afile')
  
          # Using ZipExtFile.read()
          with zipfile.ZipFile(io.BytesIO(zipdata), mode="r") as zipf:
              with zipf.open('afile', 'r') as corrupt_file:
                  self.assertRaises(zipfile.BadZipFile, corrupt_file.read)
  
          # Same with small reads (in order to exercise the buffering logic)
          with zipfile.ZipFile(io.BytesIO(zipdata), mode="r") as zipf:
              with zipf.open('afile', 'r') as corrupt_file:
                  corrupt_file.MIN_READ_SIZE = 2
                  with self.assertRaises(zipfile.BadZipFile):
                      while corrupt_file.read(2):
                          pass
  
  
  class StoredBadCrcTests(AbstractBadCrcTests, unittest.TestCase):
      compression = zipfile.ZIP_STORED
      zip_with_bad_crc = (
          b'PK\003\004\024\0\0\0\0\0 \213\212;:r'
          b'\253\377\f\0\0\0\f\0\0\0\005\0\0\000af'
          b'ilehello,AworldP'
          b'K\001\002\024\003\024\0\0\0\0\0 \213\212;:'
          b'r\253\377\f\0\0\0\f\0\0\0\005\0\0\0\0'
          b'\0\0\0\0\0\0\0\200\001\0\0\0\000afi'
          b'lePK\005\006\0\0\0\0\001\0\001\0003\000'
          b'\0\0/\0\0\0\0\0')
  
  @requires_zlib
  class DeflateBadCrcTests(AbstractBadCrcTests, unittest.TestCase):
      compression = zipfile.ZIP_DEFLATED
      zip_with_bad_crc = (
          b'PK\x03\x04\x14\x00\x00\x00\x08\x00n}\x0c=FA'
          b'KE\x10\x00\x00\x00n\x00\x00\x00\x05\x00\x00\x00af'
          b'ile\xcbH\xcd\xc9\xc9W(\xcf/\xcaI\xc9\xa0'
          b'=\x13\x00PK\x01\x02\x14\x03\x14\x00\x00\x00\x08\x00n'
          b'}\x0c=FAKE\x10\x00\x00\x00n\x00\x00\x00\x05'
          b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x00\x00\x00'
          b'\x00afilePK\x05\x06\x00\x00\x00\x00\x01\x00'
          b'\x01\x003\x00\x00\x003\x00\x00\x00\x00\x00')
  
  @requires_bz2
  class Bzip2BadCrcTests(AbstractBadCrcTests, unittest.TestCase):
      compression = zipfile.ZIP_BZIP2
      zip_with_bad_crc = (
          b'PK\x03\x04\x14\x03\x00\x00\x0c\x00nu\x0c=FA'
          b'KE8\x00\x00\x00n\x00\x00\x00\x05\x00\x00\x00af'
          b'ileBZh91AY&SY\xd4\xa8\xca'
          b'\x7f\x00\x00\x0f\x11\x80@\x00\x06D\x90\x80 \x00 \xa5'
          b'P\xd9!\x03\x03\x13\x13\x13\x89\xa9\xa9\xc2u5:\x9f'
          b'\x8b\xb9"\x9c(HjTe?\x80PK\x01\x02\x14'
          b'\x03\x14\x03\x00\x00\x0c\x00nu\x0c=FAKE8'
          b'\x00\x00\x00n\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00'
          b'\x00 \x80\x80\x81\x00\x00\x00\x00afilePK'
          b'\x05\x06\x00\x00\x00\x00\x01\x00\x01\x003\x00\x00\x00[\x00'
          b'\x00\x00\x00\x00')
  
  @requires_lzma
  class LzmaBadCrcTests(AbstractBadCrcTests, unittest.TestCase):
      compression = zipfile.ZIP_LZMA
      zip_with_bad_crc = (
          b'PK\x03\x04\x14\x03\x00\x00\x0e\x00nu\x0c=FA'
          b'KE\x1b\x00\x00\x00n\x00\x00\x00\x05\x00\x00\x00af'
          b'ile\t\x04\x05\x00]\x00\x00\x00\x04\x004\x19I'
          b'\xee\x8d\xe9\x17\x89:3`\tq!.8\x00PK'
          b'\x01\x02\x14\x03\x14\x03\x00\x00\x0e\x00nu\x0c=FA'
          b'KE\x1b\x00\x00\x00n\x00\x00\x00\x05\x00\x00\x00\x00\x00'
          b'\x00\x00\x00\x00 \x80\x80\x81\x00\x00\x00\x00afil'
          b'ePK\x05\x06\x00\x00\x00\x00\x01\x00\x01\x003\x00\x00'
          b'\x00>\x00\x00\x00\x00\x00')
  
  
  class DecryptionTests(unittest.TestCase):
      """Check that ZIP decryption works. Since the library does not
      support encryption at the moment, we use a pre-generated encrypted
      ZIP file."""
  
      data = (
          b'PK\x03\x04\x14\x00\x01\x00\x00\x00n\x92i.#y\xef?&\x00\x00\x00\x1a\x00'
          b'\x00\x00\x08\x00\x00\x00test.txt\xfa\x10\xa0gly|\xfa-\xc5\xc0=\xf9y'
          b'\x18\xe0\xa8r\xb3Z}Lg\xbc\xae\xf9|\x9b\x19\xe4\x8b\xba\xbb)\x8c\xb0\xdbl'
          b'PK\x01\x02\x14\x00\x14\x00\x01\x00\x00\x00n\x92i.#y\xef?&\x00\x00\x00'
          b'\x1a\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x01\x00 \x00\xb6\x81'
          b'\x00\x00\x00\x00test.txtPK\x05\x06\x00\x00\x00\x00\x01\x00\x01\x006\x00'
          b'\x00\x00L\x00\x00\x00\x00\x00' )
      data2 = (
          b'PK\x03\x04\x14\x00\t\x00\x08\x00\xcf}38xu\xaa\xb2\x14\x00\x00\x00\x00\x02'
          b'\x00\x00\x04\x00\x15\x00zeroUT\t\x00\x03\xd6\x8b\x92G\xda\x8b\x92GUx\x04'
          b'\x00\xe8\x03\xe8\x03\xc7<M\xb5a\xceX\xa3Y&\x8b{oE\xd7\x9d\x8c\x98\x02\xc0'
          b'PK\x07\x08xu\xaa\xb2\x14\x00\x00\x00\x00\x02\x00\x00PK\x01\x02\x17\x03'
          b'\x14\x00\t\x00\x08\x00\xcf}38xu\xaa\xb2\x14\x00\x00\x00\x00\x02\x00\x00'
          b'\x04\x00\r\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x00\x00\x00\x00ze'
          b'roUT\x05\x00\x03\xd6\x8b\x92GUx\x00\x00PK\x05\x06\x00\x00\x00\x00\x01'
          b'\x00\x01\x00?\x00\x00\x00[\x00\x00\x00\x00\x00' )
  
      plain = b'zipfile.py encryption test'
      plain2 = b'\x00'*512
  
      def setUp(self):
          with open(TESTFN, "wb") as fp:
              fp.write(self.data)
          self.zip = zipfile.ZipFile(TESTFN, "r")
          with open(TESTFN2, "wb") as fp:
              fp.write(self.data2)
          self.zip2 = zipfile.ZipFile(TESTFN2, "r")
  
      def tearDown(self):
          self.zip.close()
          os.unlink(TESTFN)
          self.zip2.close()
          os.unlink(TESTFN2)
  
      def test_no_password(self):
          # Reading the encrypted file without password
          # must generate a RunTime exception
          self.assertRaises(RuntimeError, self.zip.read, "test.txt")
          self.assertRaises(RuntimeError, self.zip2.read, "zero")
  
      def test_bad_password(self):
          self.zip.setpassword(b"perl")
          self.assertRaises(RuntimeError, self.zip.read, "test.txt")
          self.zip2.setpassword(b"perl")
          self.assertRaises(RuntimeError, self.zip2.read, "zero")
  
      @requires_zlib
      def test_good_password(self):
          self.zip.setpassword(b"python")
          self.assertEqual(self.zip.read("test.txt"), self.plain)
          self.zip2.setpassword(b"12345")
          self.assertEqual(self.zip2.read("zero"), self.plain2)
  
      def test_unicode_password(self):
          self.assertRaises(TypeError, self.zip.setpassword, "unicode")
          self.assertRaises(TypeError, self.zip.read, "test.txt", "python")
          self.assertRaises(TypeError, self.zip.open, "test.txt", pwd="python")
          self.assertRaises(TypeError, self.zip.extract, "test.txt", pwd="python")
  
  class AbstractTestsWithRandomBinaryFiles:
      @classmethod
      def setUpClass(cls):
          datacount = randint(16, 64)*1024 + randint(1, 1024)
          cls.data = b''.join(struct.pack('<f', random()*randint(-1000, 1000))
                              for i in range(datacount))
  
      def setUp(self):
          # Make a source file with some lines
          with open(TESTFN, "wb") as fp:
              fp.write(self.data)
  
      def tearDown(self):
          unlink(TESTFN)
          unlink(TESTFN2)
  
      def make_test_archive(self, f, compression):
          # Create the ZIP archive
          with zipfile.ZipFile(f, "w", compression) as zipfp:
              zipfp.write(TESTFN, "another.name")
              zipfp.write(TESTFN, TESTFN)
  
      def zip_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r", compression) as zipfp:
              testdata = zipfp.read(TESTFN)
              self.assertEqual(len(testdata), len(self.data))
              self.assertEqual(testdata, self.data)
              self.assertEqual(zipfp.read("another.name"), self.data)
  
      def test_read(self):
          for f in get_files(self):
              self.zip_test(f, self.compression)
  
      def zip_open_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r", compression) as zipfp:
              zipdata1 = []
              with zipfp.open(TESTFN) as zipopen1:
                  while True:
                      read_data = zipopen1.read(256)
                      if not read_data:
                          break
                      zipdata1.append(read_data)
  
              zipdata2 = []
              with zipfp.open("another.name") as zipopen2:
                  while True:
                      read_data = zipopen2.read(256)
                      if not read_data:
                          break
                      zipdata2.append(read_data)
  
              testdata1 = b''.join(zipdata1)
              self.assertEqual(len(testdata1), len(self.data))
              self.assertEqual(testdata1, self.data)
  
              testdata2 = b''.join(zipdata2)
              self.assertEqual(len(testdata2), len(self.data))
              self.assertEqual(testdata2, self.data)
  
      def test_open(self):
          for f in get_files(self):
              self.zip_open_test(f, self.compression)
  
      def zip_random_open_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r", compression) as zipfp:
              zipdata1 = []
              with zipfp.open(TESTFN) as zipopen1:
                  while True:
                      read_data = zipopen1.read(randint(1, 1024))
                      if not read_data:
                          break
                      zipdata1.append(read_data)
  
              testdata = b''.join(zipdata1)
              self.assertEqual(len(testdata), len(self.data))
              self.assertEqual(testdata, self.data)
  
      def test_random_open(self):
          for f in get_files(self):
              self.zip_random_open_test(f, self.compression)
  
  
  class StoredTestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles,
                                         unittest.TestCase):
      compression = zipfile.ZIP_STORED
  
  @requires_zlib
  class DeflateTestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles,
                                          unittest.TestCase):
      compression = zipfile.ZIP_DEFLATED
  
  @requires_bz2
  class Bzip2TestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles,
                                        unittest.TestCase):
      compression = zipfile.ZIP_BZIP2
  
  @requires_lzma
  class LzmaTestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles,
                                       unittest.TestCase):
      compression = zipfile.ZIP_LZMA
  
  
  # Privide the tell() method but not seek()
  class Tellable:
      def __init__(self, fp):
          self.fp = fp
          self.offset = 0
  
      def write(self, data):
          n = self.fp.write(data)
          self.offset += n
          return n
  
      def tell(self):
          return self.offset
  
      def flush(self):
          self.fp.flush()
  
  class Unseekable:
      def __init__(self, fp):
          self.fp = fp
  
      def write(self, data):
          return self.fp.write(data)
  
      def flush(self):
          self.fp.flush()
  
  class UnseekableTests(unittest.TestCase):
      def test_writestr(self):
          for wrapper in (lambda f: f), Tellable, Unseekable:
              with self.subTest(wrapper=wrapper):
                  f = io.BytesIO()
                  f.write(b'abc')
                  bf = io.BufferedWriter(f)
                  with zipfile.ZipFile(wrapper(bf), 'w', zipfile.ZIP_STORED) as zipfp:
                      zipfp.writestr('ones', b'111')
                      zipfp.writestr('twos', b'222')
                  self.assertEqual(f.getvalue()[:5], b'abcPK')
                  with zipfile.ZipFile(f, mode='r') as zipf:
                      with zipf.open('ones') as zopen:
                          self.assertEqual(zopen.read(), b'111')
                      with zipf.open('twos') as zopen:
                          self.assertEqual(zopen.read(), b'222')
  
      def test_write(self):
          for wrapper in (lambda f: f), Tellable, Unseekable:
              with self.subTest(wrapper=wrapper):
                  f = io.BytesIO()
                  f.write(b'abc')
                  bf = io.BufferedWriter(f)
                  with zipfile.ZipFile(wrapper(bf), 'w', zipfile.ZIP_STORED) as zipfp:
                      self.addCleanup(unlink, TESTFN)
                      with open(TESTFN, 'wb') as f2:
                          f2.write(b'111')
                      zipfp.write(TESTFN, 'ones')
                      with open(TESTFN, 'wb') as f2:
                          f2.write(b'222')
                      zipfp.write(TESTFN, 'twos')
                  self.assertEqual(f.getvalue()[:5], b'abcPK')
                  with zipfile.ZipFile(f, mode='r') as zipf:
                      with zipf.open('ones') as zopen:
                          self.assertEqual(zopen.read(), b'111')
                      with zipf.open('twos') as zopen:
                          self.assertEqual(zopen.read(), b'222')
  
  
  @requires_zlib
  class TestsWithMultipleOpens(unittest.TestCase):
      @classmethod
      def setUpClass(cls):
          cls.data1 = b'111' + getrandbytes(10000)
          cls.data2 = b'222' + getrandbytes(10000)
  
      def make_test_archive(self, f):
          # Create the ZIP archive
          with zipfile.ZipFile(f, "w", zipfile.ZIP_DEFLATED) as zipfp:
              zipfp.writestr('ones', self.data1)
              zipfp.writestr('twos', self.data2)
  
      def test_same_file(self):
          # Verify that (when the ZipFile is in control of creating file objects)
          # multiple open() calls can be made without interfering with each other.
          for f in get_files(self):
              self.make_test_archive(f)
              with zipfile.ZipFile(f, mode="r") as zipf:
                  with zipf.open('ones') as zopen1, zipf.open('ones') as zopen2:
                      data1 = zopen1.read(500)
                      data2 = zopen2.read(500)
                      data1 += zopen1.read()
                      data2 += zopen2.read()
                  self.assertEqual(data1, data2)
                  self.assertEqual(data1, self.data1)
  
      def test_different_file(self):
          # Verify that (when the ZipFile is in control of creating file objects)
          # multiple open() calls can be made without interfering with each other.
          for f in get_files(self):
              self.make_test_archive(f)
              with zipfile.ZipFile(f, mode="r") as zipf:
                  with zipf.open('ones') as zopen1, zipf.open('twos') as zopen2:
                      data1 = zopen1.read(500)
                      data2 = zopen2.read(500)
                      data1 += zopen1.read()
                      data2 += zopen2.read()
                  self.assertEqual(data1, self.data1)
                  self.assertEqual(data2, self.data2)
  
      def test_interleaved(self):
          # Verify that (when the ZipFile is in control of creating file objects)
          # multiple open() calls can be made without interfering with each other.
          for f in get_files(self):
              self.make_test_archive(f)
              with zipfile.ZipFile(f, mode="r") as zipf:
                  with zipf.open('ones') as zopen1, zipf.open('twos') as zopen2:
                      data1 = zopen1.read(500)
                      data2 = zopen2.read(500)
                      data1 += zopen1.read()
                      data2 += zopen2.read()
                  self.assertEqual(data1, self.data1)
                  self.assertEqual(data2, self.data2)
  
      def test_read_after_close(self):
          for f in get_files(self):
              self.make_test_archive(f)
              with contextlib.ExitStack() as stack:
                  with zipfile.ZipFile(f, 'r') as zipf:
                      zopen1 = stack.enter_context(zipf.open('ones'))
                      zopen2 = stack.enter_context(zipf.open('twos'))
                  data1 = zopen1.read(500)
                  data2 = zopen2.read(500)
                  data1 += zopen1.read()
                  data2 += zopen2.read()
              self.assertEqual(data1, self.data1)
              self.assertEqual(data2, self.data2)
  
      def test_read_after_write(self):
          for f in get_files(self):
              with zipfile.ZipFile(f, 'w', zipfile.ZIP_DEFLATED) as zipf:
                  zipf.writestr('ones', self.data1)
                  zipf.writestr('twos', self.data2)
                  with zipf.open('ones') as zopen1:
                      data1 = zopen1.read(500)
              self.assertEqual(data1, self.data1[:500])
              with zipfile.ZipFile(f, 'r') as zipf:
                  data1 = zipf.read('ones')
                  data2 = zipf.read('twos')
              self.assertEqual(data1, self.data1)
              self.assertEqual(data2, self.data2)
  
      def test_write_after_read(self):
          for f in get_files(self):
              with zipfile.ZipFile(f, "w", zipfile.ZIP_DEFLATED) as zipf:
                  zipf.writestr('ones', self.data1)
                  with zipf.open('ones') as zopen1:
                      zopen1.read(500)
                      zipf.writestr('twos', self.data2)
              with zipfile.ZipFile(f, 'r') as zipf:
                  data1 = zipf.read('ones')
                  data2 = zipf.read('twos')
              self.assertEqual(data1, self.data1)
              self.assertEqual(data2, self.data2)
  
      def test_many_opens(self):
          # Verify that read() and open() promptly close the file descriptor,
          # and don't rely on the garbage collector to free resources.
          self.make_test_archive(TESTFN2)
          with zipfile.ZipFile(TESTFN2, mode="r") as zipf:
              for x in range(100):
                  zipf.read('ones')
                  with zipf.open('ones') as zopen1:
                      pass
          with open(os.devnull) as f:
              self.assertLess(f.fileno(), 100)
  
      def tearDown(self):
          unlink(TESTFN2)
  
  
  class TestWithDirectory(unittest.TestCase):
      def setUp(self):
          os.mkdir(TESTFN2)
  
      def test_extract_dir(self):
          with zipfile.ZipFile(findfile("zipdir.zip")) as zipf:
              zipf.extractall(TESTFN2)
          self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "a")))
          self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "a", "b")))
          self.assertTrue(os.path.exists(os.path.join(TESTFN2, "a", "b", "c")))
  
      def test_bug_6050(self):
          # Extraction should succeed if directories already exist
          os.mkdir(os.path.join(TESTFN2, "a"))
          self.test_extract_dir()
  
      def test_write_dir(self):
          dirpath = os.path.join(TESTFN2, "x")
          os.mkdir(dirpath)
          mode = os.stat(dirpath).st_mode & 0xFFFF
          with zipfile.ZipFile(TESTFN, "w") as zipf:
              zipf.write(dirpath)
              zinfo = zipf.filelist[0]
              self.assertTrue(zinfo.filename.endswith("/x/"))
              self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
              zipf.write(dirpath, "y")
              zinfo = zipf.filelist[1]
              self.assertTrue(zinfo.filename, "y/")
              self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
          with zipfile.ZipFile(TESTFN, "r") as zipf:
              zinfo = zipf.filelist[0]
              self.assertTrue(zinfo.filename.endswith("/x/"))
              self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
              zinfo = zipf.filelist[1]
              self.assertTrue(zinfo.filename, "y/")
              self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
              target = os.path.join(TESTFN2, "target")
              os.mkdir(target)
              zipf.extractall(target)
              self.assertTrue(os.path.isdir(os.path.join(target, "y")))
              self.assertEqual(len(os.listdir(target)), 2)
  
      def test_writestr_dir(self):
          os.mkdir(os.path.join(TESTFN2, "x"))
          with zipfile.ZipFile(TESTFN, "w") as zipf:
              zipf.writestr("x/", b'')
              zinfo = zipf.filelist[0]
              self.assertEqual(zinfo.filename, "x/")
              self.assertEqual(zinfo.external_attr, (0o40775 << 16) | 0x10)
          with zipfile.ZipFile(TESTFN, "r") as zipf:
              zinfo = zipf.filelist[0]
              self.assertTrue(zinfo.filename.endswith("x/"))
              self.assertEqual(zinfo.external_attr, (0o40775 << 16) | 0x10)
              target = os.path.join(TESTFN2, "target")
              os.mkdir(target)
              zipf.extractall(target)
              self.assertTrue(os.path.isdir(os.path.join(target, "x")))
              self.assertEqual(os.listdir(target), ["x"])
  
      def tearDown(self):
          rmtree(TESTFN2)
          if os.path.exists(TESTFN):
              unlink(TESTFN)
  
  
  class AbstractUniversalNewlineTests:
      @classmethod
      def setUpClass(cls):
          cls.line_gen = [bytes("Test of zipfile line %d." % i, "ascii")
                          for i in range(FIXEDTEST_SIZE)]
          cls.seps = (b'\r', b'\r\n', b'\n')
          cls.arcdata = {}
          for n, s in enumerate(cls.seps):
              cls.arcdata[s] = s.join(cls.line_gen) + s
  
      def setUp(self):
          self.arcfiles = {}
          for n, s in enumerate(self.seps):
              self.arcfiles[s] = '%s-%d' % (TESTFN, n)
              with open(self.arcfiles[s], "wb") as f:
                  f.write(self.arcdata[s])
  
      def make_test_archive(self, f, compression):
          # Create the ZIP archive
          with zipfile.ZipFile(f, "w", compression) as zipfp:
              for fn in self.arcfiles.values():
                  zipfp.write(fn, fn)
  
      def read_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r") as zipfp:
              for sep, fn in self.arcfiles.items():
                  with openU(zipfp, fn) as fp:
                      zipdata = fp.read()
                  self.assertEqual(self.arcdata[sep], zipdata)
  
      def test_read(self):
          for f in get_files(self):
              self.read_test(f, self.compression)
  
      def readline_read_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r") as zipfp:
              for sep, fn in self.arcfiles.items():
                  with openU(zipfp, fn) as zipopen:
                      data = b''
                      while True:
                          read = zipopen.readline()
                          if not read:
                              break
                          data += read
  
                          read = zipopen.read(5)
                          if not read:
                              break
                          data += read
  
              self.assertEqual(data, self.arcdata[b'\n'])
  
      def test_readline_read(self):
          for f in get_files(self):
              self.readline_read_test(f, self.compression)
  
      def readline_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r") as zipfp:
              for sep, fn in self.arcfiles.items():
                  with openU(zipfp, fn) as zipopen:
                      for line in self.line_gen:
                          linedata = zipopen.readline()
                          self.assertEqual(linedata, line + b'\n')
  
      def test_readline(self):
          for f in get_files(self):
              self.readline_test(f, self.compression)
  
      def readlines_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r") as zipfp:
              for sep, fn in self.arcfiles.items():
                  with openU(zipfp, fn) as fp:
                      ziplines = fp.readlines()
                  for line, zipline in zip(self.line_gen, ziplines):
                      self.assertEqual(zipline, line + b'\n')
  
      def test_readlines(self):
          for f in get_files(self):
              self.readlines_test(f, self.compression)
  
      def iterlines_test(self, f, compression):
          self.make_test_archive(f, compression)
  
          # Read the ZIP archive
          with zipfile.ZipFile(f, "r") as zipfp:
              for sep, fn in self.arcfiles.items():
                  with openU(zipfp, fn) as fp:
                      for line, zipline in zip(self.line_gen, fp):
                          self.assertEqual(zipline, line + b'\n')
  
      def test_iterlines(self):
          for f in get_files(self):
              self.iterlines_test(f, self.compression)
  
      def tearDown(self):
          for sep, fn in self.arcfiles.items():
              unlink(fn)
          unlink(TESTFN)
          unlink(TESTFN2)
  
  
  class StoredUniversalNewlineTests(AbstractUniversalNewlineTests,
                                    unittest.TestCase):
      compression = zipfile.ZIP_STORED
  
  @requires_zlib
  class DeflateUniversalNewlineTests(AbstractUniversalNewlineTests,
                                     unittest.TestCase):
      compression = zipfile.ZIP_DEFLATED
  
  @requires_bz2
  class Bzip2UniversalNewlineTests(AbstractUniversalNewlineTests,
                                   unittest.TestCase):
      compression = zipfile.ZIP_BZIP2
  
  @requires_lzma
  class LzmaUniversalNewlineTests(AbstractUniversalNewlineTests,
                                  unittest.TestCase):
      compression = zipfile.ZIP_LZMA
  
  if __name__ == "__main__":
      unittest.main()
  