mirror of https://github.com/python/cpython
Merged revisions 81214,82302,82465,83090-83091,84097,84099 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/branches/py3k
................
r81214 | brett.cannon | 2010-05-16 00:20:16 +0200 (dim., 16 mai 2010) | 2 lines
A test was not guaranteeing cleanup in the face of an exception.
................
r82302 | benjamin.peterson | 2010-06-28 00:37:28 +0200 (lun., 28 juin 2010) | 15 lines
Merged revisions 81380 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r81380 | brett.cannon | 2010-05-20 13:37:55 -0500 (Thu, 20 May 2010) | 8 lines
Turned out that if you used explicit relative import syntax
(e.g. from .os import sep) and it failed, import would still try the implicit
relative import semantics of an absolute import (from os import sep). That's
not right, so when level is negative, only do explicit relative import
semantics.
Fixes issue #7902. Thanks to Meador Inge for the patch.
........
................
r82465 | brett.cannon | 2010-07-03 03:32:48 +0200 (sam., 03 juil. 2010) | 3 lines
Make test_import a little bit more robust for cleaning up after itself in the
face of a failure.
................
r83090 | brett.cannon | 2010-07-23 16:03:16 +0200 (ven., 23 juil. 2010) | 4 lines
Explicitly test relative imports by reusing importlib tests.
Closes issue 8392. Thanks Virgil Dupras for the initial patch.
................
r83091 | brett.cannon | 2010-07-23 16:45:19 +0200 (ven., 23 juil. 2010) | 1 line
Stop shadowing a test class.
................
r84097 | florent.xicluna | 2010-08-16 20:41:19 +0200 (lun., 16 août 2010) | 1 line
Use test.support and unittest features. Fix duplicated test (bad merge in r79033). Fix comment for issue #7902.
................
r84099 | florent.xicluna | 2010-08-16 21:03:05 +0200 (lun., 16 août 2010) | 1 line
I get it wrong in r84097: s/relative/absolute/
................
This commit is contained in:
Florent Xicluna
parent
102594f7ff
commit
2760a66b69
|
|
@ -1,14 +1,18 @@
|
|||
import unittest
|
||||
import os
|
||||
import stat
|
||||
import random
|
||||
import shutil
|
||||
import sys
|
||||
import py_compile
|
||||
import warnings
|
||||
import imp
|
||||
from importlib.test.import_ import test_relative_imports
|
||||
from importlib.test.import_ import util as importlib_util
|
||||
import marshal
|
||||
from test.support import unlink, TESTFN, unload, run_unittest, TestFailed
|
||||
import os
|
||||
import py_compile
|
||||
import random
|
||||
import stat
|
||||
import sys
|
||||
import unittest
|
||||
import warnings
|
||||
|
||||
from test.support import (
|
||||
EnvironmentVarGuard, TESTFN, forget, is_jython,
|
||||
rmtree, run_unittest, unlink, unload)
|
||||
|
||||
|
||||
def remove_files(name):
|
||||
|
|
@ -17,15 +21,20 @@ def remove_files(name):
|
|||
name + ".pyo",
|
||||
name + ".pyw",
|
||||
name + "$py.class"):
|
||||
if os.path.exists(f):
|
||||
os.remove(f)
|
||||
unlink(f)
|
||||
rmtree('__pycache__')
|
||||
|
||||
|
||||
class ImportTest(unittest.TestCase):
|
||||
class ImportTests(unittest.TestCase):
|
||||
|
||||
def testCaseSensitivity(self):
|
||||
# Brief digression to test that import is case-sensitive: if we got this
|
||||
# far, we know for sure that "random" exists.
|
||||
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:
|
||||
import RAnDoM
|
||||
except ImportError:
|
||||
|
|
@ -33,22 +42,24 @@ class ImportTest(unittest.TestCase):
|
|||
else:
|
||||
self.fail("import of RAnDoM should have failed (case mismatch)")
|
||||
|
||||
def testDoubleConst(self):
|
||||
# Another brief digression to test the accuracy of manifest float constants.
|
||||
def test_double_const(self):
|
||||
# Another brief digression to test the accuracy of manifest float
|
||||
# constants.
|
||||
from test import double_const # don't blink -- that *was* the test
|
||||
|
||||
def testImport(self):
|
||||
def test_import(self):
|
||||
def test_with_extension(ext):
|
||||
# ext normally ".py"; perhaps ".pyw"
|
||||
# The extension is normally ".py", perhaps ".pyw".
|
||||
source = TESTFN + ext
|
||||
pyo = TESTFN + ".pyo"
|
||||
if sys.platform.startswith('java'):
|
||||
if is_jython:
|
||||
pyc = TESTFN + "$py.class"
|
||||
else:
|
||||
pyc = TESTFN + ".pyc"
|
||||
|
||||
with open(source, "w") as f:
|
||||
print("# This tests Python's ability to import a", ext, "file.", file=f)
|
||||
print("# This tests Python's ability to import a",
|
||||
ext, "file.", file=f)
|
||||
a = random.randrange(1000)
|
||||
b = random.randrange(1000)
|
||||
print("a =", a, file=f)
|
||||
|
|
@ -62,26 +73,27 @@ class ImportTest(unittest.TestCase):
|
|||
except ImportError as err:
|
||||
self.fail("import from %s failed: %s" % (ext, err))
|
||||
|
||||
self.assertEquals(mod.a, a,
|
||||
self.assertEqual(mod.a, a,
|
||||
"module loaded (%s) but contents invalid" % mod)
|
||||
self.assertEquals(mod.b, b,
|
||||
self.assertEqual(mod.b, b,
|
||||
"module loaded (%s) but contents invalid" % mod)
|
||||
finally:
|
||||
forget(TESTFN)
|
||||
unlink(source)
|
||||
unlink(pyc)
|
||||
unlink(pyo)
|
||||
del sys.modules[TESTFN]
|
||||
|
||||
sys.path.insert(0, os.curdir)
|
||||
try:
|
||||
test_with_extension(".py")
|
||||
if sys.platform.startswith("win"):
|
||||
for ext in ".PY", ".Py", ".pY", ".pyw", ".PYW", ".pYw":
|
||||
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.
|
||||
|
|
@ -107,48 +119,58 @@ class ImportTest(unittest.TestCase):
|
|||
if TESTFN in sys.modules: del sys.modules[TESTFN]
|
||||
del sys.path[0]
|
||||
|
||||
def testImpModule(self):
|
||||
def test_imp_module(self):
|
||||
# Verify that the imp module can correctly load and find .py files
|
||||
import imp
|
||||
x = imp.find_module("os")
|
||||
os = imp.load_module("os", *x)
|
||||
import imp, os
|
||||
# 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
|
||||
# state after reversion. Reinitialising the module contents
|
||||
# and just reverting os.environ to its previous state is an OK
|
||||
# workaround
|
||||
orig_path = os.path
|
||||
orig_getenv = os.getenv
|
||||
with EnvironmentVarGuard():
|
||||
x = imp.find_module("os")
|
||||
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_module_with_large_stack(self, module='longlist'):
|
||||
# create module w/list of 65000 elements to test bug #561858
|
||||
# Regression test for http://bugs.python.org/issue561858.
|
||||
filename = module + '.py'
|
||||
|
||||
# create a file with a list of 65000 elements
|
||||
f = open(filename, 'w+')
|
||||
f.write('d = [\n')
|
||||
for i in range(65000):
|
||||
f.write('"",\n')
|
||||
f.write(']')
|
||||
f.close()
|
||||
# Create a file with a list of 65000 elements.
|
||||
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)
|
||||
f = open(filename, 'r')
|
||||
py_compile.compile(filename)
|
||||
f.close()
|
||||
os.unlink(filename)
|
||||
try:
|
||||
# Compile & remove .py file; we only need .pyc (or .pyo).
|
||||
py_compile.compile(filename)
|
||||
finally:
|
||||
unlink(filename)
|
||||
|
||||
# need to be able to load from current dir
|
||||
# Need to be able to load from current dir.
|
||||
sys.path.append('')
|
||||
|
||||
# this used to crash
|
||||
exec('import ' + module)
|
||||
|
||||
# cleanup
|
||||
del sys.path[-1]
|
||||
for ext in '.pyc', '.pyo':
|
||||
fname = module + ext
|
||||
if os.path.exists(fname):
|
||||
os.unlink(fname)
|
||||
try:
|
||||
# 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 + ".py"
|
||||
f = open(source, "w")
|
||||
print("a = 1/0", file=f)
|
||||
f.close()
|
||||
with open(source, "w") as f:
|
||||
print("a = 1/0", file=f)
|
||||
|
||||
# New in 2.4, we shouldn't be able to import that no matter how often
|
||||
# we try.
|
||||
|
|
@ -156,16 +178,12 @@ class ImportTest(unittest.TestCase):
|
|||
if TESTFN in sys.modules:
|
||||
del sys.modules[TESTFN]
|
||||
try:
|
||||
for i in 1, 2, 3:
|
||||
try:
|
||||
mod = __import__(TESTFN)
|
||||
except ZeroDivisionError:
|
||||
if TESTFN in sys.modules:
|
||||
self.fail("damaged module in sys.modules on %i. try" % i)
|
||||
else:
|
||||
self.fail("was able to import a damaged module on %i. try" % i)
|
||||
for i in [1, 2, 3]:
|
||||
self.assertRaises(ZeroDivisionError, __import__, TESTFN)
|
||||
self.assertNotIn(TESTFN, sys.modules,
|
||||
"damaged module in sys.modules on %i try" % i)
|
||||
finally:
|
||||
sys.path.pop(0)
|
||||
del sys.path[0]
|
||||
remove_files(TESTFN)
|
||||
|
||||
def test_import_name_binding(self):
|
||||
|
|
@ -188,16 +206,16 @@ class ImportTest(unittest.TestCase):
|
|||
|
||||
def test_failing_reload(self):
|
||||
# A failing reload should leave the module object in sys.modules.
|
||||
source = TESTFN + ".py"
|
||||
source = TESTFN + os.extsep + "py"
|
||||
with open(source, "w") as f:
|
||||
f.write("a = 1\nb=2\n")
|
||||
|
||||
sys.path.insert(0, os.curdir)
|
||||
try:
|
||||
mod = __import__(TESTFN)
|
||||
self.assertTrue(TESTFN in sys.modules, "expected module in sys.modules")
|
||||
self.assertEquals(mod.a, 1, "module has wrong attribute values")
|
||||
self.assertEquals(mod.b, 2, "module has wrong attribute values")
|
||||
self.assertIn(TESTFN, sys.modules)
|
||||
self.assertEqual(mod.a, 1, "module has wrong attribute values")
|
||||
self.assertEqual(mod.b, 2, "module has wrong attribute values")
|
||||
|
||||
# On WinXP, just replacing the .py file wasn't enough to
|
||||
# convince reload() to reparse it. Maybe the timestamp didn't
|
||||
|
|
@ -212,18 +230,17 @@ class ImportTest(unittest.TestCase):
|
|||
self.assertRaises(ZeroDivisionError, imp.reload, mod)
|
||||
# But we still expect the module to be in sys.modules.
|
||||
mod = sys.modules.get(TESTFN)
|
||||
self.assertFalse(mod is None, "expected module to still be in sys.modules")
|
||||
self.assertIsNot(mod, None, "expected module to be in sys.modules")
|
||||
|
||||
# We should have replaced a w/ 10, but the old b value should
|
||||
# stick.
|
||||
self.assertEquals(mod.a, 10, "module has wrong attribute values")
|
||||
self.assertEquals(mod.b, 2, "module has wrong attribute values")
|
||||
self.assertEqual(mod.a, 10, "module has wrong attribute values")
|
||||
self.assertEqual(mod.b, 2, "module has wrong attribute values")
|
||||
|
||||
finally:
|
||||
sys.path.pop(0)
|
||||
del sys.path[0]
|
||||
remove_files(TESTFN)
|
||||
if TESTFN in sys.modules:
|
||||
del sys.modules[TESTFN]
|
||||
unload(TESTFN)
|
||||
|
||||
def test_file_to_source(self):
|
||||
# check if __file__ points to the source file where available
|
||||
|
|
@ -238,16 +255,26 @@ class ImportTest(unittest.TestCase):
|
|||
os.remove(source)
|
||||
del sys.modules[TESTFN]
|
||||
mod = __import__(TESTFN)
|
||||
ext = mod.__file__[-4:]
|
||||
self.assertTrue(ext in ('.pyc', '.pyo'), ext)
|
||||
base, ext = os.path.splitext(mod.__file__)
|
||||
self.assertIn(ext, ('.pyc', '.pyo'))
|
||||
finally:
|
||||
sys.path.pop(0)
|
||||
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.support
|
||||
self.assertIs(x, test, x.__name__)
|
||||
self.assertTrue(hasattr(test.support, "__file__"))
|
||||
|
||||
def test_importbyfilename(self):
|
||||
# import x.y.z as w binds z as w.
|
||||
import test.support as y
|
||||
self.assertIs(y, test.support, y.__name__)
|
||||
|
||||
def test_import_by_filename(self):
|
||||
path = os.path.abspath(TESTFN)
|
||||
try:
|
||||
__import__(path)
|
||||
|
|
@ -258,7 +285,7 @@ class ImportTest(unittest.TestCase):
|
|||
self.fail("import by path didn't raise an exception")
|
||||
|
||||
|
||||
class TestPycRewriting(unittest.TestCase):
|
||||
class PycRewritingTests(unittest.TestCase):
|
||||
# Test that the `co_filename` attribute on code objects always points
|
||||
# to the right file, even when various things happen (e.g. both the .py
|
||||
# and the .pyc file are renamed).
|
||||
|
|
@ -290,12 +317,10 @@ func_filename = func.__code__.co_filename
|
|||
if self.orig_module is not None:
|
||||
sys.modules[self.module_name] = self.orig_module
|
||||
else:
|
||||
del sys.modules[self.module_name]
|
||||
for file_name in self.file_name, self.compiled_name:
|
||||
if os.path.exists(file_name):
|
||||
os.remove(file_name)
|
||||
if os.path.exists(self.dir_name):
|
||||
shutil.rmtree(self.dir_name)
|
||||
unload(self.module_name)
|
||||
unlink(self.file_name)
|
||||
unlink(self.compiled_name)
|
||||
rmtree(self.dir_name)
|
||||
|
||||
def import_module(self):
|
||||
ns = globals()
|
||||
|
|
@ -350,6 +375,7 @@ func_filename = func.__code__.co_filename
|
|||
mod = self.import_module()
|
||||
self.assertEqual(mod.constant.co_filename, foreign_code.co_filename)
|
||||
|
||||
|
||||
class PathsTests(unittest.TestCase):
|
||||
SAMPLES = ('test', 'test\u00e4\u00f6\u00fc\u00df', 'test\u00e9\u00e8',
|
||||
'test\u00b0\u00b3\u00b2')
|
||||
|
|
@ -360,25 +386,23 @@ class PathsTests(unittest.TestCase):
|
|||
self.syspath = sys.path[:]
|
||||
|
||||
def tearDown(self):
|
||||
shutil.rmtree(self.path)
|
||||
sys.path = self.syspath
|
||||
rmtree(self.path)
|
||||
sys.path[:] = self.syspath
|
||||
|
||||
# http://bugs.python.org/issue1293
|
||||
# Regression test for http://bugs.python.org/issue1293.
|
||||
def test_trailing_slash(self):
|
||||
f = open(os.path.join(self.path, 'test_trailing_slash.py'), 'w')
|
||||
f.write("testdata = 'test_trailing_slash'")
|
||||
f.close()
|
||||
with open(os.path.join(self.path, 'test_trailing_slash.py'), 'w') as f:
|
||||
f.write("testdata = 'test_trailing_slash'")
|
||||
sys.path.append(self.path+'/')
|
||||
mod = __import__("test_trailing_slash")
|
||||
self.assertEqual(mod.testdata, 'test_trailing_slash')
|
||||
unload("test_trailing_slash")
|
||||
|
||||
# http://bugs.python.org/issue3677
|
||||
# Regression test for http://bugs.python.org/issue3677.
|
||||
def _test_UNC_path(self):
|
||||
f = open(os.path.join(self.path, 'test_trailing_slash.py'), 'w')
|
||||
f.write("testdata = 'test_trailing_slash'")
|
||||
f.close()
|
||||
#create the UNC path, like \\myhost\c$\foo\bar
|
||||
with open(os.path.join(self.path, 'test_trailing_slash.py'), 'w') as f:
|
||||
f.write("testdata = 'test_trailing_slash'")
|
||||
# Create the UNC path, like \\myhost\c$\foo\bar.
|
||||
path = os.path.abspath(self.path)
|
||||
import socket
|
||||
hn = socket.gethostname()
|
||||
|
|
@ -394,44 +418,73 @@ class PathsTests(unittest.TestCase):
|
|||
test_UNC_path = _test_UNC_path
|
||||
|
||||
|
||||
class RelativeImport(unittest.TestCase):
|
||||
class RelativeImportTests(unittest.TestCase):
|
||||
|
||||
def tearDown(self):
|
||||
try:
|
||||
del sys.modules["test.relimport"]
|
||||
except:
|
||||
pass
|
||||
unload("test.relimport")
|
||||
setUp = tearDown
|
||||
|
||||
def test_relimport_star(self):
|
||||
# This will import * from .test_import.
|
||||
from . import relimport
|
||||
self.assertTrue(hasattr(relimport, "RelativeImport"))
|
||||
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_relative():
|
||||
exec("from . import relimport", ns)
|
||||
|
||||
# Check relative import OK with __package__ and __name__ correct
|
||||
ns = dict(__package__='test', __name__='test.notarealmodule')
|
||||
check_relative()
|
||||
|
||||
# Check relative import OK with only __name__ wrong
|
||||
ns = dict(__package__='test', __name__='notarealpkg.notarealmodule')
|
||||
check_relative()
|
||||
|
||||
# Check relative import fails with only __package__ wrong
|
||||
ns = dict(__package__='foo', __name__='test.notarealmodule')
|
||||
self.assertRaises(SystemError, check_relative)
|
||||
|
||||
# Check relative import fails with __package__ and __name__ wrong
|
||||
ns = dict(__package__='foo', __name__='notarealpkg.notarealmodule')
|
||||
self.assertRaises(SystemError, check_relative)
|
||||
|
||||
# Check relative import fails with package set to a non-string
|
||||
ns = dict(__package__=object())
|
||||
self.assertRaises(ValueError, check_relative)
|
||||
|
||||
def test_absolute_import_without_future(self):
|
||||
# If explicit relative import syntax is used, then do not try
|
||||
# to perform an absolute import in the face of failure.
|
||||
# Issue #7902.
|
||||
with self.assertRaises(ImportError):
|
||||
from .os import sep
|
||||
self.fail("explicit relative import triggered an "
|
||||
"implicit absolute import")
|
||||
|
||||
|
||||
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(ImportTest, TestPycRewriting, PathsTests, RelativeImport)
|
||||
run_unittest(ImportTests,
|
||||
PycRewritingTests, PathsTests, RelativeImportTests,
|
||||
RelativeImportFromImportlibTests)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
# test needs to be a package, so we can do relative import
|
||||
# Test needs to be a package, so we can do relative imports.
|
||||
from test.test_import import test_main
|
||||
test_main()
|
||||
|
|
|
|||
|
|
@ -2143,7 +2143,8 @@ import_module_level(char *name, PyObject *globals, PyObject *locals,
|
|||
if (parent == NULL)
|
||||
return NULL;
|
||||
|
||||
head = load_next(parent, Py_None, &name, buf, &buflen);
|
||||
head = load_next(parent, level < 0 ? Py_None : parent, &name, buf,
|
||||
&buflen);
|
||||
if (head == NULL)
|
||||
return NULL;
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue