Lines Matching refs:self
61 def setUp(self):
64 fp.write(self.data)
66 def make_test_archive(self, f, compression, compresslevel=None):
72 zipfp.writestr("strfile", self.data)
74 for line in self.line_gen:
77 def zip_test(self, f, compression, compresslevel=None):
78 self.make_test_archive(f, compression, compresslevel)
82 self.assertEqual(zipfp.read(TESTFN), self.data)
83 self.assertEqual(zipfp.read("another.name"), self.data)
84 self.assertEqual(zipfp.read("strfile"), self.data)
91 self.assertEqual(len(lines), 5) # Number of files + header
93 self.assertIn('File Name', lines[0])
94 self.assertIn('Modified', lines[0])
95 self.assertIn('Size', lines[0])
98 self.assertEqual(fn, 'another.name')
99 self.assertTrue(time.strptime(date, '%Y-%m-%d'))
100 self.assertTrue(time.strptime(time_, '%H:%M:%S'))
101 self.assertEqual(size, str(len(self.data)))
105 self.assertEqual(len(names), 4)
106 self.assertIn(TESTFN, names)
107 self.assertIn("another.name", names)
108 self.assertIn("strfile", names)
109 self.assertIn("written-open-w", names)
114 self.assertEqual(len(names), 4)
115 self.assertIn(TESTFN, names)
116 self.assertIn("another.name", names)
117 self.assertIn("strfile", names)
118 self.assertIn("written-open-w", names)
120 self.assertEqual(i.file_size, len(self.data))
125 self.assertEqual(info.filename, nm)
126 self.assertEqual(info.file_size, len(self.data))
131 def test_basic(self):
132 for f in get_files(self):
133 self.zip_test(f, self.compression)
135 def zip_open_test(self, f, compression):
136 self.make_test_archive(f, compression)
156 self.assertEqual(b''.join(zipdata1), self.data)
157 self.assertEqual(b''.join(zipdata2), self.data)
159 def test_open(self):
160 for f in get_files(self):
161 self.zip_open_test(f, self.compression)
163 def test_open_with_pathlike(self):
165 self.zip_open_test(path, self.compression)
166 with zipfile.ZipFile(path, "r", self.compression) as zipfp:
167 self.assertIsInstance(zipfp.filename, str)
169 def zip_random_open_test(self, f, compression):
170 self.make_test_archive(f, compression)
182 self.assertEqual(b''.join(zipdata1), self.data)
184 def test_random_open(self):
185 for f in get_files(self):
186 self.zip_random_open_test(f, self.compression)
188 def zip_read1_test(self, f, compression):
189 self.make_test_archive(f, compression)
201 self.assertEqual(b''.join(zipdata), self.data)
203 def test_read1(self):
204 for f in get_files(self):
205 self.zip_read1_test(f, self.compression)
207 def zip_read1_10_test(self, f, compression):
208 self.make_test_archive(f, compression)
216 self.assertLessEqual(len(read_data), 10)
221 self.assertEqual(b''.join(zipdata), self.data)
223 def test_read1_10(self):
224 for f in get_files(self):
225 self.zip_read1_10_test(f, self.compression)
227 def zip_readline_read_test(self, f, compression):
228 self.make_test_archive(f, compression)
245 self.assertEqual(data, self.data)
247 def test_readline_read(self):
249 for f in get_files(self):
250 self.zip_readline_read_test(f, self.compression)
252 def zip_readline_test(self, f, compression):
253 self.make_test_archive(f, compression)
258 for line in self.line_gen:
260 self.assertEqual(linedata, line)
262 def test_readline(self):
263 for f in get_files(self):
264 self.zip_readline_test(f, self.compression)
266 def zip_readlines_test(self, f, compression):
267 self.make_test_archive(f, compression)
273 for line, zipline in zip(self.line_gen, ziplines):
274 self.assertEqual(zipline, line)
276 def test_readlines(self):
277 for f in get_files(self):
278 self.zip_readlines_test(f, self.compression)
280 def zip_iterlines_test(self, f, compression):
281 self.make_test_archive(f, compression)
286 for line, zipline in zip(self.line_gen, zipopen):
287 self.assertEqual(zipline, line)
289 def test_iterlines(self):
290 for f in get_files(self):
291 self.zip_iterlines_test(f, self.compression)
293 def test_low_compression(self):
296 with zipfile.ZipFile(TESTFN2, "w", self.compression) as zipfp:
300 with zipfile.ZipFile(TESTFN2, "r", self.compression) as zipfp:
302 self.assertEqual(openobj.read(1), b'1')
303 self.assertEqual(openobj.read(1), b'2')
305 def test_writestr_compression(self):
307 zipfp.writestr("b.txt", "hello world", compress_type=self.compression)
309 self.assertEqual(info.compress_type, self.compression)
311 def test_writestr_compresslevel(self):
313 zipfp.writestr("a.txt", "hello world", compress_type=self.compression)
314 zipfp.writestr("b.txt", "hello world", compress_type=self.compression,
319 self.assertEqual(a_info.compress_type, self.compression)
320 self.assertEqual(a_info._compresslevel, 1)
324 self.assertEqual(b_info.compress_type, self.compression)
325 self.assertEqual(b_info._compresslevel, 2)
327 def test_read_return_size(self):
333 with zipfile.ZipFile(io.BytesIO(), "w", self.compression) as zipf:
337 self.assertEqual(len(buf), test_size)
339 def test_truncated_zipfile(self):
342 zipf.writestr('strfile', self.data, compress_type=self.compression)
350 with self.assertRaises(EOFError):
357 with self.assertRaises(EOFError):
365 with self.assertRaises(EOFError):
369 def test_repr(self):
371 for f in get_files(self):
372 with zipfile.ZipFile(f, 'w', self.compression) as zipfp:
375 self.assertIn("mode='w'", r)
380 self.assertIn('filename=%r' % f, r)
382 self.assertIn('file=%r' % f, r)
383 self.assertIn("mode='r'", r)
385 self.assertIn('filename=%r' % fname, r)
386 self.assertIn('filemode=', r)
387 self.assertIn('file_size=', r)
388 if self.compression != zipfile.ZIP_STORED:
389 self.assertIn('compress_type=', r)
390 self.assertIn('compress_size=', r)
393 self.assertIn('name=%r' % fname, r)
394 self.assertIn("mode='r'", r)
395 if self.compression != zipfile.ZIP_STORED:
396 self.assertIn('compress_type=', r)
397 self.assertIn('[closed]', repr(zipopen))
398 self.assertIn('[closed]', repr(zipfp))
400 def test_compresslevel_basic(self):
401 for f in get_files(self):
402 self.zip_test(f, self.compression, compresslevel=9)
404 def test_per_file_compresslevel(self):
412 self.assertEqual(one_info._compresslevel, 1)
413 self.assertEqual(nine_info._compresslevel, 9)
415 def test_writing_errors(self):
417 def write(self, data):
429 with zipfile.ZipFile(testfile, 'w', self.compression) as zipfp:
443 self.assertEqual(zipfp.namelist(), ['file1'])
444 self.assertEqual(zipfp.read('file1'), b'data1')
447 self.assertEqual(zipfp.namelist(), ['file1', 'file2'])
448 self.assertEqual(zipfp.read('file1'), b'data1')
449 self.assertEqual(zipfp.read('file2'), b'data2')
452 def tearDown(self):
462 def zip_test_writestr_permissions(self, f, compression):
467 self.make_test_archive(f, compression)
470 self.assertEqual(zinfo.external_attr, 0o600 << 16)
473 self.assertEqual(zinfo2.external_attr, 0o600 << 16)
475 def test_writestr_permissions(self):
476 for f in get_files(self):
477 self.zip_test_writestr_permissions(f, zipfile.ZIP_STORED)
479 def test_absolute_arcnames(self):
484 self.assertEqual(zipfp.namelist(), ["absolute"])
486 def test_append_to_zip_file(self):
492 zipfp.writestr("strfile", self.data)
493 self.assertEqual(zipfp.namelist(), [TESTFN, "strfile"])
495 def test_append_to_non_zip_file(self):
509 self.assertEqual(zipfp.namelist(), [TESTFN])
510 self.assertEqual(zipfp.read(TESTFN), self.data)
512 self.assertEqual(f.read(len(data)), data)
515 self.assertEqual(zipfp.namelist(), [TESTFN])
516 self.assertEqual(zipfp.read(TESTFN), self.data)
518 def test_read_concatenated_zip_file(self):
529 self.assertEqual(zipfp.namelist(), [TESTFN])
530 self.assertEqual(zipfp.read(TESTFN), self.data)
532 def test_append_to_concatenated_zip_file(self):
543 self.assertEqual(zipfp.namelist(), [TESTFN])
544 zipfp.writestr('strfile', self.data)
547 self.assertEqual(f.read(len(data)), data)
550 self.assertEqual(zipfp.namelist(), [TESTFN, 'strfile'])
551 self.assertEqual(zipfp.read(TESTFN), self.data)
552 self.assertEqual(zipfp.read('strfile'), self.data)
554 def test_ignores_newline_at_end(self):
560 self.assertIsInstance(zipfp, zipfile.ZipFile)
562 def test_ignores_stuff_appended_past_comments(self):
569 self.assertIsInstance(zipfp, zipfile.ZipFile)
570 self.assertEqual(zipfp.comment, b"this is a comment")
572 def test_write_default_name(self):
578 self.assertEqual(zipfp.read(TESTFN), f.read())
580 def test_io_on_closed_zipextfile(self):
588 self.assertRaises(ValueError, fid.read)
589 self.assertRaises(ValueError, fid.seek, 0)
590 self.assertRaises(ValueError, fid.tell)
591 self.assertRaises(ValueError, fid.readable)
592 self.assertRaises(ValueError, fid.seekable)
594 def test_write_to_readonly(self):
601 self.assertRaises(ValueError, zipfp.write, TESTFN)
604 with self.assertRaises(ValueError):
607 def test_add_file_before_1980(self):
611 self.assertRaises(ValueError, zipfp.write, TESTFN)
616 self.assertEqual(zinfo.date_time, (1980, 1, 1, 0, 0, 0))
618 def test_add_file_after_2107(self):
624 self.skipTest(f'time.localtime({ts}) raises OverflowError')
628 self.skipTest('Host fs cannot set timestamp to required value.')
640 self.skipTest(f"Linux VFS/XFS kernel bug detected: {mtime_ns=}")
643 self.assertRaises(struct.error, zipfp.write, TESTFN)
648 self.assertEqual(zinfo.date_time, (2107, 12, 31, 23, 59, 59))
656 def test_per_file_compression(self):
664 self.assertEqual(sinfo.compress_type, zipfile.ZIP_STORED)
665 self.assertEqual(dinfo.compress_type, zipfile.ZIP_DEFLATED)
688 def setUp(self):
689 self._limit = zipfile.ZIP64_LIMIT
690 self._filecount_limit = zipfile.ZIP_FILECOUNT_LIMIT
696 fp.write(self.data)
698 def zip_test(self, f, compression):
703 zipfp.writestr("strfile", self.data)
707 self.assertEqual(zipfp.read(TESTFN), self.data)
708 self.assertEqual(zipfp.read("another.name"), self.data)
709 self.assertEqual(zipfp.read("strfile"), self.data)
717 self.assertEqual(len(lines), 4) # Number of files + header
719 self.assertIn('File Name', lines[0])
720 self.assertIn('Modified', lines[0])
721 self.assertIn('Size', lines[0])
724 self.assertEqual(fn, 'another.name')
725 self.assertTrue(time.strptime(date, '%Y-%m-%d'))
726 self.assertTrue(time.strptime(time_, '%H:%M:%S'))
727 self.assertEqual(size, str(len(self.data)))
731 self.assertEqual(len(names), 3)
732 self.assertIn(TESTFN, names)
733 self.assertIn("another.name", names)
734 self.assertIn("strfile", names)
739 self.assertEqual(len(names), 3)
740 self.assertIn(TESTFN, names)
741 self.assertIn("another.name", names)
742 self.assertIn("strfile", names)
744 self.assertEqual(i.file_size, len(self.data))
749 self.assertEqual(info.filename, nm)
750 self.assertEqual(info.file_size, len(self.data))
755 def test_basic(self):
756 for f in get_files(self):
757 self.zip_test(f, self.compression)
759 def test_too_many_files(self):
762 zipf = zipfile.ZipFile(TESTFN, "w", self.compression,
768 self.assertEqual(len(zipf.namelist()), numfiles)
771 zipf2 = zipfile.ZipFile(TESTFN, "r", self.compression)
772 self.assertEqual(len(zipf2.namelist()), numfiles)
775 self.assertEqual(content, "%d" % (i**3 % 57))
778 def test_too_many_files_append(self):
779 zipf = zipfile.ZipFile(TESTFN, "w", self.compression,
785 self.assertEqual(len(zipf.namelist()), numfiles)
786 with self.assertRaises(zipfile.LargeZipFile):
788 self.assertEqual(len(zipf.namelist()), numfiles)
791 zipf = zipfile.ZipFile(TESTFN, "a", self.compression,
794 self.assertEqual(len(zipf.namelist()), numfiles)
795 with self.assertRaises(zipfile.LargeZipFile):
797 self.assertEqual(len(zipf.namelist()), numfiles)
800 zipf = zipfile.ZipFile(TESTFN, "a", self.compression,
803 self.assertEqual(len(zipf.namelist()), numfiles)
807 self.assertEqual(len(zipf.namelist()), numfiles2)
810 zipf2 = zipfile.ZipFile(TESTFN, "r", self.compression)
811 self.assertEqual(len(zipf2.namelist()), numfiles2)
814 self.assertEqual(content, "%d" % (i**3 % 57))
817 def tearDown(self):
818 zipfile.ZIP64_LIMIT = self._limit
819 zipfile.ZIP_FILECOUNT_LIMIT = self._filecount_limit
828 def large_file_exception_test(self, f, compression):
830 self.assertRaises(zipfile.LargeZipFile,
833 def large_file_exception_test2(self, f, compression):
835 self.assertRaises(zipfile.LargeZipFile,
836 zipfp.writestr, "another.name", self.data)
838 def test_large_file_exception(self):
839 for f in get_files(self):
840 self.large_file_exception_test(f, zipfile.ZIP_STORED)
841 self.large_file_exception_test2(f, zipfile.ZIP_STORED)
843 def test_absolute_arcnames(self):
849 self.assertEqual(zipfp.namelist(), ["absolute"])
851 def test_append(self):
855 zipfp.writestr("strfile", self.data)
860 zipfp.writestr("strfile2", self.data)
863 self.assertEqual(zinfo.extra, extra)
866 self, file_size_64_set=False, file_size_extra=False,
964 def test_bad_zip64_extra(self):
982 missing_file_size_extra = self.make_zip64_file(
985 with self.assertRaises(zipfile.BadZipFile) as e:
987 self.assertIn('file size', str(e.exception).lower())
991 missing_compress_size_extra = self.make_zip64_file(
996 with self.assertRaises(zipfile.BadZipFile) as e:
998 self.assertIn('compress size', str(e.exception).lower())
1002 missing_compress_size_extra = self.make_zip64_file(
1005 with self.assertRaises(zipfile.BadZipFile) as e:
1007 self.assertIn('compress size', str(e.exception).lower())
1012 missing_header_offset_extra = self.make_zip64_file(
1019 with self.assertRaises(zipfile.BadZipFile) as e:
1021 self.assertIn('header offset', str(e.exception).lower())
1025 missing_header_offset_extra = self.make_zip64_file(
1031 with self.assertRaises(zipfile.BadZipFile) as e:
1033 self.assertIn('header offset', str(e.exception).lower())
1037 missing_header_offset_extra = self.make_zip64_file(
1043 with self.assertRaises(zipfile.BadZipFile) as e:
1045 self.assertIn('header offset', str(e.exception).lower())
1049 missing_header_offset_extra = self.make_zip64_file(
1054 with self.assertRaises(zipfile.BadZipFile) as e:
1056 self.assertIn('header offset', str(e.exception).lower())
1058 def test_generated_valid_zip64_extra(self):
1078 with zipfile.ZipFile(io.BytesIO(self.make_zip64_file(**kwargs))) as zf:
1080 self.assertEqual(zinfo.file_size, expected_file_size)
1081 self.assertEqual(zinfo.compress_size, expected_compress_size)
1082 self.assertEqual(zinfo.header_offset, expected_header_offset)
1083 self.assertEqual(zf.read(zinfo), expected_content)
1085 def test_force_zip64(self):
1119 self.assertEqual(header, b"PK\x03\x04") # local file header
1120 self.assertGreaterEqual(vers, zipfile.ZIP64_VERSION) # requires zip64 to extract
1121 self.assertEqual(os, 0) # compatible with MS-DOS
1122 self.assertEqual(flags, 0) # no flags
1123 self.assertEqual(comp, 0) # compression method = stored
1124 self.assertEqual(csize, 0xFFFFFFFF) # sizes are in zip64 extra
1125 self.assertEqual(usize, 0xFFFFFFFF)
1126 self.assertEqual(fn_len, 8) # filename len
1127 self.assertEqual(ex_total_len, 20) # size of extra records
1128 self.assertEqual(ex_id, 1) # Zip64 extra record
1129 self.assertEqual(ex_len, 16) # 16 bytes of data
1130 self.assertEqual(ex_usize, 1) # uncompressed size
1131 self.assertEqual(ex_csize, 1) # compressed size
1132 self.assertEqual(cd_sig, b"PK\x01\x02") # ensure the central directory header is next
1136 self.assertEqual(len(zinfos), 1)
1137 self.assertGreaterEqual(zinfos[0].extract_version, zipfile.ZIP64_VERSION) # requires zip64 to extract
1139 def test_unseekable_zip_unknown_filesize(self):
1147 self.assertRaises(RuntimeError, make_zip, io.BytesIO())
1148 self.assertRaises(RuntimeError, make_zip, Unseekable(io.BytesIO()))
1150 def test_zip64_required_not_allowed_fail(self):
1159 self.assertRaises(zipfile.LargeZipFile, make_zip, io.BytesIO())
1160 self.assertRaises(zipfile.LargeZipFile, make_zip, Unseekable(io.BytesIO()))
1162 def test_unseekable_zip_known_filesize(self):
1197 self.assertEqual(header, b"PK\x03\x04") # local file header
1198 self.assertGreaterEqual(vers, zipfile.ZIP64_VERSION) # requires zip64 to extract
1199 self.assertEqual(os, 0) # compatible with MS-DOS
1200 self.assertEqual(flags, 0) # no flags set
1201 self.assertEqual(comp, 0) # compression method = stored
1202 self.assertEqual(csize, 0xFFFFFFFF) # sizes are in zip64 extra
1203 self.assertEqual(usize, 0xFFFFFFFF)
1204 self.assertEqual(fn_len, 8) # filename len
1205 self.assertEqual(ex_total_len, 20) # size of extra records
1206 self.assertEqual(ex_id, 1) # Zip64 extra record
1207 self.assertEqual(ex_len, 16) # 16 bytes of data
1208 self.assertEqual(ex_usize, file_size) # uncompressed size
1209 self.assertEqual(ex_csize, file_size) # compressed size
1210 self.assertEqual(cd_sig, b"PK\x01\x02") # ensure the central directory header is next
1220 self.assertEqual(header, b"PK\x03\x04") # local file header
1221 self.assertGreaterEqual(vers, zipfile.ZIP64_VERSION) # requires zip64 to extract
1222 self.assertEqual(os, 0) # compatible with MS-DOS
1223 self.assertEqual("{:b}".format(flags), "1000") # streaming flag set
1224 self.assertEqual(comp, 0) # compression method = stored
1225 self.assertEqual(csize, 0xFFFFFFFF) # sizes are in zip64 extra
1226 self.assertEqual(usize, 0xFFFFFFFF)
1227 self.assertEqual(fn_len, 8) # filename len
1228 self.assertEqual(ex_total_len, 20) # size of extra records
1229 self.assertEqual(ex_id, 1) # Zip64 extra record
1230 self.assertEqual(ex_len, 16) # 16 bytes of data
1231 self.assertEqual(ex_usize, 0) # uncompressed size - 0 to defer to data descriptor
1232 self.assertEqual(ex_csize, 0) # compressed size - 0 to defer to data descriptor
1233 self.assertEqual(dd_header, b"PK\07\x08") # data descriptor
1234 self.assertEqual(dd_usize, file_size) # file size (8 bytes because zip64)
1235 self.assertEqual(dd_csize, file_size) # compressed size (8 bytes because zip64)
1236 self.assertEqual(cd_sig, b"PK\x01\x02") # ensure the central directory header is next
1257 def tearDown(self):
1260 def test_close_after_close(self):
1262 with zipfile.ZipFile(TESTFN2, "w", self.compression) as zipf:
1266 self.assertTrue(w.closed)
1268 self.assertTrue(w.closed)
1269 self.assertEqual(zipf.read('test'), data)
1271 def test_write_after_close(self):
1273 with zipfile.ZipFile(TESTFN2, "w", self.compression) as zipf:
1277 self.assertTrue(w.closed)
1278 self.assertRaises(ValueError, w.write, b'')
1279 self.assertEqual(zipf.read('test'), data)
1281 def test_issue44439(self):
1284 with zipfile.ZipFile(io.BytesIO(), 'w', self.compression) as zip:
1286 self.assertEqual(data.write(q), LENGTH)
1287 self.assertEqual(zip.getinfo('data').file_size, LENGTH)
1306 def assertCompiledIn(self, name, namelist):
1308 self.assertIn(name + 'c', namelist)
1310 def requiresWriteAccess(self, path):
1314 self.skipTest('requires write access to the installed location')
1320 self.skipTest('requires write access to the installed location')
1323 def test_write_pyfile(self):
1324 self.requiresWriteAccess(os.path.dirname(__file__))
1339 self.assertNotIn(bn, zipfp.namelist())
1340 self.assertCompiledIn(bn, zipfp.namelist())
1350 self.assertNotIn(bn, zipfp.namelist())
1351 self.assertCompiledIn(bn, zipfp.namelist())
1353 def test_write_python_package(self):
1356 self.requiresWriteAccess(packagedir)
1364 self.assertCompiledIn('email/__init__.py', names)
1365 self.assertCompiledIn('email/mime/text.py', names)
1367 def test_write_filtered_python_package(self):
1370 self.requiresWriteAccess(packagedir)
1379 self.assertTrue('SyntaxError' in reportStr)
1385 self.assertTrue('SyntaxError' not in reportStr)
1390 with captured_stdout() as reportSIO, self.assertWarns(UserWarning):
1395 self.assertTrue('SyntaxError' not in reportStr)
1397 def test_write_with_optimization(self):
1400 self.requiresWriteAccess(packagedir)
1409 self.assertIn('email/__init__' + ext, names)
1410 self.assertIn('email/mime/text' + ext, names)
1412 def test_write_python_directory(self):
1428 self.assertCompiledIn('mod1.py', names)
1429 self.assertCompiledIn('mod2.py', names)
1430 self.assertNotIn('mod2.txt', names)
1435 def test_write_python_directory_filtered(self):
1449 self.assertCompiledIn('mod1.py', names)
1450 self.assertNotIn('mod2.py', names)
1455 def test_write_non_pyfile(self):
1459 self.assertRaises(RuntimeError, zipfp.writepy, TESTFN)
1462 def test_write_pyfile_bad_syntax(self):
1473 self.assertIn("SyntaxError", s.getvalue())
1478 self.assertIn('mod1.py', names)
1479 self.assertNotIn('mod1.pyc', names)
1484 def test_write_pathlike(self):
1493 self.assertCompiledIn('mod1.py', names)
1500 def make_test_file(self):
1505 def test_extract(self):
1507 self.make_test_file()
1516 self.assertEqual(writtenfile, correctfile)
1520 self.assertEqual(fdata.encode(), f.read())
1524 def _test_extract_with_target(self, target):
1525 self.make_test_file()
1533 self.assertTrue(os.path.samefile(writtenfile, correctfile), (writtenfile, target))
1537 self.assertEqual(fdata.encode(), f.read())
1543 def test_extract_with_target(self):
1545 self._test_extract_with_target(extdir)
1547 def test_extract_with_target_pathlike(self):
1549 self._test_extract_with_target(pathlib.Path(extdir))
1551 def test_extract_all(self):
1553 self.make_test_file()
1560 self.assertEqual(fdata.encode(), f.read())
1564 def _test_extract_all_with_target(self, target):
1565 self.make_test_file()
1572 self.assertEqual(fdata.encode(), f.read())
1578 def test_extract_all_with_target(self):
1580 self._test_extract_all_with_target(extdir)
1582 def test_extract_all_with_target_pathlike(self):
1584 self._test_extract_all_with_target(pathlib.Path(extdir))
1586 def check_file(self, filename, content):
1587 self.assertTrue(os.path.isfile(filename))
1589 self.assertEqual(f.read(), content)
1591 def test_sanitize_windows_name(self):
1594 self.assertEqual(san(r',,?,C:,foo,bar/z', ','), r'_,C_,foo,bar/z')
1595 self.assertEqual(san(r'a\b,c<d>e|f"g?h*i', ','), r'a\b,c_d_e_f_g_h_i')
1596 self.assertEqual(san('../../foo../../ba..r', '/'), r'foo/ba..r')
1598 def test_extract_hackers_arcnames_common_cases(self):
1609 self._test_extract_hackers_arcnames(common_hacknames)
1612 def test_extract_hackers_arcnames_windows_only(self):
1635 self._test_extract_hackers_arcnames(windows_hacknames)
1638 def test_extract_hackers_arcnames_posix_only(self):
1644 self._test_extract_hackers_arcnames(posix_hacknames)
1646 def _test_extract_hackers_arcnames(self, hacknames):
1662 self.assertEqual(writtenfile, correctfile,
1665 self.check_file(correctfile, content)
1670 self.check_file(correctfile, content)
1677 self.assertEqual(writtenfile, correctfile,
1679 self.check_file(correctfile, content)
1684 self.check_file(correctfile, content)
1691 def test_open_via_zip_info(self):
1695 with self.assertWarns(UserWarning):
1697 self.assertEqual(zipfp.namelist(), ["name"] * 2)
1705 self.assertIn(data, {b"foobar", b"barfoo"})
1709 self.assertIn(data, {b"foobar", b"barfoo"})
1711 def test_writestr_extended_local_header_issue1202(self):
1718 def test_close(self):
1723 self.assertIsNotNone(zipfp.fp, 'zipfp is not open')
1724 self.assertIsNone(zipfp.fp, 'zipfp is not closed')
1727 self.assertIsNotNone(zipfp.fp, 'zipfp is not open')
1728 self.assertIsNone(zipfp.fp, 'zipfp is not closed')
1730 def test_close_on_exception(self):
1741 self.assertIsNone(zipfp2.fp, 'zipfp is not closed')
1743 def test_unsupported_version(self):
1751 self.assertRaises(NotImplementedError, zipfile.ZipFile,
1755 def test_read_unicode_filenames(self):
1762 def test_write_unicode_filenames(self):
1766 self.assertIsInstance(zf.infolist()[0].filename, str)
1769 self.assertEqual(zf.filelist[0].filename, "foo.txt")
1770 self.assertEqual(zf.filelist[1].filename, "\xf6.txt")
1772 def test_read_after_write_unicode_filenames(self):
1775 self.assertEqual(zipfp.read('приклад'), b'sample')
1777 def test_exclusive_create_zip_file(self):
1784 with self.assertRaises(FileExistsError):
1787 self.assertEqual(zipfp.namelist(), [filename])
1788 self.assertEqual(zipfp.read(filename), content)
1790 def test_create_non_existent_file_for_append(self):
1801 self.fail('Could not append data to a non-existent zip file.')
1803 self.assertTrue(os.path.exists(TESTFN))
1806 self.assertEqual(zf.read(filename), content)
1808 def test_close_erroneous_file(self):
1823 def test_is_zip_erroneous_file(self):
1828 self.assertFalse(zipfile.is_zipfile(TESTFN))
1830 self.assertFalse(zipfile.is_zipfile(pathlib.Path(TESTFN)))
1833 self.assertFalse(zipfile.is_zipfile(fp))
1837 self.assertFalse(zipfile.is_zipfile(fp))
1839 self.assertFalse(zipfile.is_zipfile(fp))
1841 def test_damaged_zipfile(self):
1853 self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, fp)
1855 def test_is_zip_valid_file(self):
1861 self.assertTrue(zipfile.is_zipfile(TESTFN))
1864 self.assertTrue(zipfile.is_zipfile(fp))
1870 self.assertTrue(zipfile.is_zipfile(fp))
1872 self.assertTrue(zipfile.is_zipfile(fp))
1874 def test_non_existent_file_raises_OSError(self):
1886 self.assertRaises(OSError, zipfile.ZipFile, TESTFN)
1888 def test_empty_file_raises_BadZipFile(self):
1891 self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, TESTFN)
1895 self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, TESTFN)
1897 def test_negative_central_directory_offset_raises_BadZipFile(self):
1906 self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, f)
1908 def test_closed_zip_raises_ValueError(self):
1918 self.assertRaises(ValueError, zipf.read, "foo.txt")
1919 self.assertRaises(ValueError, zipf.open, "foo.txt")
1920 self.assertRaises(ValueError, zipf.testzip)
1921 self.assertRaises(ValueError, zipf.writestr, "bogus.txt", "bogus")
1924 self.assertRaises(ValueError, zipf.write, TESTFN)
1926 def test_bad_constructor_mode(self):
1928 self.assertRaises(ValueError, zipfile.ZipFile, TESTFN, "q")
1930 def test_bad_open_mode(self):
1938 self.assertRaises(ValueError, zipf.open, "foo.txt", "q")
1940 self.assertRaises(ValueError, zipf.open, "foo.txt", "U")
1941 self.assertRaises(ValueError, zipf.open, "foo.txt", "rU")
1943 def test_read0(self):
1951 self.assertEqual(f.read(0), b'')
1953 self.assertEqual(f.read(), b"O, for a Muse of Fire!")
1955 def test_open_non_existent_item(self):
1959 self.assertRaises(KeyError, zipf.open, "foo.txt", "r")
1961 def test_bad_compression_mode(self):
1964 self.assertRaises(NotImplementedError, zipfile.ZipFile, TESTFN, "w", -1)
1966 def test_unsupported_compression(self):
1975 self.assertRaises(NotImplementedError, zipf.open, 'x')
1977 def test_null_byte_in_filename(self):
1982 self.assertEqual(zipf.namelist(), ['foo.txt'])
1984 def test_struct_sizes(self):
1986 self.assertEqual(zipfile.sizeEndCentDir, 22)
1987 self.assertEqual(zipfile.sizeCentralDir, 46)
1988 self.assertEqual(zipfile.sizeEndCentDir64, 56)
1989 self.assertEqual(zipfile.sizeEndCentDir64Locator, 20)
1991 def test_comments(self):
1996 self.assertEqual(zipf.comment, b'')
2000 self.assertEqual(zipfr.comment, b'')
2008 self.assertEqual(zipf.comment, comment)
2018 self.assertEqual(zipfr.comment, comment2)
2022 with self.assertWarns(UserWarning):
2026 self.assertEqual(zipfr.comment, comment2)
2035 self.assertEqual(zipf.comment, b"an updated comment")
2045 self.assertTrue(original_zip_size > os.path.getsize(TESTFN))
2047 self.assertEqual(zipf.comment, b"shorter comment")
2049 def test_unicode_comment(self):
2052 with self.assertRaises(TypeError):
2055 def test_change_comment_in_empty_archive(self):
2057 self.assertFalse(zipf.filelist)
2060 self.assertEqual(zipf.comment, b"this is a comment")
2062 def test_change_comment_in_nonempty_archive(self):
2066 self.assertTrue(zipf.filelist)
2069 self.assertEqual(zipf.comment, b"this is a comment")
2071 def test_empty_zipfile(self):
2079 self.fail("Unable to create empty ZIP file in 'w' mode")
2086 self.fail("Unable to create empty ZIP file in 'a' mode")
2088 def test_open_empty_file(self):
2094 self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, TESTFN, 'r')
2096 def test_create_zipinfo_before_1980(self):
2097 self.assertRaises(ValueError,
2100 def test_create_empty_zipinfo_repr(self):
2103 self.assertEqual(repr(zi), "<ZipInfo filename='empty' file_size=0>")
2105 def test_create_empty_zipinfo_default_attributes(self):
2108 self.assertEqual(zi.orig_filename, "NoName")
2109 self.assertEqual(zi.filename, "NoName")
2110 self.assertEqual(zi.date_time, (1980, 1, 1, 0, 0, 0))
2111 self.assertEqual(zi.compress_type, zipfile.ZIP_STORED)
2112 self.assertEqual(zi.comment, b"")
2113 self.assertEqual(zi.extra, b"")
2114 self.assertIn(zi.create_system, (0, 3))
2115 self.assertEqual(zi.create_version, zipfile.DEFAULT_VERSION)
2116 self.assertEqual(zi.extract_version, zipfile.DEFAULT_VERSION)
2117 self.assertEqual(zi.reserved, 0)
2118 self.assertEqual(zi.flag_bits, 0)
2119 self.assertEqual(zi.volume, 0)
2120 self.assertEqual(zi.internal_attr, 0)
2121 self.assertEqual(zi.external_attr, 0)
2124 self.assertEqual(zi.file_size, 0)
2125 self.assertEqual(zi.compress_size, 0)
2127 def test_zipfile_with_short_extra_field(self):
2140 self.assertIsNone(zipf.testzip())
2142 def test_open_conflicting_handles(self):
2151 with self.assertRaises(ValueError):
2153 with self.assertRaises(ValueError):
2155 with self.assertRaises(ValueError):
2157 with self.assertRaises(ValueError):
2159 with self.assertRaises(ValueError):
2166 self.assertEqual(zipf.read('foo'), msg1)
2167 self.assertEqual(zipf.read('bar'), msg2)
2168 self.assertEqual(zipf.read('baz'), msg3)
2169 self.assertEqual(zipf.namelist(), ['foo', 'bar', 'baz'])
2171 def test_seek_tell(self):
2181 self.assertEqual(fp.tell(), bloc)
2183 self.assertEqual(fp.tell(), 0)
2185 self.assertEqual(fp.tell(), bloc)
2186 self.assertEqual(fp.read(5), txt[bloc:bloc+5])
2188 self.assertEqual(fp.tell(), len(txt))
2190 self.assertEqual(fp.tell(), 0)
2198 self.assertEqual(fp.tell(), bloc)
2200 self.assertEqual(fp.tell(), 0)
2202 self.assertEqual(fp.tell(), bloc)
2203 self.assertEqual(fp.read(5), txt[bloc:bloc+5])
2205 self.assertEqual(fp.tell(), len(txt))
2207 self.assertEqual(fp.tell(), 0)
2210 def test_decompress_without_3rd_party_library(self):
2217 self.assertRaises(RuntimeError, zf.extract, 'a.txt')
2220 def test_full_overlap(self):
2235 self.assertEqual(zipf.namelist(), ['a', 'b'])
2237 self.assertEqual(zi.header_offset, 0)
2238 self.assertEqual(zi.compress_size, 16)
2239 self.assertEqual(zi.file_size, 1033)
2241 self.assertEqual(zi.header_offset, 0)
2242 self.assertEqual(zi.compress_size, 16)
2243 self.assertEqual(zi.file_size, 1033)
2244 self.assertEqual(len(zipf.read('a')), 1033)
2245 with self.assertRaisesRegex(zipfile.BadZipFile, 'File name.*differ'):
2249 def test_quoted_overlap(self):
2266 self.assertEqual(zipf.namelist(), ['a', 'b'])
2268 self.assertEqual(zi.header_offset, 0)
2269 self.assertEqual(zi.compress_size, 52)
2270 self.assertEqual(zi.file_size, 1064)
2272 self.assertEqual(zi.header_offset, 36)
2273 self.assertEqual(zi.compress_size, 16)
2274 self.assertEqual(zi.file_size, 1033)
2275 with self.assertRaisesRegex(zipfile.BadZipFile, 'Overlapped entries'):
2277 self.assertEqual(len(zipf.read('b')), 1033)
2279 def tearDown(self):
2285 def test_testzip_with_bad_crc(self):
2287 zipdata = self.zip_with_bad_crc
2291 self.assertEqual('afile', zipf.testzip())
2293 def test_read_with_bad_crc(self):
2295 zipdata = self.zip_with_bad_crc
2299 self.assertRaises(zipfile.BadZipFile, zipf.read, 'afile')
2304 self.assertRaises(zipfile.BadZipFile, corrupt_file.read)
2310 with self.assertRaises(zipfile.BadZipFile):
2397 def setUp(self):
2399 fp.write(self.data)
2400 self.zip = zipfile.ZipFile(TESTFN, "r")
2402 fp.write(self.data2)
2403 self.zip2 = zipfile.ZipFile(TESTFN2, "r")
2405 def tearDown(self):
2406 self.zip.close()
2408 self.zip2.close()
2411 def test_no_password(self):
2414 self.assertRaises(RuntimeError, self.zip.read, "test.txt")
2415 self.assertRaises(RuntimeError, self.zip2.read, "zero")
2417 def test_bad_password(self):
2418 self.zip.setpassword(b"perl")
2419 self.assertRaises(RuntimeError, self.zip.read, "test.txt")
2420 self.zip2.setpassword(b"perl")
2421 self.assertRaises(RuntimeError, self.zip2.read, "zero")
2424 def test_good_password(self):
2425 self.zip.setpassword(b"python")
2426 self.assertEqual(self.zip.read("test.txt"), self.plain)
2427 self.zip2.setpassword(b"12345")
2428 self.assertEqual(self.zip2.read("zero"), self.plain2)
2430 def test_unicode_password(self):
2433 with self.assertRaisesRegex(TypeError, expected_msg):
2434 self.zip.setpassword("unicode")
2436 with self.assertRaisesRegex(TypeError, expected_msg):
2437 self.zip.read("test.txt", "python")
2439 with self.assertRaisesRegex(TypeError, expected_msg):
2440 self.zip.open("test.txt", pwd="python")
2442 with self.assertRaisesRegex(TypeError, expected_msg):
2443 self.zip.extract("test.txt", pwd="python")
2445 with self.assertRaisesRegex(TypeError, expected_msg):
2446 self.zip.pwd = "python"
2447 self.zip.open("test.txt")
2449 def test_seek_tell(self):
2450 self.zip.setpassword(b"python")
2451 txt = self.plain
2455 with self.zip.open("test.txt", "r") as fp:
2457 self.assertEqual(fp.tell(), bloc)
2459 self.assertEqual(fp.tell(), 0)
2461 self.assertEqual(fp.tell(), bloc)
2462 self.assertEqual(fp.read(bloc_len), txt[bloc:bloc+bloc_len])
2472 self.assertEqual(fp.tell(), 0)
2474 self.assertEqual(fp.read(bloc_len), txt[bloc:bloc+bloc_len])
2478 self.assertEqual(fp.tell(), len(txt))
2480 self.assertEqual(fp.tell(), 0)
2494 def setUp(self):
2497 fp.write(self.data)
2499 def tearDown(self):
2503 def make_test_archive(self, f, compression):
2509 def zip_test(self, f, compression):
2510 self.make_test_archive(f, compression)
2515 self.assertEqual(len(testdata), len(self.data))
2516 self.assertEqual(testdata, self.data)
2517 self.assertEqual(zipfp.read("another.name"), self.data)
2519 def test_read(self):
2520 for f in get_files(self):
2521 self.zip_test(f, self.compression)
2523 def zip_open_test(self, f, compression):
2524 self.make_test_archive(f, compression)
2545 self.assertEqual(len(testdata1), len(self.data))
2546 self.assertEqual(testdata1, self.data)
2549 self.assertEqual(len(testdata2), len(self.data))
2550 self.assertEqual(testdata2, self.data)
2552 def test_open(self):
2553 for f in get_files(self):
2554 self.zip_open_test(f, self.compression)
2556 def zip_random_open_test(self, f, compression):
2557 self.make_test_archive(f, compression)
2570 self.assertEqual(len(testdata), len(self.data))
2571 self.assertEqual(testdata, self.data)
2573 def test_random_open(self):
2574 for f in get_files(self):
2575 self.zip_random_open_test(f, self.compression)
2600 def __init__(self, fp):
2601 self.fp = fp
2602 self.offset = 0
2604 def write(self, data):
2605 n = self.fp.write(data)
2606 self.offset += n
2609 def tell(self):
2610 return self.offset
2612 def flush(self):
2613 self.fp.flush()
2616 def __init__(self, fp):
2617 self.fp = fp
2619 def write(self, data):
2620 return self.fp.write(data)
2622 def flush(self):
2623 self.fp.flush()
2626 def test_writestr(self):
2628 with self.subTest(wrapper=wrapper):
2635 self.assertEqual(f.getvalue()[:5], b'abcPK')
2638 self.assertEqual(zopen.read(), b'111')
2640 self.assertEqual(zopen.read(), b'222')
2642 def test_write(self):
2644 with self.subTest(wrapper=wrapper):
2649 self.addCleanup(unlink, TESTFN)
2656 self.assertEqual(f.getvalue()[:5], b'abcPK')
2659 self.assertEqual(zopen.read(), b'111')
2661 self.assertEqual(zopen.read(), b'222')
2663 def test_open_write(self):
2665 with self.subTest(wrapper=wrapper):
2674 self.assertEqual(f.getvalue()[:5], b'abcPK')
2676 self.assertEqual(zipf.read('ones'), b'111')
2677 self.assertEqual(zipf.read('twos'), b'222')
2687 def make_test_archive(self, f):
2690 zipfp.writestr('ones', self.data1)
2691 zipfp.writestr('twos', self.data2)
2693 def test_same_file(self):
2696 for f in get_files(self):
2697 self.make_test_archive(f)
2704 self.assertEqual(data1, data2)
2705 self.assertEqual(data1, self.data1)
2707 def test_different_file(self):
2710 for f in get_files(self):
2711 self.make_test_archive(f)
2718 self.assertEqual(data1, self.data1)
2719 self.assertEqual(data2, self.data2)
2721 def test_interleaved(self):
2724 for f in get_files(self):
2725 self.make_test_archive(f)
2733 self.assertEqual(data1, self.data1)
2734 self.assertEqual(data2, self.data2)
2736 def test_read_after_close(self):
2737 for f in get_files(self):
2738 self.make_test_archive(f)
2747 self.assertEqual(data1, self.data1)
2748 self.assertEqual(data2, self.data2)
2750 def test_read_after_write(self):
2751 for f in get_files(self):
2753 zipf.writestr('ones', self.data1)
2754 zipf.writestr('twos', self.data2)
2757 self.assertEqual(data1, self.data1[:500])
2761 self.assertEqual(data1, self.data1)
2762 self.assertEqual(data2, self.data2)
2764 def test_write_after_read(self):
2765 for f in get_files(self):
2767 zipf.writestr('ones', self.data1)
2770 zipf.writestr('twos', self.data2)
2774 self.assertEqual(data1, self.data1)
2775 self.assertEqual(data2, self.data2)
2777 def test_many_opens(self):
2781 self.make_test_archive(TESTFN2)
2787 self.assertEqual(startcount, fd_count())
2789 def test_write_while_reading(self):
2791 zipf.writestr('ones', self.data1)
2796 w1.write(self.data2)
2798 self.assertEqual(data1, self.data1)
2800 self.assertEqual(zipf.read('twos'), self.data2)
2802 def tearDown(self):
2807 def setUp(self):
2810 def test_extract_dir(self):
2813 self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "a")))
2814 self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "a", "b")))
2815 self.assertTrue(os.path.exists(os.path.join(TESTFN2, "a", "b", "c")))
2817 def test_bug_6050(self):
2820 self.test_extract_dir()
2822 def test_write_dir(self):
2829 self.assertTrue(zinfo.filename.endswith("/x/"))
2830 self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
2833 self.assertTrue(zinfo.filename, "y/")
2834 self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
2837 self.assertTrue(zinfo.filename.endswith("/x/"))
2838 self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
2840 self.assertTrue(zinfo.filename, "y/")
2841 self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
2845 self.assertTrue(os.path.isdir(os.path.join(target, "y")))
2846 self.assertEqual(len(os.listdir(target)), 2)
2848 def test_writestr_dir(self):
2853 self.assertEqual(zinfo.filename, "x/")
2854 self.assertEqual(zinfo.external_attr, (0o40775 << 16) | 0x10)
2857 self.assertTrue(zinfo.filename.endswith("x/"))
2858 self.assertEqual(zinfo.external_attr, (0o40775 << 16) | 0x10)
2862 self.assertTrue(os.path.isdir(os.path.join(target, "x")))
2863 self.assertEqual(os.listdir(target), ["x"])
2865 def test_mkdir(self):
2869 self.assertEqual(zinfo.filename, "directory/")
2870 self.assertEqual(zinfo.external_attr, (0o40777 << 16) | 0x10)
2874 self.assertEqual(zinfo.filename, "directory2/")
2875 self.assertEqual(zinfo.external_attr, (0o40777 << 16) | 0x10)
2879 self.assertEqual(zinfo.filename, "directory3/")
2880 self.assertEqual(zinfo.external_attr, (0o40777 << 16) | 0x10)
2889 self.assertEqual(old_zinfo.filename, "directory4/")
2890 self.assertEqual(old_zinfo.external_attr, new_zinfo.external_attr)
2895 self.assertEqual(set(os.listdir(target)), {"directory", "directory2", "directory3", "directory4"})
2897 def test_create_directory_with_write(self):
2902 self.assertEqual(zinfo.filename, "directory/")
2909 self.assertEqual(zinfo.filename, "directory2/")
2910 self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
2916 self.assertEqual(set(os.listdir(target)), {"directory", "directory2"})
2918 def tearDown(self):
2925 def test_from_file(self):
2927 self.assertEqual(posixpath.basename(zi.filename), 'test_zipfile.py')
2928 self.assertFalse(zi.is_dir())
2929 self.assertEqual(zi.file_size, os.path.getsize(__file__))
2931 def test_from_file_pathlike(self):
2933 self.assertEqual(posixpath.basename(zi.filename), 'test_zipfile.py')
2934 self.assertFalse(zi.is_dir())
2935 self.assertEqual(zi.file_size, os.path.getsize(__file__))
2937 def test_from_file_bytes(self):
2939 self.assertEqual(posixpath.basename(zi.filename), 'test')
2940 self.assertFalse(zi.is_dir())
2941 self.assertEqual(zi.file_size, os.path.getsize(__file__))
2943 def test_from_file_fileno(self):
2946 self.assertEqual(posixpath.basename(zi.filename), 'test')
2947 self.assertFalse(zi.is_dir())
2948 self.assertEqual(zi.file_size, os.path.getsize(__file__))
2950 def test_from_dir(self):
2953 self.assertEqual(zi.filename, 'stdlib_tests/')
2954 self.assertTrue(zi.is_dir())
2955 self.assertEqual(zi.compress_type, zipfile.ZIP_STORED)
2956 self.assertEqual(zi.file_size, 0)
2961 def zipfilecmd(self, *args, **kwargs):
2966 def zipfilecmd_failure(self, *args):
2969 def test_bad_use(self):
2970 rc, out, err = self.zipfilecmd_failure()
2971 self.assertEqual(out, b'')
2972 self.assertIn(b'usage', err.lower())
2973 self.assertIn(b'error', err.lower())
2974 self.assertIn(b'required', err.lower())
2975 rc, out, err = self.zipfilecmd_failure('-l', '')
2976 self.assertEqual(out, b'')
2977 self.assertNotEqual(err.strip(), b'')
2979 def test_test_command(self):
2982 out = self.zipfilecmd(opt, zip_name)
2983 self.assertEqual(out.rstrip(), b'Done testing')
2985 rc, out, err = self.zipfilecmd_failure('-t', zip_name)
2986 self.assertEqual(out, b'')
2988 def test_list_command(self):
2995 out = self.zipfilecmd(opt, zip_name,
2997 self.assertEqual(out, expected)
3000 def test_create_command(self):
3001 self.addCleanup(unlink, TESTFN)
3005 self.addCleanup(rmtree, TESTFNDIR)
3012 out = self.zipfilecmd(opt, TESTFN2, *files)
3013 self.assertEqual(out, b'')
3015 self.assertEqual(zf.namelist(), namelist)
3016 self.assertEqual(zf.read(namelist[0]), b'test 1')
3017 self.assertEqual(zf.read(namelist[2]), b'test 2')
3021 def test_extract_command(self):
3025 out = self.zipfilecmd(opt, zip_name, extdir)
3026 self.assertEqual(out, b'')
3032 self.assertTrue(os.path.isdir(path))
3034 self.assertTrue(os.path.isfile(path))
3036 self.assertEqual(f.read(), zf.read(zi))
3042 def setUp(self):
3043 self.exe_zip = findfile('exe_with_zip', subdir='ziptestdata')
3044 self.exe_zip64 = findfile('exe_with_z64', subdir='ziptestdata')
3046 def _test_zip_works(self, name):
3048 self.assertTrue(zipfile.is_zipfile(name),
3054 self.assertIn(b'FAVORITE_NUMBER', data)
3056 def test_read_zip_with_exe_prepended(self):
3057 self._test_zip_works(self.exe_zip)
3059 def test_read_zip64_with_exe_prepended(self):
3060 self._test_zip_works(self.exe_zip64)
3066 def test_execute_zip2(self):
3067 output = subprocess.check_output([self.exe_zip, sys.executable])
3068 self.assertIn(b'number in executable: 5', output)
3074 def test_execute_zip64(self):
3075 output = subprocess.check_output([self.exe_zip64, sys.executable])
3076 self.assertIn(b'number in executable: 5', output)
3087 def __init__(self, i):
3088 self.count = 0
3089 self._orig_iter = iter(i)
3091 def __iter__(self):
3092 return self
3094 def __next__(self):
3095 result = next(self._orig_iter)
3096 self.count += 1
3153 def wrapper(self):
3154 for alpharep in self.zipfile_alpharep():
3155 meth(self, alpharep=alpharep)
3161 def setUp(self):
3162 self.fixtures = contextlib.ExitStack()
3163 self.addCleanup(self.fixtures.close)
3165 def zipfile_alpharep(self):
3166 with self.subTest():
3168 with self.subTest():
3171 def zipfile_ondisk(self, alpharep):
3172 tmpdir = pathlib.Path(self.fixtures.enter_context(temp_dir()))
3181 def test_iterdir_and_types(self, alpharep):
3197 def test_is_file_missing(self, alpharep):
3202 def test_iterdir_on_file(self, alpharep):
3205 with self.assertRaises(ValueError):
3209 def test_subdir_is_dir(self, alpharep):
3217 def test_open(self, alpharep):
3222 self.assertEqual(data, "content of a")
3225 self.assertEqual(data, "content of a")
3227 def test_open_encoding_utf16(self):
3237 self.assertEqual(data, "This was utf-16")
3240 self.assertEqual(data, "This was utf-16")
3242 def test_open_encoding_errors(self):
3253 self.assertEqual(data, "invalid utf-8: .")
3255 self.assertEqual(f.read(), "invalid utf-8: \udcff\udcff.")
3258 with self.assertRaisesRegex(TypeError, "encoding"):
3264 with self.assertRaises(UnicodeDecodeError):
3267 def test_encoding_warnings(self):
3282 self.assertEqual(len(warnings), 2, proc.err)
3283 self.assertRegex(warnings[0], rb"^<string>:8: EncodingWarning:")
3284 self.assertRegex(warnings[1], rb"^<string>:9: EncodingWarning:")
3286 def test_open_write(self):
3297 def test_open_extant_directory(self):
3302 with self.assertRaises(IsADirectoryError):
3306 def test_open_binary_invalid_args(self, alpharep):
3308 with self.assertRaises(ValueError):
3310 with self.assertRaises(ValueError):
3313 def test_open_missing_directory(self):
3318 with self.assertRaises(FileNotFoundError):
3322 def test_read(self, alpharep):
3330 def test_joinpath(self, alpharep):
3338 def test_joinpath_multiple(self, alpharep):
3344 def test_traverse_truediv(self, alpharep):
3352 def test_traverse_simplediv(self, alpharep):
3365 def test_pathlike_construction(self, alpharep):
3369 zipfile_ondisk = self.zipfile_ondisk(alpharep)
3374 def test_traverse_pathlike(self, alpharep):
3379 def test_parent(self, alpharep):
3385 def test_dir_parent(self, alpharep):
3391 def test_missing_dir_parent(self, alpharep):
3396 def test_mutability(self, alpharep):
3412 def huge_zipfile(self):
3416 for entry in map(str, range(self.HUGE_ZIPFILE_NUM_ENTRIES)):
3421 def test_joinpath_constant_time(self):
3425 root = zipfile.Path(self.huge_zipfile())
3430 assert entries.count == self.HUGE_ZIPFILE_NUM_ENTRIES
3433 def test_implied_dirs_performance(self):
3438 def test_read_does_not_close(self, alpharep):
3439 alpharep = self.zipfile_ondisk(alpharep)
3445 def test_subclass(self, alpharep):
3453 def test_filename(self, alpharep):
3458 def test_root_name(self, alpharep):
3466 def test_suffix(self, alpharep):
3485 def test_suffixes(self, alpharep):
3507 def test_stem(self, alpharep):
3524 def test_root_parent(self, alpharep):
3531 def test_root_unnamed(self, alpharep):
3538 with self.assertRaises(TypeError):
3540 with self.assertRaises(TypeError):
3549 def test_inheritance(self, alpharep):
3551 for alpharep in self.zipfile_alpharep():
3556 def test_extract_orig_with_implied_dirs(self, alpharep):
3560 source_path = self.zipfile_ondisk(alpharep)
3566 def test_malformed_paths(self):
3594 def setUp(self):
3595 self.addCleanup(unlink, TESTFN)
3601 placeholders = ["n1", "n2"] + self.file_names[2:]
3603 for temp, content in zip(placeholders, self.file_content):
3608 for name, temp in zip(self.file_names, placeholders[:2]):
3614 def _test_read(self, zipfp, expected_names, expected_content):
3617 self.assertEqual(sorted(names), sorted(expected_names))
3622 self.assertEqual(sorted(names), sorted(expected_names))
3627 self.assertEqual(info.filename, name)
3628 self.assertEqual(info.file_size, len(content))
3629 self.assertEqual(zipfp.read(name), content)
3631 def test_read_with_metadata_encoding(self):
3634 self._test_read(zipfp, self.file_names, self.file_content)
3636 def test_read_without_metadata_encoding(self):
3639 for name in self.file_names[:2]] + self.file_names[2:]
3641 self._test_read(zipfp, expected_names, self.file_content)
3643 def test_read_with_incorrect_metadata_encoding(self):
3646 for name in self.file_names[:2]] + self.file_names[2:]
3648 self._test_read(zipfp, expected_names, self.file_content)
3650 def test_read_with_unsuitable_metadata_encoding(self):
3653 with self.assertRaises(UnicodeDecodeError):
3655 with self.assertRaises(UnicodeDecodeError):
3658 def test_read_after_append(self):
3661 for name in self.file_names[:2]] + self.file_names[2:]
3663 expected_content = (*self.file_content, b"newcontent")
3667 self.assertEqual(sorted(zipfp.namelist()), sorted(expected_names))
3670 self._test_read(zipfp, expected_names, expected_content)
3673 self.assertEqual(sorted(zipfp.namelist()), sorted(expected_names))
3676 self.assertEqual(info.filename, name)
3677 self.assertEqual(info.file_size, len(content))
3679 with self.assertRaises(zipfile.BadZipFile):
3682 self.assertEqual(zipfp.read(name), content)
3684 def test_write_with_metadata_encoding(self):
3687 with self.assertRaisesRegex(ValueError,
3691 def test_cli_with_metadata_encoding(self):
3696 self.assertRaises(SystemExit, zipfile.main, args)
3697 self.assertEqual(stdout.getvalue(), "")
3698 self.assertIn(errmsg, stderr.getvalue())
3707 for name in self.file_names:
3708 self.assertIn(name, listing)
3710 def test_cli_with_metadata_encoding_extract(self):
3712 self.addCleanup(rmtree, TESTFN2)
3715 for fn in self.file_names:
3721 self.skipTest(f'cannot encode file name {fn!r}')
3725 for name in self.file_names:
3726 self.assertIn(name, listing)
3736 def test_no_data(self):
3738 a = s.pack(self.ZIP64_EXTRA, 0)
3742 self.assertEqual(b'', zipfile._strip_extra(a, (self.ZIP64_EXTRA,)))
3743 self.assertEqual(b, zipfile._strip_extra(b, (self.ZIP64_EXTRA,)))
3744 self.assertEqual(
3745 b+b"z", zipfile._strip_extra(b+b"z", (self.ZIP64_EXTRA,)))
3747 self.assertEqual(b+c, zipfile._strip_extra(a+b+c, (self.ZIP64_EXTRA,)))
3748 self.assertEqual(b+c, zipfile._strip_extra(b+a+c, (self.ZIP64_EXTRA,)))
3749 self.assertEqual(b+c, zipfile._strip_extra(b+c+a, (self.ZIP64_EXTRA,)))
3751 def test_with_data(self):
3753 a = s.pack(self.ZIP64_EXTRA, 1) + b"a"
3757 self.assertEqual(b"", zipfile._strip_extra(a, (self.ZIP64_EXTRA,)))
3758 self.assertEqual(b, zipfile._strip_extra(b, (self.ZIP64_EXTRA,)))
3759 self.assertEqual(
3760 b+b"z", zipfile._strip_extra(b+b"z", (self.ZIP64_EXTRA,)))
3762 self.assertEqual(b+c, zipfile._strip_extra(a+b+c, (self.ZIP64_EXTRA,)))
3763 self.assertEqual(b+c, zipfile._strip_extra(b+a+c, (self.ZIP64_EXTRA,)))
3764 self.assertEqual(b+c, zipfile._strip_extra(b+c+a, (self.ZIP64_EXTRA,)))
3766 def test_multiples(self):
3768 a = s.pack(self.ZIP64_EXTRA, 1) + b"a"
3771 self.assertEqual(b"", zipfile._strip_extra(a+a, (self.ZIP64_EXTRA,)))
3772 self.assertEqual(b"", zipfile._strip_extra(a+a+a, (self.ZIP64_EXTRA,)))
3773 self.assertEqual(
3774 b"z", zipfile._strip_extra(a+a+b"z", (self.ZIP64_EXTRA,)))
3775 self.assertEqual(
3776 b+b"z", zipfile._strip_extra(a+a+b+b"z", (self.ZIP64_EXTRA,)))
3778 self.assertEqual(b, zipfile._strip_extra(a+a+b, (self.ZIP64_EXTRA,)))
3779 self.assertEqual(b, zipfile._strip_extra(a+b+a, (self.ZIP64_EXTRA,)))
3780 self.assertEqual(b, zipfile._strip_extra(b+a+a, (self.ZIP64_EXTRA,)))
3782 def test_too_short(self):
3783 self.assertEqual(b"", zipfile._strip_extra(b"", (self.ZIP64_EXTRA,)))
3784 self.assertEqual(b"z", zipfile._strip_extra(b"z", (self.ZIP64_EXTRA,)))
3785 self.assertEqual(
3786 b"zz", zipfile._strip_extra(b"zz", (self.ZIP64_EXTRA,)))
3787 self.assertEqual(
3788 b"zzz", zipfile._strip_extra(b"zzz", (self.ZIP64_EXTRA,)))