diff --git a/Lib/runpy.py b/Lib/runpy.py
index 31e5e55..7cb4668 100644
--- a/Lib/runpy.py
+++ b/Lib/runpy.py
@@ -68,6 +68,7 @@
     run_globals.update(__name__ = mod_name,
                        __file__ = mod_fname,
                        __cached__ = None,
+                       __doc__ = None,
                        __loader__ = mod_loader,
                        __package__ = pkg_name)
     exec(code, run_globals)
@@ -242,12 +243,14 @@
     """
     if run_name is None:
         run_name = "<run_path>"
+    pkg_name = run_name.rpartition(".")[0]
     importer = _get_importer(path_name)
     if isinstance(importer, 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
@@ -266,7 +269,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
index 7ffb6af..85eb76f 100644
--- a/Lib/test/test_runpy.py
+++ b/Lib/test/test_runpy.py
@@ -10,80 +10,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
 
-class RunModuleCodeTest(unittest.TestCase):
+# 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>')
+"""
+
+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):
@@ -107,7 +170,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)
@@ -120,19 +183,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
 
@@ -140,73 +203,98 @@
         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)
             __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)
-            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)
             __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)
-            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
+            if verbose > 1: print("Running from compiled:", pkg_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, 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:
@@ -220,18 +308,18 @@
         sibling_fname = os.path.join(module_dir, "sibling.py")
         sibling_file = open(sibling_fname, "w")
         sibling_file.close()
-        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")
         nephew_file = open(nephew_fname, "w")
         nephew_file.close()
-        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"""\
@@ -241,13 +329,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
@@ -255,77 +347,97 @@
             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)
             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)
@@ -336,7 +448,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:
@@ -345,14 +457,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:
@@ -362,7 +474,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:
@@ -376,7 +488,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:
@@ -385,7 +497,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:
@@ -419,9 +531,9 @@
 
 def test_main():
     run_unittest(
-                 RunModuleCodeTest,
-                 RunModuleTest,
-                 RunPathTest
+                 ExecutionLayerTestCase,
+                 RunModuleTestCase,
+                 RunPathTestCase
                  )
 
 if __name__ == "__main__":
diff --git a/Misc/NEWS b/Misc/NEWS
index 34a34c0..1b2f4f4 100644
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -87,6 +87,9 @@
 Library
 -------
 
+- Issue #15230: runpy.run_path now correctly sets __package__ as described
+  in the documentation
+
 - Issue #14990: Correctly fail with SyntaxError on invalid encoding
   declaration.
 
@@ -341,6 +344,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.