[Python-checkins] cpython (merge 3.2 -> default): Merge fix for #15230 from 3.2
nick.coghlan
python-checkins at python.org
Sat Jul 14 16:08:06 CEST 2012
http://hg.python.org/cpython/rev/8a44e7c0fa30
changeset: 78095:8a44e7c0fa30
parent: 78093:0dbffd3c1317
parent: 78094:3b05cf877124
user: Nick Coghlan <ncoghlan at gmail.com>
date: Sun Jul 15 00:07:43 2012 +1000
summary:
Merge fix for #15230 from 3.2
files:
Lib/runpy.py | 6 +-
Lib/test/test_runpy.py | 420 ++++++++++++++++++----------
Misc/NEWS | 5 +
3 files changed, 275 insertions(+), 156 deletions(-)
diff --git a/Lib/runpy.py b/Lib/runpy.py
--- a/Lib/runpy.py
+++ b/Lib/runpy.py
@@ -70,6 +70,7 @@
run_globals.update(__name__ = mod_name,
__file__ = mod_fname,
__cached__ = None,
+ __doc__ = None,
__loader__ = mod_loader,
__package__ = pkg_name)
exec(code, run_globals)
@@ -233,12 +234,14 @@
"""
if run_name is None:
run_name = "<run_path>"
+ pkg_name = run_name.rpartition(".")[0]
importer = _get_importer(path_name)
if isinstance(importer, (type(None), imp.NullImporter)):
# Not a valid sys.path entry, so run the code directly
# execfile() doesn't help as we want to allow compiled files
code = _get_code_from_file(path_name)
- return _run_module_code(code, init_globals, run_name, path_name)
+ return _run_module_code(code, init_globals, run_name, path_name,
+ pkg_name=pkg_name)
else:
# Importer is defined for path, so add it to
# the start of sys.path
@@ -257,7 +260,6 @@
mod_name, loader, code, fname = _get_main_module_details()
finally:
sys.modules[main_name] = saved_main
- pkg_name = ""
with _TempModule(run_name) as temp_module, \
_ModifiedArgv0(path_name):
mod_globals = temp_module.module.__dict__
diff --git a/Lib/test/test_runpy.py b/Lib/test/test_runpy.py
--- a/Lib/test/test_runpy.py
+++ b/Lib/test/test_runpy.py
@@ -13,80 +13,143 @@
from test.script_helper import (
make_pkg, make_script, make_zip_pkg, make_zip_script, temp_dir)
-
+import runpy
from runpy import _run_code, _run_module_code, run_module, run_path
# Note: This module can't safely test _run_module_as_main as it
# runs its tests in the current process, which would mess with the
# real __main__ module (usually test.regrtest)
# See test_cmd_line_script for a test that executes that code path
+
# Set up the test code and expected results
+example_source = """\
+# Check basic code execution
+result = ['Top level assignment']
+def f():
+ result.append('Lower level reference')
+f()
+del f
+# Check the sys module
+import sys
+run_argv0 = sys.argv[0]
+run_name_in_sys_modules = __name__ in sys.modules
+module_in_sys_modules = (run_name_in_sys_modules and
+ globals() is sys.modules[__name__].__dict__)
+# Check nested operation
+import runpy
+nested = runpy._run_module_code('x=1\\n', mod_name='<run>')
+"""
-class RunModuleCodeTest(unittest.TestCase):
+implicit_namespace = {
+ "__name__": None,
+ "__file__": None,
+ "__cached__": None,
+ "__package__": None,
+ "__doc__": None,
+}
+example_namespace = {
+ "sys": sys,
+ "runpy": runpy,
+ "result": ["Top level assignment", "Lower level reference"],
+ "run_argv0": sys.argv[0],
+ "run_name_in_sys_modules": False,
+ "module_in_sys_modules": False,
+ "nested": dict(implicit_namespace,
+ x=1, __name__="<run>", __loader__=None),
+}
+example_namespace.update(implicit_namespace)
+
+class CodeExecutionMixin:
+ # Issue #15230 (run_path not handling run_name correctly) highlighted a
+ # problem with the way arguments were being passed from higher level APIs
+ # down to lower level code. This mixin makes it easier to ensure full
+ # testing occurs at those upper layers as well, not just at the utility
+ # layer
+
+ def assertNamespaceMatches(self, result_ns, expected_ns):
+ """Check two namespaces match.
+
+ Ignores any unspecified interpreter created names
+ """
+ # Impls are permitted to add extra names, so filter them out
+ for k in list(result_ns):
+ if k.startswith("__") and k.endswith("__"):
+ if k not in expected_ns:
+ result_ns.pop(k)
+ if k not in expected_ns["nested"]:
+ result_ns["nested"].pop(k)
+ # Don't use direct dict comparison - the diffs are too hard to debug
+ self.assertEqual(set(result_ns), set(expected_ns))
+ for k in result_ns:
+ actual = (k, result_ns[k])
+ expected = (k, expected_ns[k])
+ self.assertEqual(actual, expected)
+
+ def check_code_execution(self, create_namespace, expected_namespace):
+ """Check that an interface runs the example code correctly
+
+ First argument is a callable accepting the initial globals and
+ using them to create the actual namespace
+ Second argument is the expected result
+ """
+ sentinel = object()
+ expected_ns = expected_namespace.copy()
+ run_name = expected_ns["__name__"]
+ saved_argv0 = sys.argv[0]
+ saved_mod = sys.modules.get(run_name, sentinel)
+ # Check without initial globals
+ result_ns = create_namespace(None)
+ self.assertNamespaceMatches(result_ns, expected_ns)
+ self.assertIs(sys.argv[0], saved_argv0)
+ self.assertIs(sys.modules.get(run_name, sentinel), saved_mod)
+ # And then with initial globals
+ initial_ns = {"sentinel": sentinel}
+ expected_ns["sentinel"] = sentinel
+ result_ns = create_namespace(initial_ns)
+ self.assertIsNot(result_ns, initial_ns)
+ self.assertNamespaceMatches(result_ns, expected_ns)
+ self.assertIs(sys.argv[0], saved_argv0)
+ self.assertIs(sys.modules.get(run_name, sentinel), saved_mod)
+
+
+class ExecutionLayerTestCase(unittest.TestCase, CodeExecutionMixin):
"""Unit tests for runpy._run_code and runpy._run_module_code"""
- expected_result = ["Top level assignment", "Lower level reference"]
- test_source = (
- "# Check basic code execution\n"
- "result = ['Top level assignment']\n"
- "def f():\n"
- " result.append('Lower level reference')\n"
- "f()\n"
- "# Check the sys module\n"
- "import sys\n"
- "run_argv0 = sys.argv[0]\n"
- "run_name_in_sys_modules = __name__ in sys.modules\n"
- "if run_name_in_sys_modules:\n"
- " module_in_sys_modules = globals() is sys.modules[__name__].__dict__\n"
- "# Check nested operation\n"
- "import runpy\n"
- "nested = runpy._run_module_code('x=1\\n', mod_name='<run>')\n"
- )
-
def test_run_code(self):
- saved_argv0 = sys.argv[0]
- d = _run_code(self.test_source, {})
- self.assertEqual(d["result"], self.expected_result)
- self.assertIs(d["__name__"], None)
- self.assertIs(d["__file__"], None)
- self.assertIs(d["__cached__"], None)
- self.assertIs(d["__loader__"], None)
- self.assertIs(d["__package__"], None)
- self.assertIs(d["run_argv0"], saved_argv0)
- self.assertNotIn("run_name", d)
- self.assertIs(sys.argv[0], saved_argv0)
+ expected_ns = example_namespace.copy()
+ expected_ns.update({
+ "__loader__": None,
+ })
+ def create_ns(init_globals):
+ return _run_code(example_source, {}, init_globals)
+ self.check_code_execution(create_ns, expected_ns)
def test_run_module_code(self):
- initial = object()
- name = "<Nonsense>"
- file = "Some other nonsense"
- loader = "Now you're just being silly"
- package = '' # Treat as a top level module
- d1 = dict(initial=initial)
- saved_argv0 = sys.argv[0]
- d2 = _run_module_code(self.test_source,
- d1,
- name,
- file,
- loader,
- package)
- self.assertNotIn("result", d1)
- self.assertIs(d2["initial"], initial)
- self.assertEqual(d2["result"], self.expected_result)
- self.assertEqual(d2["nested"]["x"], 1)
- self.assertIs(d2["__name__"], name)
- self.assertTrue(d2["run_name_in_sys_modules"])
- self.assertTrue(d2["module_in_sys_modules"])
- self.assertIs(d2["__file__"], file)
- self.assertIs(d2["__cached__"], None)
- self.assertIs(d2["run_argv0"], file)
- self.assertIs(d2["__loader__"], loader)
- self.assertIs(d2["__package__"], package)
- self.assertIs(sys.argv[0], saved_argv0)
- self.assertNotIn(name, sys.modules)
+ mod_name = "<Nonsense>"
+ mod_fname = "Some other nonsense"
+ mod_loader = "Now you're just being silly"
+ mod_package = '' # Treat as a top level module
+ expected_ns = example_namespace.copy()
+ expected_ns.update({
+ "__name__": mod_name,
+ "__file__": mod_fname,
+ "__loader__": mod_loader,
+ "__package__": mod_package,
+ "run_argv0": mod_fname,
+ "run_name_in_sys_modules": True,
+ "module_in_sys_modules": True,
+ })
+ def create_ns(init_globals):
+ return _run_module_code(example_source,
+ init_globals,
+ mod_name,
+ mod_fname,
+ mod_loader,
+ mod_package)
+ self.check_code_execution(create_ns, expected_ns)
-class RunModuleTest(unittest.TestCase):
+class RunModuleTestCase(unittest.TestCase, CodeExecutionMixin):
"""Unit tests for runpy.run_module"""
def expect_import_error(self, mod_name):
@@ -110,7 +173,7 @@
self.expect_import_error("multiprocessing")
def test_library_module(self):
- run_module("runpy")
+ self.assertEqual(run_module("runpy")["__name__"], "runpy")
def _add_pkg_dir(self, pkg_dir):
os.mkdir(pkg_dir)
@@ -122,19 +185,19 @@
pkg_name = "__runpy_pkg__"
test_fname = mod_base+os.extsep+"py"
pkg_dir = sub_dir = tempfile.mkdtemp()
- if verbose: print(" Package tree in:", sub_dir)
+ if verbose > 1: print(" Package tree in:", sub_dir)
sys.path.insert(0, pkg_dir)
- if verbose: print(" Updated sys.path:", sys.path[0])
+ if verbose > 1: print(" Updated sys.path:", sys.path[0])
for i in range(depth):
sub_dir = os.path.join(sub_dir, pkg_name)
pkg_fname = self._add_pkg_dir(sub_dir)
- if verbose: print(" Next level in:", sub_dir)
- if verbose: print(" Created:", pkg_fname)
+ if verbose > 1: print(" Next level in:", sub_dir)
+ if verbose > 1: print(" Created:", pkg_fname)
mod_fname = os.path.join(sub_dir, test_fname)
mod_file = open(mod_fname, "w")
mod_file.write(source)
mod_file.close()
- if verbose: print(" Created:", mod_fname)
+ if verbose > 1: print(" Created:", mod_fname)
mod_name = (pkg_name+".")*depth + mod_base
return pkg_dir, mod_fname, mod_name
@@ -142,77 +205,102 @@
for entry in list(sys.modules):
if entry.startswith("__runpy_pkg__"):
del sys.modules[entry]
- if verbose: print(" Removed sys.modules entries")
+ if verbose > 1: print(" Removed sys.modules entries")
del sys.path[0]
- if verbose: print(" Removed sys.path entry")
+ if verbose > 1: print(" Removed sys.path entry")
for root, dirs, files in os.walk(top, topdown=False):
for name in files:
try:
os.remove(os.path.join(root, name))
except OSError as ex:
- if verbose: print(ex) # Persist with cleaning up
+ if verbose > 1: print(ex) # Persist with cleaning up
for name in dirs:
fullname = os.path.join(root, name)
try:
os.rmdir(fullname)
except OSError as ex:
- if verbose: print(ex) # Persist with cleaning up
+ if verbose > 1: print(ex) # Persist with cleaning up
try:
os.rmdir(top)
- if verbose: print(" Removed package tree")
+ if verbose > 1: print(" Removed package tree")
except OSError as ex:
- if verbose: print(ex) # Persist with cleaning up
+ if verbose > 1: print(ex) # Persist with cleaning up
- def _check_module(self, depth):
+ def _fix_ns_for_legacy_pyc(self, ns, alter_sys):
+ char_to_add = "c" if __debug__ else "o"
+ ns["__file__"] += char_to_add
+ if alter_sys:
+ ns["run_argv0"] += char_to_add
+
+
+ def _check_module(self, depth, alter_sys=False):
pkg_dir, mod_fname, mod_name = (
- self._make_pkg("x=1\n", depth))
+ self._make_pkg(example_source, depth))
forget(mod_name)
+ expected_ns = example_namespace.copy()
+ expected_ns.update({
+ "__name__": mod_name,
+ "__file__": mod_fname,
+ "__package__": mod_name.rpartition(".")[0],
+ })
+ if alter_sys:
+ expected_ns.update({
+ "run_argv0": mod_fname,
+ "run_name_in_sys_modules": True,
+ "module_in_sys_modules": True,
+ })
+ def create_ns(init_globals):
+ return run_module(mod_name, init_globals, alter_sys=alter_sys)
try:
- if verbose: print("Running from source:", mod_name)
- d1 = run_module(mod_name) # Read from source
- self.assertIn("x", d1)
- self.assertEqual(d1["x"], 1)
- del d1 # Ensure __loader__ entry doesn't keep file open
+ if verbose > 1: print("Running from source:", mod_name)
+ self.check_code_execution(create_ns, expected_ns)
importlib.invalidate_caches()
__import__(mod_name)
os.remove(mod_fname)
make_legacy_pyc(mod_fname)
unload(mod_name) # In case loader caches paths
- if verbose: print("Running from compiled:", mod_name)
importlib.invalidate_caches()
- d2 = run_module(mod_name) # Read from bytecode
- self.assertIn("x", d2)
- self.assertEqual(d2["x"], 1)
- del d2 # Ensure __loader__ entry doesn't keep file open
+ if verbose > 1: print("Running from compiled:", mod_name)
+ self._fix_ns_for_legacy_pyc(expected_ns, alter_sys)
+ self.check_code_execution(create_ns, expected_ns)
finally:
self._del_pkg(pkg_dir, depth, mod_name)
- if verbose: print("Module executed successfully")
+ if verbose > 1: print("Module executed successfully")
- def _check_package(self, depth):
+ def _check_package(self, depth, alter_sys=False):
pkg_dir, mod_fname, mod_name = (
- self._make_pkg("x=1\n", depth, "__main__"))
- pkg_name, _, _ = mod_name.rpartition(".")
+ self._make_pkg(example_source, depth, "__main__"))
+ pkg_name = mod_name.rpartition(".")[0]
forget(mod_name)
+ expected_ns = example_namespace.copy()
+ expected_ns.update({
+ "__name__": mod_name,
+ "__file__": mod_fname,
+ "__package__": pkg_name,
+ })
+ if alter_sys:
+ expected_ns.update({
+ "run_argv0": mod_fname,
+ "run_name_in_sys_modules": True,
+ "module_in_sys_modules": True,
+ })
+ def create_ns(init_globals):
+ return run_module(pkg_name, init_globals, alter_sys=alter_sys)
try:
- if verbose: print("Running from source:", pkg_name)
- d1 = run_module(pkg_name) # Read from source
- self.assertIn("x", d1)
- self.assertTrue(d1["x"] == 1)
- del d1 # Ensure __loader__ entry doesn't keep file open
+ if verbose > 1: print("Running from source:", pkg_name)
+ self.check_code_execution(create_ns, expected_ns)
importlib.invalidate_caches()
__import__(mod_name)
os.remove(mod_fname)
make_legacy_pyc(mod_fname)
unload(mod_name) # In case loader caches paths
- if verbose: print("Running from compiled:", pkg_name)
+ if verbose > 1: print("Running from compiled:", pkg_name)
importlib.invalidate_caches()
- d2 = run_module(pkg_name) # Read from bytecode
- self.assertIn("x", d2)
- self.assertTrue(d2["x"] == 1)
- del d2 # Ensure __loader__ entry doesn't keep file open
+ self._fix_ns_for_legacy_pyc(expected_ns, alter_sys)
+ self.check_code_execution(create_ns, expected_ns)
finally:
self._del_pkg(pkg_dir, depth, pkg_name)
- if verbose: print("Package executed successfully")
+ if verbose > 1: print("Package executed successfully")
def _add_relative_modules(self, base_dir, source, depth):
if depth <= 1:
@@ -225,17 +313,17 @@
# Add sibling module
sibling_fname = os.path.join(module_dir, "sibling.py")
create_empty_file(sibling_fname)
- if verbose: print(" Added sibling module:", sibling_fname)
+ if verbose > 1: print(" Added sibling module:", sibling_fname)
# Add nephew module
uncle_dir = os.path.join(parent_dir, "uncle")
self._add_pkg_dir(uncle_dir)
- if verbose: print(" Added uncle package:", uncle_dir)
+ if verbose > 1: print(" Added uncle package:", uncle_dir)
cousin_dir = os.path.join(uncle_dir, "cousin")
self._add_pkg_dir(cousin_dir)
- if verbose: print(" Added cousin package:", cousin_dir)
+ if verbose > 1: print(" Added cousin package:", cousin_dir)
nephew_fname = os.path.join(cousin_dir, "nephew.py")
create_empty_file(nephew_fname)
- if verbose: print(" Added nephew module:", nephew_fname)
+ if verbose > 1: print(" Added nephew module:", nephew_fname)
def _check_relative_imports(self, depth, run_name=None):
contents = r"""\
@@ -245,13 +333,17 @@
"""
pkg_dir, mod_fname, mod_name = (
self._make_pkg(contents, depth))
+ if run_name is None:
+ expected_name = mod_name
+ else:
+ expected_name = run_name
try:
self._add_relative_modules(pkg_dir, contents, depth)
pkg_name = mod_name.rpartition('.')[0]
- if verbose: print("Running from source:", mod_name)
+ if verbose > 1: print("Running from source:", mod_name)
d1 = run_module(mod_name, run_name=run_name) # Read from source
- self.assertIn("__package__", d1)
- self.assertTrue(d1["__package__"] == pkg_name)
+ self.assertEqual(d1["__name__"], expected_name)
+ self.assertEqual(d1["__package__"], pkg_name)
self.assertIn("sibling", d1)
self.assertIn("nephew", d1)
del d1 # Ensure __loader__ entry doesn't keep file open
@@ -260,78 +352,98 @@
os.remove(mod_fname)
make_legacy_pyc(mod_fname)
unload(mod_name) # In case the loader caches paths
- if verbose: print("Running from compiled:", mod_name)
+ if verbose > 1: print("Running from compiled:", mod_name)
importlib.invalidate_caches()
d2 = run_module(mod_name, run_name=run_name) # Read from bytecode
- self.assertIn("__package__", d2)
- self.assertTrue(d2["__package__"] == pkg_name)
+ self.assertEqual(d2["__name__"], expected_name)
+ self.assertEqual(d2["__package__"], pkg_name)
self.assertIn("sibling", d2)
self.assertIn("nephew", d2)
del d2 # Ensure __loader__ entry doesn't keep file open
finally:
self._del_pkg(pkg_dir, depth, mod_name)
- if verbose: print("Module executed successfully")
+ if verbose > 1: print("Module executed successfully")
def test_run_module(self):
for depth in range(4):
- if verbose: print("Testing package depth:", depth)
+ if verbose > 1: print("Testing package depth:", depth)
self._check_module(depth)
def test_run_package(self):
for depth in range(1, 4):
- if verbose: print("Testing package depth:", depth)
+ if verbose > 1: print("Testing package depth:", depth)
self._check_package(depth)
+ def test_run_module_alter_sys(self):
+ for depth in range(4):
+ if verbose > 1: print("Testing package depth:", depth)
+ self._check_module(depth, alter_sys=True)
+
+ def test_run_package_alter_sys(self):
+ for depth in range(1, 4):
+ if verbose > 1: print("Testing package depth:", depth)
+ self._check_package(depth, alter_sys=True)
+
def test_explicit_relative_import(self):
for depth in range(2, 5):
- if verbose: print("Testing relative imports at depth:", depth)
+ if verbose > 1: print("Testing relative imports at depth:", depth)
self._check_relative_imports(depth)
def test_main_relative_import(self):
for depth in range(2, 5):
- if verbose: print("Testing main relative imports at depth:", depth)
+ if verbose > 1: print("Testing main relative imports at depth:", depth)
self._check_relative_imports(depth, "__main__")
+ def test_run_name(self):
+ depth = 1
+ run_name = "And now for something completely different"
+ pkg_dir, mod_fname, mod_name = (
+ self._make_pkg(example_source, depth))
+ forget(mod_name)
+ expected_ns = example_namespace.copy()
+ expected_ns.update({
+ "__name__": run_name,
+ "__file__": mod_fname,
+ "__package__": mod_name.rpartition(".")[0],
+ })
+ def create_ns(init_globals):
+ return run_module(mod_name, init_globals, run_name)
+ try:
+ self.check_code_execution(create_ns, expected_ns)
+ finally:
+ self._del_pkg(pkg_dir, depth, mod_name)
-class RunPathTest(unittest.TestCase):
+
+class RunPathTestCase(unittest.TestCase, CodeExecutionMixin):
"""Unit tests for runpy.run_path"""
- # Based on corresponding tests in test_cmd_line_script
-
- test_source = """\
-# Script may be run with optimisation enabled, so don't rely on assert
-# statements being executed
-def assertEqual(lhs, rhs):
- if lhs != rhs:
- raise AssertionError('%r != %r' % (lhs, rhs))
-def assertIs(lhs, rhs):
- if lhs is not rhs:
- raise AssertionError('%r is not %r' % (lhs, rhs))
-# Check basic code execution
-result = ['Top level assignment']
-def f():
- result.append('Lower level reference')
-f()
-assertEqual(result, ['Top level assignment', 'Lower level reference'])
-# Check the sys module
-import sys
-assertIs(globals(), sys.modules[__name__].__dict__)
-argv0 = sys.argv[0]
-"""
def _make_test_script(self, script_dir, script_basename, source=None):
if source is None:
- source = self.test_source
+ source = example_source
return make_script(script_dir, script_basename, source)
def _check_script(self, script_name, expected_name, expected_file,
- expected_argv0, expected_package):
- result = run_path(script_name)
- self.assertEqual(result["__name__"], expected_name)
- self.assertEqual(result["__file__"], expected_file)
- self.assertEqual(result["__cached__"], None)
- self.assertIn("argv0", result)
- self.assertEqual(result["argv0"], expected_argv0)
- self.assertEqual(result["__package__"], expected_package)
+ expected_argv0):
+ # First check is without run_name
+ def create_ns(init_globals):
+ return run_path(script_name, init_globals)
+ expected_ns = example_namespace.copy()
+ expected_ns.update({
+ "__name__": expected_name,
+ "__file__": expected_file,
+ "__package__": "",
+ "run_argv0": expected_argv0,
+ "run_name_in_sys_modules": True,
+ "module_in_sys_modules": True,
+ })
+ self.check_code_execution(create_ns, expected_ns)
+ # Second check makes sure run_name works in all cases
+ run_name = "prove.issue15230.is.fixed"
+ def create_ns(init_globals):
+ return run_path(script_name, init_globals, run_name)
+ expected_ns["__name__"] = run_name
+ expected_ns["__package__"] = run_name.rpartition(".")[0]
+ self.check_code_execution(create_ns, expected_ns)
def _check_import_error(self, script_name, msg):
msg = re.escape(msg)
@@ -342,7 +454,7 @@
mod_name = 'script'
script_name = self._make_test_script(script_dir, mod_name)
self._check_script(script_name, "<run_path>", script_name,
- script_name, None)
+ script_name)
def test_script_compiled(self):
with temp_dir() as script_dir:
@@ -351,14 +463,14 @@
compiled_name = py_compile.compile(script_name, doraise=True)
os.remove(script_name)
self._check_script(compiled_name, "<run_path>", compiled_name,
- compiled_name, None)
+ compiled_name)
def test_directory(self):
with temp_dir() as script_dir:
mod_name = '__main__'
script_name = self._make_test_script(script_dir, mod_name)
self._check_script(script_dir, "<run_path>", script_name,
- script_dir, '')
+ script_dir)
def test_directory_compiled(self):
with temp_dir() as script_dir:
@@ -368,7 +480,7 @@
os.remove(script_name)
legacy_pyc = make_legacy_pyc(script_name)
self._check_script(script_dir, "<run_path>", legacy_pyc,
- script_dir, '')
+ script_dir)
def test_directory_error(self):
with temp_dir() as script_dir:
@@ -382,7 +494,7 @@
mod_name = '__main__'
script_name = self._make_test_script(script_dir, mod_name)
zip_name, fname = make_zip_script(script_dir, 'test_zip', script_name)
- self._check_script(zip_name, "<run_path>", fname, zip_name, '')
+ self._check_script(zip_name, "<run_path>", fname, zip_name)
def test_zipfile_compiled(self):
with temp_dir() as script_dir:
@@ -391,7 +503,7 @@
compiled_name = py_compile.compile(script_name, doraise=True)
zip_name, fname = make_zip_script(script_dir, 'test_zip',
compiled_name)
- self._check_script(zip_name, "<run_path>", fname, zip_name, '')
+ self._check_script(zip_name, "<run_path>", fname, zip_name)
def test_zipfile_error(self):
with temp_dir() as script_dir:
@@ -426,9 +538,9 @@
def test_main():
run_unittest(
- RunModuleCodeTest,
- RunModuleTest,
- RunPathTest
+ ExecutionLayerTestCase,
+ RunModuleTestCase,
+ RunPathTestCase
)
if __name__ == "__main__":
diff --git a/Misc/NEWS b/Misc/NEWS
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -35,6 +35,9 @@
Library
-------
+- Issue #15230: runpy.run_path now correctly sets __package__ as described
+ in the documentation
+
- Issue #15315: Support VS 2010 in distutils cygwincompiler.
- Issue #15294: Fix a regression in pkgutil.extend_path()'s handling of
@@ -133,6 +136,8 @@
Tests
-----
+- Issue #15230: Adopted a more systematic approach in the runpy tests
+
- Issue #15300: Ensure the temporary test working directories are in the same
parent folder when running tests in multiprocess mode from a Python build.
Patch by Chris Jerdonek.
--
Repository URL: http://hg.python.org/cpython
More information about the Python-checkins
mailing list