diff options
Diffstat (limited to 'Lib/test/test_import.py')
| -rw-r--r-- | Lib/test/test_import.py | 519 |
1 files changed, 315 insertions, 204 deletions
diff --git a/Lib/test/test_import.py b/Lib/test/test_import.py index ea50d34..b10f350 100644 --- a/Lib/test/test_import.py +++ b/Lib/test/test_import.py @@ -1,21 +1,25 @@ -import errno +import builtins import imp +from importlib.test.import_ import test_relative_imports +from importlib.test.import_ import util as importlib_util import marshal import os +import platform import py_compile import random import stat -import struct import sys import unittest import textwrap -import shutil +import errno -from test.test_support import (unlink, TESTFN, unload, run_unittest, rmtree, - is_jython, check_warnings, EnvironmentVarGuard) -from test import symlink_support +from test.support import ( + EnvironmentVarGuard, TESTFN, check_warnings, forget, is_jython, + make_legacy_pyc, rmtree, run_unittest, swap_attr, swap_item, temp_umask, + unlink, unload) from test import script_helper + def _files(name): return (name + os.extsep + "py", name + os.extsep + "pyc", @@ -26,7 +30,7 @@ def _files(name): def chmod_files(name): for f in _files(name): try: - os.chmod(f, 0600) + os.chmod(f, 0o600) except OSError as exc: if exc.errno != errno.ENOENT: raise @@ -34,23 +38,24 @@ def chmod_files(name): def remove_files(name): for f in _files(name): unlink(f) + rmtree('__pycache__') class ImportTests(unittest.TestCase): + def setUp(self): + remove_files(TESTFN) + def tearDown(self): unload(TESTFN) + setUp = tearDown def test_case_sensitivity(self): # Brief digression to test that import is case-sensitive: if we got # this far, we know for sure that "random" exists. - try: + with self.assertRaises(ImportError): import RAnDoM - except ImportError: - pass - else: - self.fail("import of RAnDoM should have failed (case mismatch)") def test_double_const(self): # Another brief digression to test the accuracy of manifest float @@ -61,76 +66,72 @@ class ImportTests(unittest.TestCase): def test_with_extension(ext): # The extension is normally ".py", perhaps ".pyw". source = TESTFN + ext - pyo = TESTFN + os.extsep + "pyo" + pyo = TESTFN + ".pyo" if is_jython: pyc = TESTFN + "$py.class" else: - pyc = TESTFN + os.extsep + "pyc" + pyc = TESTFN + ".pyc" with open(source, "w") as f: - print >> f, ("# This tests Python's ability to import a", ext, - "file.") + print("# This tests Python's ability to import a", + ext, "file.", file=f) a = random.randrange(1000) b = random.randrange(1000) - print >> f, "a =", a - print >> f, "b =", b + print("a =", a, file=f) + print("b =", b, file=f) + if TESTFN in sys.modules: + del sys.modules[TESTFN] try: - mod = __import__(TESTFN) - except ImportError, err: - self.fail("import from %s failed: %s" % (ext, err)) - else: + try: + mod = __import__(TESTFN) + except ImportError as err: + self.fail("import from %s failed: %s" % (ext, err)) + self.assertEqual(mod.a, a, "module loaded (%s) but contents invalid" % mod) self.assertEqual(mod.b, b, "module loaded (%s) but contents invalid" % mod) finally: + forget(TESTFN) unlink(source) - - try: - imp.reload(mod) - except ImportError, err: - self.fail("import from .pyc/.pyo failed: %s" % err) - finally: unlink(pyc) unlink(pyo) - unload(TESTFN) sys.path.insert(0, os.curdir) try: - test_with_extension(os.extsep + "py") + test_with_extension(".py") if sys.platform.startswith("win"): for ext in [".PY", ".Py", ".pY", ".pyw", ".PYW", ".pYw"]: test_with_extension(ext) finally: del sys.path[0] - @unittest.skipUnless(os.name == 'posix', "test meaningful only on posix systems") + @unittest.skipUnless(os.name == 'posix', + "test meaningful only on posix systems") def test_execute_bit_not_copied(self): # Issue 6070: under posix .pyc files got their execute bit set if # the .py file had the execute bit set, but they aren't executable. - oldmask = os.umask(022) - sys.path.insert(0, os.curdir) - try: - fname = TESTFN + os.extsep + "py" - f = open(fname, 'w').close() - os.chmod(fname, (stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH | - stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)) - __import__(TESTFN) - fn = fname + 'c' - if not os.path.exists(fn): - fn = fname + 'o' + with temp_umask(0o022): + sys.path.insert(0, os.curdir) + try: + fname = TESTFN + os.extsep + "py" + open(fname, 'w').close() + os.chmod(fname, (stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH | + stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)) + fn = imp.cache_from_source(fname) + unlink(fn) + __import__(TESTFN) if not os.path.exists(fn): self.fail("__import__ did not result in creation of " "either a .pyc or .pyo file") - s = os.stat(fn) - self.assertEqual(stat.S_IMODE(s.st_mode), - stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH) - finally: - os.umask(oldmask) - remove_files(TESTFN) - unload(TESTFN) - del sys.path[0] + s = os.stat(fn) + self.assertEqual(stat.S_IMODE(s.st_mode), + stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH) + finally: + del sys.path[0] + remove_files(TESTFN) + unload(TESTFN) def test_rewrite_pyc_with_read_only_source(self): # Issue 6074: a long time ago on posix, and more recently on Windows, @@ -145,11 +146,11 @@ class ImportTests(unittest.TestCase): # Tweak the mtime of the source to ensure pyc gets updated later s = os.stat(fname) os.utime(fname, (s.st_atime, s.st_mtime-100000000)) - os.chmod(fname, 0400) + os.chmod(fname, 0o400) m1 = __import__(TESTFN) self.assertEqual(m1.x, 'original') # Change the file and then reimport it - os.chmod(fname, 0600) + os.chmod(fname, 0o600) with open(fname, 'w') as f: f.write("x = 'rewritten'\n") unload(TESTFN) @@ -158,6 +159,11 @@ class ImportTests(unittest.TestCase): # Now delete the source file and check the pyc was rewritten unlink(fname) unload(TESTFN) + if __debug__: + bytecode_name = fname + "c" + else: + bytecode_name = fname + "o" + os.rename(imp.cache_from_source(fname), bytecode_name) m3 = __import__(TESTFN) self.assertEqual(m3.x, 'rewritten') finally: @@ -168,8 +174,7 @@ class ImportTests(unittest.TestCase): def test_imp_module(self): # Verify that the imp module can correctly load and find .py files - - # XXX (ncoghlan): It would be nice to use test_support.CleanImport + # XXX (ncoghlan): It would be nice to use support.CleanImport # here, but that breaks because the os module registers some # handlers in copy_reg on import. Since CleanImport doesn't # revert that registration, the module is left in a broken @@ -180,46 +185,62 @@ class ImportTests(unittest.TestCase): orig_getenv = os.getenv with EnvironmentVarGuard(): x = imp.find_module("os") + self.addCleanup(x[0].close) new_os = imp.load_module("os", *x) self.assertIs(os, new_os) self.assertIs(orig_path, new_os.path) self.assertIsNot(orig_getenv, new_os.getenv) + def test_bug7732(self): + source = TESTFN + '.py' + os.mkdir(source) + try: + self.assertRaisesRegex(ImportError, '^No module', + imp.find_module, TESTFN, ["."]) + finally: + os.rmdir(source) + def test_module_with_large_stack(self, module='longlist'): # Regression test for http://bugs.python.org/issue561858. - filename = module + os.extsep + 'py' + filename = module + '.py' # Create a file with a list of 65000 elements. - with open(filename, 'w+') as f: + with open(filename, 'w') as f: f.write('d = [\n') for i in range(65000): f.write('"",\n') f.write(']') - # Compile & remove .py file, we only need .pyc (or .pyo). - with open(filename, 'r') as f: + try: + # Compile & remove .py file; we only need .pyc (or .pyo). + # Bytecode must be relocated from the PEP 3147 bytecode-only location. py_compile.compile(filename) - unlink(filename) + finally: + unlink(filename) # Need to be able to load from current dir. sys.path.append('') - # This used to crash. - exec 'import ' + module - - # Cleanup. - del sys.path[-1] - unlink(filename + 'c') - unlink(filename + 'o') + try: + make_legacy_pyc(filename) + # This used to crash. + exec('import ' + module) + finally: + # Cleanup. + del sys.path[-1] + unlink(filename + 'c') + unlink(filename + 'o') def test_failing_import_sticks(self): - source = TESTFN + os.extsep + "py" + source = TESTFN + ".py" with open(source, "w") as f: - print >> f, "a = 1 // 0" + print("a = 1/0", file=f) # New in 2.4, we shouldn't be able to import that no matter how often # we try. sys.path.insert(0, os.curdir) + if TESTFN in sys.modules: + del sys.modules[TESTFN] try: for i in [1, 2, 3]: self.assertRaises(ZeroDivisionError, __import__, TESTFN) @@ -229,12 +250,22 @@ class ImportTests(unittest.TestCase): del sys.path[0] remove_files(TESTFN) + def test_import_name_binding(self): + # import x.y.z binds x in the current namespace + import test as x + import test.support + self.assertTrue(x is test, x.__name__) + self.assertTrue(hasattr(test.support, "__file__")) + + # import x.y.z as w binds z as w + import test.support as y + self.assertTrue(y is test.support, y.__name__) + def test_failing_reload(self): # A failing reload should leave the module object in sys.modules. source = TESTFN + os.extsep + "py" with open(source, "w") as f: - print >> f, "a = 1" - print >> f, "b = 2" + f.write("a = 1\nb=2\n") sys.path.insert(0, os.curdir) try: @@ -251,11 +282,9 @@ class ImportTests(unittest.TestCase): # Now damage the module. with open(source, "w") as f: - print >> f, "a = 10" - print >> f, "b = 20//0" + f.write("a = 10\nb=20//0\n") self.assertRaises(ZeroDivisionError, imp.reload, mod) - # But we still expect the module to be in sys.modules. mod = sys.modules.get(TESTFN) self.assertIsNot(mod, None, "expected module to be in sys.modules") @@ -270,26 +299,38 @@ class ImportTests(unittest.TestCase): remove_files(TESTFN) unload(TESTFN) - def test_infinite_reload(self): - # http://bugs.python.org/issue742342 reports that Python segfaults - # (infinite recursion in C) when faced with self-recursive reload()ing. + def test_file_to_source(self): + # check if __file__ points to the source file where available + source = TESTFN + ".py" + with open(source, "w") as f: + f.write("test = None\n") - sys.path.insert(0, os.path.dirname(__file__)) + sys.path.insert(0, os.curdir) try: - import infinite_reload + mod = __import__(TESTFN) + self.assertTrue(mod.__file__.endswith('.py')) + os.remove(source) + del sys.modules[TESTFN] + make_legacy_pyc(source) + mod = __import__(TESTFN) + base, ext = os.path.splitext(mod.__file__) + self.assertIn(ext, ('.pyc', '.pyo')) finally: del sys.path[0] + remove_files(TESTFN) + if TESTFN in sys.modules: + del sys.modules[TESTFN] def test_import_name_binding(self): # import x.y.z binds x in the current namespace. import test as x - import test.test_support + import test.support self.assertIs(x, test, x.__name__) - self.assertTrue(hasattr(test.test_support, "__file__")) + self.assertTrue(hasattr(test.support, "__file__")) # import x.y.z as w binds z as w. - import test.test_support as y - self.assertIs(y, test.test_support, y.__name__) + import test.support as y + self.assertIs(y, test.support, y.__name__) def test_import_initless_directory_warning(self): with check_warnings(('', ImportWarning)): @@ -299,6 +340,11 @@ class ImportTests(unittest.TestCase): def test_import_by_filename(self): path = os.path.abspath(TESTFN) + encoding = sys.getfilesystemencoding() + try: + path.encode(encoding) + except UnicodeEncodeError: + self.skipTest('path is not encodable to {}'.format(encoding)) with self.assertRaises(ImportError) as c: __import__(path) self.assertEqual("Import by filename is not supported.", @@ -313,19 +359,7 @@ class ImportTests(unittest.TestCase): import imp sys.argv.insert(0, C()) """)) - try: - script_helper.assert_python_ok(testfn) - finally: - unlink(testfn) - - def test_bug7732(self): - source = TESTFN + '.py' - os.mkdir(source) - try: - self.assertRaises((ImportError, IOError), - imp.find_module, TESTFN, ["."]) - finally: - os.rmdir(source) + script_helper.assert_python_ok(testfn) def test_timestamp_overflow(self): # A modification timestamp larger than 2**32 should not be a problem @@ -333,7 +367,7 @@ class ImportTests(unittest.TestCase): sys.path.insert(0, os.curdir) try: source = TESTFN + ".py" - compiled = source + ('c' if __debug__ else 'o') + compiled = imp.cache_from_source(source) with open(source, 'w') as f: pass try: @@ -351,46 +385,6 @@ class ImportTests(unittest.TestCase): del sys.path[0] remove_files(TESTFN) - def test_pyc_mtime(self): - # Test for issue #13863: .pyc timestamp sometimes incorrect on Windows. - sys.path.insert(0, os.curdir) - try: - # Jan 1, 2012; Jul 1, 2012. - mtimes = 1325376000, 1341100800 - - # Different names to avoid running into import caching. - tails = "spam", "eggs" - for mtime, tail in zip(mtimes, tails): - module = TESTFN + tail - source = module + ".py" - compiled = source + ('c' if __debug__ else 'o') - - # Create a new Python file with the given mtime. - with open(source, 'w') as f: - f.write("# Just testing\nx=1, 2, 3\n") - os.utime(source, (mtime, mtime)) - - # Generate the .pyc/o file; if it couldn't be created - # for some reason, skip the test. - m = __import__(module) - if not os.path.exists(compiled): - unlink(source) - self.skipTest("Couldn't create .pyc/.pyo file.") - - # Actual modification time of .py file. - mtime1 = int(os.stat(source).st_mtime) & 0xffffffff - - # mtime that was encoded in the .pyc file. - with open(compiled, 'rb') as f: - mtime2 = struct.unpack('<L', f.read(8)[4:])[0] - - unlink(compiled) - unlink(source) - - self.assertEqual(mtime1, mtime2) - finally: - sys.path.pop(0) - class PycRewritingTests(unittest.TestCase): # Test that the `co_filename` attribute on code objects always points @@ -405,11 +399,11 @@ module_filename = __file__ constant = 1 def func(): pass -func_filename = func.func_code.co_filename +func_filename = func.__code__.co_filename """ dir_name = os.path.abspath(TESTFN) file_name = os.path.join(dir_name, module_name) + os.extsep + "py" - compiled_name = file_name + ("c" if __debug__ else "o") + compiled_name = imp.cache_from_source(file_name) def setUp(self): self.sys_path = sys.path[:] @@ -441,14 +435,14 @@ func_filename = func.func_code.co_filename self.assertEqual(mod.func_filename, self.file_name) del sys.modules[self.module_name] mod = self.import_module() - self.assertEqual(mod.module_filename, self.compiled_name) + self.assertEqual(mod.module_filename, self.file_name) self.assertEqual(mod.code_filename, self.file_name) self.assertEqual(mod.func_filename, self.file_name) def test_incorrect_code_name(self): py_compile.compile(self.file_name, dfile="another_module.py") mod = self.import_module() - self.assertEqual(mod.module_filename, self.compiled_name) + self.assertEqual(mod.module_filename, self.file_name) self.assertEqual(mod.code_filename, self.file_name) self.assertEqual(mod.func_filename, self.file_name) @@ -456,8 +450,9 @@ func_filename = func.func_code.co_filename target = "another_module.py" py_compile.compile(self.file_name, dfile=target) os.remove(self.file_name) + pyc_file = make_legacy_pyc(self.file_name) mod = self.import_module() - self.assertEqual(mod.module_filename, self.compiled_name) + self.assertEqual(mod.module_filename, pyc_file) self.assertEqual(mod.code_filename, target) self.assertEqual(mod.func_filename, target) @@ -467,10 +462,11 @@ func_filename = func.func_code.co_filename header = f.read(8) code = marshal.load(f) constants = list(code.co_consts) - foreign_code = test_main.func_code + foreign_code = test_main.__code__ pos = constants.index(1) constants[pos] = foreign_code - code = type(code)(code.co_argcount, code.co_nlocals, code.co_stacksize, + code = type(code)(code.co_argcount, code.co_kwonlyargcount, + code.co_nlocals, code.co_stacksize, code.co_flags, code.co_code, tuple(constants), code.co_names, code.co_varnames, code.co_filename, code.co_name, code.co_firstlineno, code.co_lnotab, @@ -483,6 +479,8 @@ func_filename = func.func_code.co_filename class PathsTests(unittest.TestCase): + SAMPLES = ('test', 'test\u00e4\u00f6\u00fc\u00df', 'test\u00e9\u00e8', + 'test\u00b0\u00b3\u00b2') path = TESTFN def setUp(self): @@ -541,37 +539,32 @@ class RelativeImportTests(unittest.TestCase): self.assertTrue(hasattr(relimport, "RelativeImportTests")) def test_issue3221(self): + # Note for mergers: the 'absolute' tests from the 2.x branch + # are missing in Py3k because implicit relative imports are + # a thing of the past + # # Regression test for http://bugs.python.org/issue3221. - def check_absolute(): - exec "from os import path" in ns def check_relative(): - exec "from . import relimport" in ns + exec("from . import relimport", ns) - # Check both OK with __package__ and __name__ correct + # Check relative import OK with __package__ and __name__ correct ns = dict(__package__='test', __name__='test.notarealmodule') - check_absolute() check_relative() - # Check both OK with only __name__ wrong + # Check relative import OK with only __name__ wrong ns = dict(__package__='test', __name__='notarealpkg.notarealmodule') - check_absolute() check_relative() - # Check relative fails with only __package__ wrong + # Check relative import fails with only __package__ wrong ns = dict(__package__='foo', __name__='test.notarealmodule') - with check_warnings(('.+foo', RuntimeWarning)): - check_absolute() self.assertRaises(SystemError, check_relative) - # Check relative fails with __package__ and __name__ wrong + # Check relative import fails with __package__ and __name__ wrong ns = dict(__package__='foo', __name__='notarealpkg.notarealmodule') - with check_warnings(('.+foo', RuntimeWarning)): - check_absolute() self.assertRaises(SystemError, check_relative) - # Check both fail with package set to a non-string + # Check relative import fails with package set to a non-string ns = dict(__package__=object()) - self.assertRaises(ValueError, check_absolute) self.assertRaises(ValueError, check_relative) def test_absolute_import_without_future(self): @@ -584,58 +577,176 @@ class RelativeImportTests(unittest.TestCase): "implicit absolute import") -class TestSymbolicallyLinkedPackage(unittest.TestCase): - package_name = 'sample' +class OverridingImportBuiltinTests(unittest.TestCase): + def test_override_builtin(self): + # Test that overriding builtins.__import__ can bypass sys.modules. + import os + + def foo(): + import os + return os + self.assertEqual(foo(), os) # Quick sanity check. + + with swap_attr(builtins, "__import__", lambda *x: 5): + self.assertEqual(foo(), 5) + + # Test what happens when we shadow __import__ in globals(); this + # currently does not impact the import process, but if this changes, + # other code will need to change, so keep this test as a tripwire. + with swap_item(globals(), "__import__", lambda *x: 5): + self.assertEqual(foo(), os) + + +class PycacheTests(unittest.TestCase): + # Test the various PEP 3147 related behaviors. + + tag = imp.get_tag() + + def _clean(self): + forget(TESTFN) + rmtree('__pycache__') + unlink(self.source) def setUp(self): - if os.path.exists(self.tagged): - shutil.rmtree(self.tagged) - if os.path.exists(self.package_name): - symlink_support.remove_symlink(self.package_name) - self.orig_sys_path = sys.path[:] - - # create a sample package; imagine you have a package with a tag and - # you want to symbolically link it from its untagged name. - os.mkdir(self.tagged) - init_file = os.path.join(self.tagged, '__init__.py') - open(init_file, 'w').close() - assert os.path.exists(init_file) - - # now create a symlink to the tagged package - # sample -> sample-tagged - symlink_support.symlink(self.tagged, self.package_name) - - assert os.path.isdir(self.package_name) - assert os.path.isfile(os.path.join(self.package_name, '__init__.py')) - - @property - def tagged(self): - return self.package_name + '-tagged' - - # regression test for issue6727 - @unittest.skipUnless( - not hasattr(sys, 'getwindowsversion') - or sys.getwindowsversion() >= (6, 0), - "Windows Vista or later required") - @symlink_support.skip_unless_symlink - def test_symlinked_dir_importable(self): - # make sure sample can only be imported from the current directory. - sys.path[:] = ['.'] - - # and try to import the package - __import__(self.package_name) + self.source = TESTFN + '.py' + self._clean() + with open(self.source, 'w') as fp: + print('# This is a test file written by test_import.py', file=fp) + sys.path.insert(0, os.curdir) def tearDown(self): - # now cleanup - if os.path.exists(self.package_name): - symlink_support.remove_symlink(self.package_name) - if os.path.exists(self.tagged): - shutil.rmtree(self.tagged) - sys.path[:] = self.orig_sys_path + assert sys.path[0] == os.curdir, 'Unexpected sys.path[0]' + del sys.path[0] + self._clean() + + def test_import_pyc_path(self): + self.assertFalse(os.path.exists('__pycache__')) + __import__(TESTFN) + self.assertTrue(os.path.exists('__pycache__')) + self.assertTrue(os.path.exists(os.path.join( + '__pycache__', '{}.{}.py{}'.format( + TESTFN, self.tag, 'c' if __debug__ else 'o')))) + + @unittest.skipUnless(os.name == 'posix', + "test meaningful only on posix systems") + @unittest.skipIf(hasattr(os, 'geteuid') and os.geteuid() == 0, + "due to varying filesystem permission semantics (issue #11956)") + def test_unwritable_directory(self): + # When the umask causes the new __pycache__ directory to be + # unwritable, the import still succeeds but no .pyc file is written. + with temp_umask(0o222): + __import__(TESTFN) + self.assertTrue(os.path.exists('__pycache__')) + self.assertFalse(os.path.exists(os.path.join( + '__pycache__', '{}.{}.pyc'.format(TESTFN, self.tag)))) + + def test_missing_source(self): + # With PEP 3147 cache layout, removing the source but leaving the pyc + # file does not satisfy the import. + __import__(TESTFN) + pyc_file = imp.cache_from_source(self.source) + self.assertTrue(os.path.exists(pyc_file)) + os.remove(self.source) + forget(TESTFN) + self.assertRaises(ImportError, __import__, TESTFN) + + def test_missing_source_legacy(self): + # Like test_missing_source() except that for backward compatibility, + # when the pyc file lives where the py file would have been (and named + # without the tag), it is importable. The __file__ of the imported + # module is the pyc location. + __import__(TESTFN) + # pyc_file gets removed in _clean() via tearDown(). + pyc_file = make_legacy_pyc(self.source) + os.remove(self.source) + unload(TESTFN) + m = __import__(TESTFN) + self.assertEqual(m.__file__, + os.path.join(os.curdir, os.path.relpath(pyc_file))) + + def test___cached__(self): + # Modules now also have an __cached__ that points to the pyc file. + m = __import__(TESTFN) + pyc_file = imp.cache_from_source(TESTFN + '.py') + self.assertEqual(m.__cached__, os.path.join(os.curdir, pyc_file)) + + def test___cached___legacy_pyc(self): + # Like test___cached__() except that for backward compatibility, + # when the pyc file lives where the py file would have been (and named + # without the tag), it is importable. The __cached__ of the imported + # module is the pyc location. + __import__(TESTFN) + # pyc_file gets removed in _clean() via tearDown(). + pyc_file = make_legacy_pyc(self.source) + os.remove(self.source) + unload(TESTFN) + m = __import__(TESTFN) + self.assertEqual(m.__cached__, + os.path.join(os.curdir, os.path.relpath(pyc_file))) + + def test_package___cached__(self): + # Like test___cached__ but for packages. + def cleanup(): + rmtree('pep3147') + os.mkdir('pep3147') + self.addCleanup(cleanup) + # Touch the __init__.py + with open(os.path.join('pep3147', '__init__.py'), 'w'): + pass + with open(os.path.join('pep3147', 'foo.py'), 'w'): + pass + unload('pep3147.foo') + unload('pep3147') + m = __import__('pep3147.foo') + init_pyc = imp.cache_from_source( + os.path.join('pep3147', '__init__.py')) + self.assertEqual(m.__cached__, os.path.join(os.curdir, init_pyc)) + foo_pyc = imp.cache_from_source(os.path.join('pep3147', 'foo.py')) + self.assertEqual(sys.modules['pep3147.foo'].__cached__, + os.path.join(os.curdir, foo_pyc)) + + def test_package___cached___from_pyc(self): + # Like test___cached__ but ensuring __cached__ when imported from a + # PEP 3147 pyc file. + def cleanup(): + rmtree('pep3147') + os.mkdir('pep3147') + self.addCleanup(cleanup) + unload('pep3147.foo') + unload('pep3147') + # Touch the __init__.py + with open(os.path.join('pep3147', '__init__.py'), 'w'): + pass + with open(os.path.join('pep3147', 'foo.py'), 'w'): + pass + m = __import__('pep3147.foo') + unload('pep3147.foo') + unload('pep3147') + m = __import__('pep3147.foo') + init_pyc = imp.cache_from_source( + os.path.join('pep3147', '__init__.py')) + self.assertEqual(m.__cached__, os.path.join(os.curdir, init_pyc)) + foo_pyc = imp.cache_from_source(os.path.join('pep3147', 'foo.py')) + self.assertEqual(sys.modules['pep3147.foo'].__cached__, + os.path.join(os.curdir, foo_pyc)) + + +class RelativeImportFromImportlibTests(test_relative_imports.RelativeImports): + + def setUp(self): + self._importlib_util_flag = importlib_util.using___import__ + importlib_util.using___import__ = True + + def tearDown(self): + importlib_util.using___import__ = self._importlib_util_flag + def test_main(verbose=None): - run_unittest(ImportTests, PycRewritingTests, PathsTests, - RelativeImportTests, TestSymbolicallyLinkedPackage) + run_unittest(ImportTests, PycacheTests, + PycRewritingTests, PathsTests, RelativeImportTests, + OverridingImportBuiltinTests, + RelativeImportFromImportlibTests) + if __name__ == '__main__': # Test needs to be a package, so we can do relative imports. |