def test_module_with_large_stack(self, module="longlist"):
        # Regression test for http://bugs.python.org/issue561858.
        filename = module + ".py"

        # 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("]")

        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)
        finally:
            unlink(filename)

        # Need to be able to load from current dir.
        sys.path.append("")
        importlib.invalidate_caches()

        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 run_test(self, test, create=None, *, compile_=None, unlink=None):
        """Test the finding of 'test' with the creation of modules listed in
        'create'.

        Any names listed in 'compile_' are byte-compiled. Modules
        listed in 'unlink' have their source files deleted.

        """
        if create is None:
            create = {test}
        with source_util.create_modules(*create) as mapping:
            if compile_:
                for name in compile_:
                    py_compile.compile(mapping[name])
            if unlink:
                for name in unlink:
                    os.unlink(mapping[name])
                    try:
                        make_legacy_pyc(mapping[name])
                    except OSError as error:
                        # Some tests do not set compile_=True so the source
                        # module will not get compiled and there will be no
                        # PEP 3147 pyc file to rename.
                        if error.errno != errno.ENOENT:
                            raise
            loader = self.import_(mapping['.root'], test)
            self.assertTrue(hasattr(loader, 'load_module'))
            return loader

 def _check_package(self, depth):
     pkg_dir, mod_fname, mod_name = self._make_pkg("x=1\n", depth, "__main__")
     pkg_name, _, _ = mod_name.rpartition(".")
     forget(mod_name)
     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
         __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
     finally:
         self._del_pkg(pkg_dir, depth, pkg_name)
     if verbose:
         print("Package executed successfully")

 def _check_package(self, depth, alter_sys=False):
     pkg_dir, mod_fname, mod_name = (
            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 > 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 > 1: print("Running from compiled:", pkg_name)
         importlib.invalidate_caches()
         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 > 1: print("Package executed successfully")

    def _check_relative_imports(self, depth, run_name=None):
        contents = r"""\
from __future__ import absolute_import
from . import sibling
from ..uncle.cousin import nephew
"""
        pkg_dir, mod_fname, mod_name = (
               self._make_pkg(contents, depth))
        try:
            self._add_relative_modules(pkg_dir, contents, depth)
            pkg_name = mod_name.rpartition('.')[0]
            if verbose: 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.assertIn("sibling", d1)
            self.assertIn("nephew", d1)
            del d1 # Ensure __loader__ entry doesn't keep file open
            __import__(mod_name)
            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)
            d2 = run_module(mod_name, run_name=run_name) # Read from bytecode
            self.assertIn("__package__", d2)
            self.assertTrue(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")

    def test_module_with_large_stack(self, module='longlist'):
        # Regression test for http://bugs.python.org/issue561858.
        filename = module + '.py'

        # 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(']')

        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)
        finally:
            unlink(filename)

        # Need to be able to load from current dir.
        sys.path.append('')

        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_script_compiled(self):
     with temp_dir() as script_dir:
         script_name = _make_test_script(script_dir, "script")
         py_compile.compile(script_name, doraise=True)
         os.remove(script_name)
         pyc_file = support.make_legacy_pyc(script_name)
         self._check_script(pyc_file, pyc_file, pyc_file, script_dir, None, importlib.machinery.SourcelessFileLoader)

 def test_script_compiled(self):
     with temp_dir() as script_dir:
         script_name = _make_test_script(script_dir, 'script')
         py_compile.compile(script_name, doraise=True)
         os.remove(script_name)
         pyc_file = support.make_legacy_pyc(script_name)
         self._check_script(pyc_file)

 def test_directory_compiled(self):
     with temp_dir() as script_dir:
         mod_name = "__main__"
         script_name = self._make_test_script(script_dir, mod_name)
         compiled_name = py_compile.compile(script_name, doraise=True)
         os.remove(script_name)
         legacy_pyc = make_legacy_pyc(script_name)
         self._check_script(script_dir, "<run_path>", legacy_pyc, script_dir, "")

 def test_module_without_source(self):
     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, pyc_file)
     self.assertEqual(mod.code_filename, target)
     self.assertEqual(mod.func_filename, target)

 def test_directory_compiled(self):
     source = self.main_in_children_source
     with temp_dir() as script_dir:
         script_name = _make_test_script(script_dir, '__main__',
                                         source=source)
         py_compile.compile(script_name, doraise=True)
         os.remove(script_name)
         pyc_file = support.make_legacy_pyc(script_name)
         self._check_script(script_dir)

 def test_directory_compiled(self):
     with support.temp_dir() as script_dir:
         script_name = _make_test_script(script_dir, '__main__')
         py_compile.compile(script_name, doraise=True)
         os.remove(script_name)
         pyc_file = support.make_legacy_pyc(script_name)
         self._check_script(script_dir, pyc_file, script_dir,
                            script_dir, '',
                            importlib.machinery.SourcelessFileLoader)

 def test_script_compiled(self):
     with temp_dir() as script_dir:
         script_name = _make_test_script(script_dir, 'script')
         py_compile.compile(script_name, doraise=True)
         os.remove(script_name)
         pyc_file = support.make_legacy_pyc(script_name)
         package = '' if support.check_impl_detail(pypy=True) else None
         self._check_script(pyc_file, pyc_file,
                            pyc_file, script_dir, package,
                            importlib.machinery.SourcelessFileLoader)

 def test_directory_compiled(self):
     with temp_dir() as script_dir:
         mod_name = '__main__'
         script_name = self._make_test_script(script_dir, mod_name)
         compiled_name = py_compile.compile(script_name, doraise=True)
         os.remove(script_name)
         if not sys.dont_write_bytecode:
             legacy_pyc = make_legacy_pyc(script_name)
             self._check_script(script_dir, "<run_path>", legacy_pyc,
                                script_dir, mod_name=mod_name)

 def test_package_compiled(self):
     with temp_dir() as script_dir:
         pkg_dir = os.path.join(script_dir, 'test_pkg')
         make_pkg(pkg_dir)
         script_name = _make_test_script(pkg_dir, '__main__')
         compiled_name = py_compile.compile(script_name, doraise=True)
         os.remove(script_name)
         pyc_file = support.make_legacy_pyc(script_name)
         launch_name = _make_launch_script(script_dir, 'launch', 'test_pkg')
         self._check_script(launch_name, pyc_file,
                            pyc_file, script_dir, 'test_pkg')

    def _check_relative_imports(self, depth, run_name=None):
        contents = r"""\
from __future__ import absolute_import
from . import sibling
from ..uncle.cousin import nephew
"""
        pkg_dir, mod_fname, mod_name, mod_spec = 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 > 1:
                print("Running from source:", mod_name)
            d1 = run_module(mod_name, run_name=run_name)  # Read from source
            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
            importlib.invalidate_caches()
            __import__(mod_name)
            os.remove(mod_fname)
            if not sys.dont_write_bytecode:
                make_legacy_pyc(mod_fname)
                unload(mod_name)  # In case the loader caches paths
                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.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)
        if verbose > 1:
            print("Module executed successfully")

 def test_package_compiled(self):
     with temp_dir() as script_dir:
         pkg_dir = os.path.join(script_dir, "test_pkg")
         make_pkg(pkg_dir)
         script_name = _make_test_script(pkg_dir, "__main__")
         compiled_name = py_compile.compile(script_name, doraise=True)
         os.remove(script_name)
         pyc_file = support.make_legacy_pyc(script_name)
         launch_name = _make_launch_script(script_dir, "launch", "test_pkg")
         self._check_script(
             launch_name, pyc_file, pyc_file, script_dir, "test_pkg", importlib.machinery.SourcelessFileLoader
         )

 def test_package_compiled(self):
     with support.temp_dir() as script_dir:
         pkg_dir = os.path.join(script_dir, 'test_pkg')
         make_pkg(pkg_dir)
         script_name = _make_test_script(pkg_dir, '__main__')
         compiled_name = py_compile.compile(script_name, doraise=True)
         os.remove(script_name)
         pyc_file = support.make_legacy_pyc(script_name)
         self._check_script(["-m", "test_pkg"], pyc_file,
                            pyc_file, script_dir, 'test_pkg',
                            importlib.machinery.SourcelessFileLoader,
                            cwd=script_dir)

    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.curdir)
        try:
            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 _check_module(self, depth, alter_sys=False, *, namespace=False, parent_namespaces=False):
        pkg_dir, mod_fname, mod_name, mod_spec = self._make_pkg(
            example_source, depth, namespace=namespace, parent_namespaces=parent_namespaces
        )
        forget(mod_name)
        expected_ns = example_namespace.copy()
        expected_ns.update(
            {
                "__name__": mod_name,
                "__file__": mod_fname,
                "__cached__": mod_spec.cached,
                "__package__": mod_name.rpartition(".")[0],
                "__spec__": mod_spec,
            }
        )
        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 > 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)
            if not sys.dont_write_bytecode:
                make_legacy_pyc(mod_fname)
                unload(mod_name)  # In case loader caches paths
                importlib.invalidate_caches()
                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)
        if verbose > 1:
            print("Module executed successfully")