traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

bpo-40275: More lazy imports in test.support (GH-20131) 

Make the the following imports lazy in test.support:

* bz2
* gzip
* lzma
* resource
* zlib

The following test.support decorators now need to be called
with parenthesis:

* @support.requires_bz2
* @support.requires_gzip
* @support.requires_lzma
* @support.requires_zlib

For example, "@requires_zlib" becomes "@requires_zlib()".
This commit is contained in:
Hai Shi 2020-05-19 06:02:57 +08:00 committed by GitHub
parent ced4e5c227
commit a3ec3ad9e2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 81 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
Lib/test/support/__init__.py
View File

@ -28,31 +28,6 @@ import warnings
from .testresult import get_test_runner from .testresult import get_test_runner
try:
import zlib
except ImportError:
zlib = None
try:
import gzip
except ImportError:
gzip = None
try:
import bz2
except ImportError:
bz2 = None
try:
import lzma
except ImportError:
lzma = None
try:
import resource
except ImportError:
resource = None
__all__ = [ __all__ = [
# globals # globals
"PIPE_MAX_SIZE", "verbose", "max_memuse", "use_resources", "failfast", "PIPE_MAX_SIZE", "verbose", "max_memuse", "use_resources", "failfast",
@ -705,13 +680,33 @@ requires_IEEE_754 = unittest.skipUnless(
float.__getformat__("double").startswith("IEEE"), float.__getformat__("double").startswith("IEEE"),
"test requires IEEE 754 doubles") "test requires IEEE 754 doubles")
requires_zlib = unittest.skipUnless(zlib, 'requires zlib') def requires_zlib(reason='requires zlib'):
try:
import zlib
except ImportError:
zlib = None
return unittest.skipUnless(zlib, reason)
requires_gzip = unittest.skipUnless(gzip, 'requires gzip') def requires_gzip(reason='requires gzip'):
try:
import gzip
except ImportError:
gzip = None
return unittest.skipUnless(gzip, reason)
requires_bz2 = unittest.skipUnless(bz2, 'requires bz2') def requires_bz2(reason='requires bz2'):
try:
import bz2
except ImportError:
bz2 = None
return unittest.skipUnless(bz2, reason)
requires_lzma = unittest.skipUnless(lzma, 'requires lzma') def requires_lzma(reason='requires lzma'):
try:
import lzma
except ImportError:
lzma = None
return unittest.skipUnless(lzma, reason)
is_jython = sys.platform.startswith('java') is_jython = sys.platform.startswith('java')
@ -1062,6 +1057,10 @@ def check_syntax_warning(testcase, statement, errtext='', *, lineno=1, offset=No
def open_urlresource(url, *args, **kw): def open_urlresource(url, *args, **kw):
import urllib.request, urllib.parse import urllib.request, urllib.parse
try:
import gzip
except ImportError:
gzip = None
check = kw.pop('check', None) check = kw.pop('check', None)
@ -2579,10 +2578,15 @@ class SuppressCrashReport:
self.old_modes[report_type] = old_mode, old_file self.old_modes[report_type] = old_mode, old_file
else: else:
if resource is not None:
try: try:
self.old_value = resource.getrlimit(resource.RLIMIT_CORE) import resource
resource.setrlimit(resource.RLIMIT_CORE, self.resource = resource
except ImportError:
self.resource = None
if self.resource is not None:
try:
self.old_value = self.resource.getrlimit(self.resource.RLIMIT_CORE)
self.resource.setrlimit(self.resource.RLIMIT_CORE,
(0, self.old_value[1])) (0, self.old_value[1]))
except (ValueError, OSError): except (ValueError, OSError):
pass pass
@ -2621,9 +2625,9 @@ class SuppressCrashReport:
msvcrt.CrtSetReportMode(report_type, old_mode) msvcrt.CrtSetReportMode(report_type, old_mode)
msvcrt.CrtSetReportFile(report_type, old_file) msvcrt.CrtSetReportFile(report_type, old_file)
else: else:
if resource is not None: if self.resource is not None:
try: try:
resource.setrlimit(resource.RLIMIT_CORE, self.old_value) self.resource.setrlimit(self.resource.RLIMIT_CORE, self.old_value)
except (ValueError, OSError): except (ValueError, OSError):
pass pass

4
Lib/test/test_importlib/test_zip.py
View File

@ -10,7 +10,7 @@ from importlib.resources import path
from test.support import requires_zlib from test.support import requires_zlib
@requires_zlib @requires_zlib()
class TestZip(unittest.TestCase): class TestZip(unittest.TestCase):
root = 'test.test_importlib.data' root = 'test.test_importlib.data'
@ -50,7 +50,7 @@ class TestZip(unittest.TestCase):
assert '.whl/' in path, path assert '.whl/' in path, path
@requires_zlib @requires_zlib()
class TestEgg(TestZip): class TestEgg(TestZip):
def setUp(self): def setUp(self):
# Find the path to the example-*.egg so we can add it to the front of # Find the path to the example-*.egg so we can add it to the front of

2
Lib/test/test_logging.py
View File

@ -5076,7 +5076,7 @@ class RotatingFileHandlerTest(BaseFileTest):
self.assertFalse(os.path.exists(rh.namer(self.fn + ".1"))) self.assertFalse(os.path.exists(rh.namer(self.fn + ".1")))
rh.close() rh.close()
@support.requires_zlib @support.requires_zlib()
def test_rotator(self): def test_rotator(self):
def namer(name): def namer(name):
return name + ".gz" return name + ".gz"

24
Lib/test/test_shutil.py
View File

@ -1246,7 +1246,7 @@ class TestArchives(BaseTest, unittest.TestCase):
### shutil.make_archive ### shutil.make_archive
@support.requires_zlib @support.requires_zlib()
def test_make_tarball(self): def test_make_tarball(self):
# creating something to tar # creating something to tar
root_dir, base_dir = self._create_files('') root_dir, base_dir = self._create_files('')
@ -1302,7 +1302,7 @@ class TestArchives(BaseTest, unittest.TestCase):
write_file((root_dir, 'outer'), 'xxx') write_file((root_dir, 'outer'), 'xxx')
return root_dir, base_dir return root_dir, base_dir
@support.requires_zlib @support.requires_zlib()
@unittest.skipUnless(shutil.which('tar'), @unittest.skipUnless(shutil.which('tar'),
'Need the tar command to run') 'Need the tar command to run')
def test_tarfile_vs_tar(self): def test_tarfile_vs_tar(self):
@ -1335,7 +1335,7 @@ class TestArchives(BaseTest, unittest.TestCase):
self.assertEqual(tarball, base_name + '.tar') self.assertEqual(tarball, base_name + '.tar')
self.assertTrue(os.path.isfile(tarball)) self.assertTrue(os.path.isfile(tarball))
@support.requires_zlib @support.requires_zlib()
def test_make_zipfile(self): def test_make_zipfile(self):
# creating something to zip # creating something to zip
root_dir, base_dir = self._create_files() root_dir, base_dir = self._create_files()
@ -1372,7 +1372,7 @@ class TestArchives(BaseTest, unittest.TestCase):
['dist/', 'dist/sub/', 'dist/sub2/', ['dist/', 'dist/sub/', 'dist/sub2/',
'dist/file1', 'dist/file2', 'dist/sub/file3']) 'dist/file1', 'dist/file2', 'dist/sub/file3'])
@support.requires_zlib @support.requires_zlib()
@unittest.skipUnless(shutil.which('zip'), @unittest.skipUnless(shutil.which('zip'),
'Need the zip command to run') 'Need the zip command to run')
def test_zipfile_vs_zip(self): def test_zipfile_vs_zip(self):
@ -1398,7 +1398,7 @@ class TestArchives(BaseTest, unittest.TestCase):
names2 = zf.namelist() names2 = zf.namelist()
self.assertEqual(sorted(names), sorted(names2)) self.assertEqual(sorted(names), sorted(names2))
@support.requires_zlib @support.requires_zlib()
@unittest.skipUnless(shutil.which('unzip'), @unittest.skipUnless(shutil.which('unzip'),
'Need the unzip command to run') 'Need the unzip command to run')
def test_unzip_zipfile(self): def test_unzip_zipfile(self):
@ -1427,7 +1427,7 @@ class TestArchives(BaseTest, unittest.TestCase):
base_name = os.path.join(tmpdir, 'archive') base_name = os.path.join(tmpdir, 'archive')
self.assertRaises(ValueError, make_archive, base_name, 'xxx') self.assertRaises(ValueError, make_archive, base_name, 'xxx')
@support.requires_zlib @support.requires_zlib()
def test_make_archive_owner_group(self): def test_make_archive_owner_group(self):
# testing make_archive with owner and group, with various combinations # testing make_archive with owner and group, with various combinations
# this works even if there's not gid/uid support # this works even if there's not gid/uid support
@ -1455,7 +1455,7 @@ class TestArchives(BaseTest, unittest.TestCase):
self.assertTrue(os.path.isfile(res)) self.assertTrue(os.path.isfile(res))
@support.requires_zlib @support.requires_zlib()
@unittest.skipUnless(UID_GID_SUPPORT, "Requires grp and pwd support") @unittest.skipUnless(UID_GID_SUPPORT, "Requires grp and pwd support")
def test_tarfile_root_owner(self): def test_tarfile_root_owner(self):
root_dir, base_dir = self._create_files() root_dir, base_dir = self._create_files()
@ -1500,7 +1500,7 @@ class TestArchives(BaseTest, unittest.TestCase):
self.assertEqual(make_archive('test', 'tar'), 'test.tar') self.assertEqual(make_archive('test', 'tar'), 'test.tar')
self.assertTrue(os.path.isfile('test.tar')) self.assertTrue(os.path.isfile('test.tar'))
@support.requires_zlib @support.requires_zlib()
def test_make_zipfile_in_curdir(self): def test_make_zipfile_in_curdir(self):
# Issue #21280 # Issue #21280
root_dir = self.mkdtemp() root_dir = self.mkdtemp()
@ -1555,20 +1555,20 @@ class TestArchives(BaseTest, unittest.TestCase):
def test_unpack_archive_tar(self): def test_unpack_archive_tar(self):
self.check_unpack_archive('tar') self.check_unpack_archive('tar')
@support.requires_zlib @support.requires_zlib()
def test_unpack_archive_gztar(self): def test_unpack_archive_gztar(self):
self.check_unpack_archive('gztar') self.check_unpack_archive('gztar')
@support.requires_bz2 @support.requires_bz2()
def test_unpack_archive_bztar(self): def test_unpack_archive_bztar(self):
self.check_unpack_archive('bztar') self.check_unpack_archive('bztar')
@support.requires_lzma @support.requires_lzma()
@unittest.skipIf(AIX and not _maxdataOK(), "AIX MAXDATA must be 0x20000000 or larger") @unittest.skipIf(AIX and not _maxdataOK(), "AIX MAXDATA must be 0x20000000 or larger")
def test_unpack_archive_xztar(self): def test_unpack_archive_xztar(self):
self.check_unpack_archive('xztar') self.check_unpack_archive('xztar')
@support.requires_zlib @support.requires_zlib()
def test_unpack_archive_zip(self): def test_unpack_archive_zip(self):
self.check_unpack_archive('zip') self.check_unpack_archive('zip')

6
Lib/test/test_tarfile.py
View File

@ -57,21 +57,21 @@ class TarTest:
def mode(self): def mode(self):
return self.prefix + self.suffix return self.prefix + self.suffix
@support.requires_gzip @support.requires_gzip()
class GzipTest: class GzipTest:
tarname = gzipname tarname = gzipname
suffix = 'gz' suffix = 'gz'
open = gzip.GzipFile if gzip else None open = gzip.GzipFile if gzip else None
taropen = tarfile.TarFile.gzopen taropen = tarfile.TarFile.gzopen
@support.requires_bz2 @support.requires_bz2()
class Bz2Test: class Bz2Test:
tarname = bz2name tarname = bz2name
suffix = 'bz2' suffix = 'bz2'
open = bz2.BZ2File if bz2 else None open = bz2.BZ2File if bz2 else None
taropen = tarfile.TarFile.bz2open taropen = tarfile.TarFile.bz2open
@support.requires_lzma @support.requires_lzma()
class LzmaTest: class LzmaTest:
tarname = xzname tarname = xzname
suffix = 'xz' suffix = 'xz'

2
Lib/test/test_venv.py
View File

@ -530,7 +530,7 @@ class EnsurePipTest(BaseTest):
# Issue #26610: pip/pep425tags.py requires ctypes # Issue #26610: pip/pep425tags.py requires ctypes
@unittest.skipUnless(ctypes, 'pip requires ctypes') @unittest.skipUnless(ctypes, 'pip requires ctypes')
@requires_zlib @requires_zlib()
def test_with_pip(self): def test_with_pip(self):
self.do_test_with_pip(False) self.do_test_with_pip(False)
self.do_test_with_pip(True) self.do_test_with_pip(True)

2
Lib/test/test_zipapp.py
View File

@ -101,7 +101,7 @@ class ZipAppTest(unittest.TestCase):
expected_target = self.tmpdir / 'source.pyz' expected_target = self.tmpdir / 'source.pyz'
self.assertTrue(expected_target.is_file()) self.assertTrue(expected_target.is_file())
@requires_zlib @requires_zlib()
def test_create_archive_with_compression(self): def test_create_archive_with_compression(self):
# Test packing a directory into a compressed archive. # Test packing a directory into a compressed archive.
source = self.tmpdir / 'source' source = self.tmpdir / 'source'

40
Lib/test/test_zipfile.py
View File

@ -640,7 +640,7 @@ class StoredTestsWithSourceFile(AbstractTestsWithSourceFile,
self.assertEqual(zinfo.date_time, (2107, 12, 31, 23, 59, 59)) self.assertEqual(zinfo.date_time, (2107, 12, 31, 23, 59, 59))
@requires_zlib @requires_zlib()
class DeflateTestsWithSourceFile(AbstractTestsWithSourceFile, class DeflateTestsWithSourceFile(AbstractTestsWithSourceFile,
unittest.TestCase): unittest.TestCase):
compression = zipfile.ZIP_DEFLATED compression = zipfile.ZIP_DEFLATED
@ -656,12 +656,12 @@ class DeflateTestsWithSourceFile(AbstractTestsWithSourceFile,
self.assertEqual(sinfo.compress_type, zipfile.ZIP_STORED) self.assertEqual(sinfo.compress_type, zipfile.ZIP_STORED)
self.assertEqual(dinfo.compress_type, zipfile.ZIP_DEFLATED) self.assertEqual(dinfo.compress_type, zipfile.ZIP_DEFLATED)
@requires_bz2 @requires_bz2()
class Bzip2TestsWithSourceFile(AbstractTestsWithSourceFile, class Bzip2TestsWithSourceFile(AbstractTestsWithSourceFile,
unittest.TestCase): unittest.TestCase):
compression = zipfile.ZIP_BZIP2 compression = zipfile.ZIP_BZIP2
@requires_lzma @requires_lzma()
class LzmaTestsWithSourceFile(AbstractTestsWithSourceFile, class LzmaTestsWithSourceFile(AbstractTestsWithSourceFile,
unittest.TestCase): unittest.TestCase):
compression = zipfile.ZIP_LZMA compression = zipfile.ZIP_LZMA
@ -1075,17 +1075,17 @@ class StoredTestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
self.assertEqual(zf.read(zinfo), expected_content) self.assertEqual(zf.read(zinfo), expected_content)
@requires_zlib @requires_zlib()
class DeflateTestZip64InSmallFiles(AbstractTestZip64InSmallFiles, class DeflateTestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
unittest.TestCase): unittest.TestCase):
compression = zipfile.ZIP_DEFLATED compression = zipfile.ZIP_DEFLATED
@requires_bz2 @requires_bz2()
class Bzip2TestZip64InSmallFiles(AbstractTestZip64InSmallFiles, class Bzip2TestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
unittest.TestCase): unittest.TestCase):
compression = zipfile.ZIP_BZIP2 compression = zipfile.ZIP_BZIP2
@requires_lzma @requires_lzma()
class LzmaTestZip64InSmallFiles(AbstractTestZip64InSmallFiles, class LzmaTestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
unittest.TestCase): unittest.TestCase):
compression = zipfile.ZIP_LZMA compression = zipfile.ZIP_LZMA
@ -1120,15 +1120,15 @@ class AbstractWriterTests:
class StoredWriterTests(AbstractWriterTests, unittest.TestCase): class StoredWriterTests(AbstractWriterTests, unittest.TestCase):
compression = zipfile.ZIP_STORED compression = zipfile.ZIP_STORED
@requires_zlib @requires_zlib()
class DeflateWriterTests(AbstractWriterTests, unittest.TestCase): class DeflateWriterTests(AbstractWriterTests, unittest.TestCase):
compression = zipfile.ZIP_DEFLATED compression = zipfile.ZIP_DEFLATED
@requires_bz2 @requires_bz2()
class Bzip2WriterTests(AbstractWriterTests, unittest.TestCase): class Bzip2WriterTests(AbstractWriterTests, unittest.TestCase):
compression = zipfile.ZIP_BZIP2 compression = zipfile.ZIP_BZIP2
@requires_lzma @requires_lzma()
class LzmaWriterTests(AbstractWriterTests, unittest.TestCase): class LzmaWriterTests(AbstractWriterTests, unittest.TestCase):
compression = zipfile.ZIP_LZMA compression = zipfile.ZIP_LZMA
@ -1582,7 +1582,7 @@ class OtherTests(unittest.TestCase):
self.assertRaises(NotImplementedError, zipfile.ZipFile, self.assertRaises(NotImplementedError, zipfile.ZipFile,
io.BytesIO(data), 'r') io.BytesIO(data), 'r')
@requires_zlib @requires_zlib()
def test_read_unicode_filenames(self): def test_read_unicode_filenames(self):
# bug #10801 # bug #10801
fname = findfile('zip_cp437_header.zip') fname = findfile('zip_cp437_header.zip')
@ -2018,7 +2018,7 @@ class OtherTests(unittest.TestCase):
fp.seek(0, os.SEEK_SET) fp.seek(0, os.SEEK_SET)
self.assertEqual(fp.tell(), 0) self.assertEqual(fp.tell(), 0)
@requires_bz2 @requires_bz2()
def test_decompress_without_3rd_party_library(self): def test_decompress_without_3rd_party_library(self):
data = b'PK\x05\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' data = b'PK\x05\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
zip_file = io.BytesIO(data) zip_file = io.BytesIO(data)
@ -2076,7 +2076,7 @@ class StoredBadCrcTests(AbstractBadCrcTests, unittest.TestCase):
b'lePK\005\006\0\0\0\0\001\0\001\0003\000' b'lePK\005\006\0\0\0\0\001\0\001\0003\000'
b'\0\0/\0\0\0\0\0') b'\0\0/\0\0\0\0\0')
@requires_zlib @requires_zlib()
class DeflateBadCrcTests(AbstractBadCrcTests, unittest.TestCase): class DeflateBadCrcTests(AbstractBadCrcTests, unittest.TestCase):
compression = zipfile.ZIP_DEFLATED compression = zipfile.ZIP_DEFLATED
zip_with_bad_crc = ( zip_with_bad_crc = (
@ -2089,7 +2089,7 @@ class DeflateBadCrcTests(AbstractBadCrcTests, unittest.TestCase):
b'\x00afilePK\x05\x06\x00\x00\x00\x00\x01\x00' b'\x00afilePK\x05\x06\x00\x00\x00\x00\x01\x00'
b'\x01\x003\x00\x00\x003\x00\x00\x00\x00\x00') b'\x01\x003\x00\x00\x003\x00\x00\x00\x00\x00')
@requires_bz2 @requires_bz2()
class Bzip2BadCrcTests(AbstractBadCrcTests, unittest.TestCase): class Bzip2BadCrcTests(AbstractBadCrcTests, unittest.TestCase):
compression = zipfile.ZIP_BZIP2 compression = zipfile.ZIP_BZIP2
zip_with_bad_crc = ( zip_with_bad_crc = (
@ -2105,7 +2105,7 @@ class Bzip2BadCrcTests(AbstractBadCrcTests, unittest.TestCase):
b'\x05\x06\x00\x00\x00\x00\x01\x00\x01\x003\x00\x00\x00[\x00' b'\x05\x06\x00\x00\x00\x00\x01\x00\x01\x003\x00\x00\x00[\x00'
b'\x00\x00\x00\x00') b'\x00\x00\x00\x00')
@requires_lzma @requires_lzma()
class LzmaBadCrcTests(AbstractBadCrcTests, unittest.TestCase): class LzmaBadCrcTests(AbstractBadCrcTests, unittest.TestCase):
compression = zipfile.ZIP_LZMA compression = zipfile.ZIP_LZMA
zip_with_bad_crc = ( zip_with_bad_crc = (
@ -2172,7 +2172,7 @@ class DecryptionTests(unittest.TestCase):
self.zip2.setpassword(b"perl") self.zip2.setpassword(b"perl")
self.assertRaises(RuntimeError, self.zip2.read, "zero") self.assertRaises(RuntimeError, self.zip2.read, "zero")
@requires_zlib @requires_zlib()
def test_good_password(self): def test_good_password(self):
self.zip.setpassword(b"python") self.zip.setpassword(b"python")
self.assertEqual(self.zip.read("test.txt"), self.plain) self.assertEqual(self.zip.read("test.txt"), self.plain)
@ -2318,17 +2318,17 @@ class StoredTestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles,
unittest.TestCase): unittest.TestCase):
compression = zipfile.ZIP_STORED compression = zipfile.ZIP_STORED
@requires_zlib @requires_zlib()
class DeflateTestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles, class DeflateTestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles,
unittest.TestCase): unittest.TestCase):
compression = zipfile.ZIP_DEFLATED compression = zipfile.ZIP_DEFLATED
@requires_bz2 @requires_bz2()
class Bzip2TestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles, class Bzip2TestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles,
unittest.TestCase): unittest.TestCase):
compression = zipfile.ZIP_BZIP2 compression = zipfile.ZIP_BZIP2
@requires_lzma @requires_lzma()
class LzmaTestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles, class LzmaTestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles,
unittest.TestCase): unittest.TestCase):
compression = zipfile.ZIP_LZMA compression = zipfile.ZIP_LZMA
@ -2416,7 +2416,7 @@ class UnseekableTests(unittest.TestCase):
self.assertEqual(zipf.read('twos'), b'222') self.assertEqual(zipf.read('twos'), b'222')
@requires_zlib @requires_zlib()
class TestsWithMultipleOpens(unittest.TestCase): class TestsWithMultipleOpens(unittest.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
@ -2682,7 +2682,7 @@ class CommandLineTest(unittest.TestCase):
PYTHONIOENCODING='ascii:backslashreplace') PYTHONIOENCODING='ascii:backslashreplace')
self.assertEqual(out, expected) self.assertEqual(out, expected)
@requires_zlib @requires_zlib()
def test_create_command(self): def test_create_command(self):
self.addCleanup(unlink, TESTFN) self.addCleanup(unlink, TESTFN)
with open(TESTFN, 'w') as f: with open(TESTFN, 'w') as f:

2
Lib/test/test_zipfile64.py
View File

@ -73,7 +73,7 @@ class TestsWithSourceFile(unittest.TestCase):
self.assertFalse(f.closed) self.assertFalse(f.closed)
self.zipTest(TESTFN2, zipfile.ZIP_STORED) self.zipTest(TESTFN2, zipfile.ZIP_STORED)
@requires_zlib @requires_zlib()
def testDeflated(self): def testDeflated(self):
# Try the temp file first. If we do TESTFN2 first, then it hogs # Try the temp file first. If we do TESTFN2 first, then it hogs
# gigabytes of disk space for the duration of the test. # gigabytes of disk space for the duration of the test.

2
Lib/test/test_zipimport.py
View File

@ -683,7 +683,7 @@ class UncompressedZipImportTestCase(ImportHooksBaseTestCase):
self.doTest(".py", files, TESTMOD, comment=b"c" * ((1 << 16) - 1)) self.doTest(".py", files, TESTMOD, comment=b"c" * ((1 << 16) - 1))
@support.requires_zlib @support.requires_zlib()
class CompressedZipImportTestCase(UncompressedZipImportTestCase): class CompressedZipImportTestCase(UncompressedZipImportTestCase):
compression = ZIP_DEFLATED compression = ZIP_DEFLATED