def test_zipfile(self):
     with temp_dir() as script_dir:
         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,
                            mod_name=mod_name, check_loader=False)

    def test_doctest_main_issue4197(self):
        test_src = textwrap.dedent("""\
                    class Test:
                        ">>> 'line 2'"
                        pass

                    import doctest
                    doctest.testmod()
                    """)
        pattern = 'File "%s", line 2, in %s'
        with test.support.temp_dir() as d:
            script_name = make_script(d, 'script', test_src)
            rc, out, err = assert_python_ok(script_name)
            expected = pattern % (script_name, "__main__.Test")
            if verbose:
                print ("Expected line", expected)
                print ("Got stdout:")
                print (ascii(out))
            self.assertIn(expected.encode('utf-8'), out)
            zip_name, run_name = make_zip_script(d, "test_zip",
                                                script_name, '__main__.py')
            rc, out, err = assert_python_ok(zip_name)
            expected = pattern % (run_name, "__main__.Test")
            if verbose:
                print ("Expected line", expected)
                print ("Got stdout:")
                print (ascii(out))
            self.assertIn(expected.encode('utf-8'), out)

 def test_zipfile(self):
     source = self.main_in_children_source
     with support.temp_dir() as script_dir:
         script_name = _make_test_script(script_dir, '__main__',
                                         source=source)
         zip_name, run_name = make_zip_script(script_dir, 'test_zip', script_name)
         self._check_script(zip_name)

 def test_zipfile_compiled(self):
     with support.temp_dir() as script_dir:
         script_name = _make_test_script(script_dir, '__main__')
         compiled_name = py_compile.compile(script_name, doraise=True)
         zip_name, run_name = make_zip_script(script_dir, 'test_zip', compiled_name)
         self._check_script(zip_name, run_name, zip_name, zip_name, '',
                            zipimport.zipimporter)

 def test_zipfile_error(self):
     with temp_dir() as script_dir:
         mod_name = 'not_main'
         script_name = self._make_test_script(script_dir, mod_name)
         zip_name, fname = make_zip_script(script_dir, 'test_zip', script_name)
         msg = "can't find '__main__' module in %r" % zip_name
         self._check_import_error(zip_name, msg)

 def test_zipfile_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)
         zip_name, fname = make_zip_script(script_dir, "test_zip", compiled_name)
         self._check_script(zip_name, "<run_path>", fname, zip_name, mod_name=mod_name, check_loader=False)

 def test_zipfile_compiled(self):
     source = self.main_in_children_source
     with support.temp_dir() as script_dir:
         script_name = _make_test_script(script_dir, '__main__',
                                         source=source)
         compiled_name = py_compile.compile(script_name, doraise=True)
         zip_name, run_name = make_zip_script(script_dir, 'test_zip', compiled_name)
         self._check_script(zip_name)

 def test_main_recursion_error(self):
     with temp_dir() as script_dir, temp_dir() as dummy_dir:
         mod_name = "__main__"
         source = ("import runpy\n" "runpy.run_path(%r)\n") % dummy_dir
         script_name = self._make_test_script(script_dir, mod_name, source)
         zip_name, fname = make_zip_script(script_dir, "test_zip", script_name)
         msg = "recursion depth exceeded"
         self.assertRaisesRegex(RecursionError, msg, run_path, zip_name)

 def test_zipfile_compiled_unchecked_hash(self):
     with support.temp_dir() as script_dir:
         script_name = _make_test_script(script_dir, '__main__')
         compiled_name = py_compile.compile(
             script_name, doraise=True,
             invalidation_mode=py_compile.PycInvalidationMode.UNCHECKED_HASH)
         zip_name, run_name = make_zip_script(script_dir, 'test_zip', compiled_name)
         self._check_script(zip_name, run_name, zip_name, zip_name, '',
                            zipimport.zipimporter)

 def test_zipfile_compiled_timestamp(self):
     with support.temp_dir() as script_dir:
         script_name = _make_test_script(script_dir, '__main__')
         compiled_name = py_compile.compile(
             script_name, doraise=True,
             invalidation_mode=py_compile.PycInvalidationMode.TIMESTAMP)
         zip_name, run_name = make_zip_script(script_dir, 'test_zip', compiled_name)
         self._check_script(zip_name, run_name, zip_name, zip_name, '',
                            zipimport.zipimporter)

 def test_inspect_getsource_issue4223(self):
     test_src = "def foo(): pass\n"
     with test.support.temp_dir() as d:
         init_name = make_script(d, '__init__', test_src)
         name_in_zip = os.path.join('zip_pkg',
                                    os.path.basename(init_name))
         zip_name, run_name = make_zip_script(d, 'test_zip',
                                             init_name, name_in_zip)
         os.remove(init_name)
         sys.path.insert(0, zip_name)
         import zip_pkg
         try:
             self.assertEqual(inspect.getsource(zip_pkg.foo), test_src)
         finally:
             del sys.modules["zip_pkg"]

    def test_pdb_issue4201(self):
        test_src = textwrap.dedent("""\
                    def f():
                        pass

                    import pdb
                    pdb.Pdb(nosigint=True).runcall(f)
                    """)
        with test.support.temp_dir() as d:
            script_name = make_script(d, 'script', test_src)
            p = spawn_python(script_name)
            p.stdin.write(b'l\n')
            data = kill_python(p)
            # bdb/pdb applies normcase to its filename before displaying
            self.assertIn(os.path.normcase(script_name.encode('utf-8')), data)
            zip_name, run_name = make_zip_script(d, "test_zip",
                                                script_name, '__main__.py')
            p = spawn_python(zip_name)
            p.stdin.write(b'l\n')
            data = kill_python(p)
            # bdb/pdb applies normcase to its filename before displaying
            self.assertIn(os.path.normcase(run_name.encode('utf-8')), data)

    def test_doctest_issue4197(self):
        # To avoid having to keep two copies of the doctest module's
        # unit tests in sync, this test works by taking the source of
        # test_doctest itself, rewriting it a bit to cope with a new
        # location, and then throwing it in a zip file to make sure
        # everything still works correctly
        test_src = inspect.getsource(test_doctest)
        test_src = test_src.replace(
                         "from test import test_doctest",
                         "import test_zipped_doctest as test_doctest")
        test_src = test_src.replace("test.test_doctest",
                                    "test_zipped_doctest")
        test_src = test_src.replace("test.sample_doctest",
                                    "sample_zipped_doctest")
        # The sample doctest files rewritten to include in the zipped version.
        sample_sources = {}
        for mod in [sample_doctest, sample_doctest_no_doctests,
                    sample_doctest_no_docstrings]:
            src = inspect.getsource(mod)
            src = src.replace("test.test_doctest", "test_zipped_doctest")
            # Rewrite the module name so that, for example,
            # "test.sample_doctest" becomes "sample_zipped_doctest".
            mod_name = mod.__name__.split(".")[-1]
            mod_name = mod_name.replace("sample_", "sample_zipped_")
            sample_sources[mod_name] = src

        with test.support.temp_dir() as d:
            script_name = make_script(d, 'test_zipped_doctest',
                                            test_src)
            zip_name, run_name = make_zip_script(d, 'test_zip',
                                                script_name)
            z = zipfile.ZipFile(zip_name, 'a')
            for mod_name, src in sample_sources.items():
                z.writestr(mod_name + ".py", src)
            z.close()
            if verbose:
                zip_file = zipfile.ZipFile(zip_name, 'r')
                print ('Contents of %r:' % zip_name)
                zip_file.printdir()
                zip_file.close()
            os.remove(script_name)
            sys.path.insert(0, zip_name)
            import test_zipped_doctest
            try:
                # Some of the doc tests depend on the colocated text files
                # which aren't available to the zipped version (the doctest
                # module currently requires real filenames for non-embedded
                # tests). So we're forced to be selective about which tests
                # to run.
                # doctest could really use some APIs which take a text
                # string or a file object instead of a filename...
                known_good_tests = [
                    test_zipped_doctest.SampleClass,
                    test_zipped_doctest.SampleClass.NestedClass,
                    test_zipped_doctest.SampleClass.NestedClass.__init__,
                    test_zipped_doctest.SampleClass.__init__,
                    test_zipped_doctest.SampleClass.a_classmethod,
                    test_zipped_doctest.SampleClass.a_property,
                    test_zipped_doctest.SampleClass.a_staticmethod,
                    test_zipped_doctest.SampleClass.double,
                    test_zipped_doctest.SampleClass.get,
                    test_zipped_doctest.SampleNewStyleClass,
                    test_zipped_doctest.SampleNewStyleClass.__init__,
                    test_zipped_doctest.SampleNewStyleClass.double,
                    test_zipped_doctest.SampleNewStyleClass.get,
                    test_zipped_doctest.sample_func,
                    test_zipped_doctest.test_DocTest,
                    test_zipped_doctest.test_DocTestParser,
                    test_zipped_doctest.test_DocTestRunner.basics,
                    test_zipped_doctest.test_DocTestRunner.exceptions,
                    test_zipped_doctest.test_DocTestRunner.option_directives,
                    test_zipped_doctest.test_DocTestRunner.optionflags,
                    test_zipped_doctest.test_DocTestRunner.verbose_flag,
                    test_zipped_doctest.test_Example,
                    test_zipped_doctest.test_debug,
                    test_zipped_doctest.test_testsource,
                    test_zipped_doctest.test_trailing_space_in_test,
                    test_zipped_doctest.test_DocTestSuite,
                    test_zipped_doctest.test_DocTestFinder,
                ]
                # These tests are the ones which need access
                # to the data files, so we don't run them
                fail_due_to_missing_data_files = [
                    test_zipped_doctest.test_DocFileSuite,
                    test_zipped_doctest.test_testfile,
                    test_zipped_doctest.test_unittest_reportflags,
                ]

                for obj in known_good_tests:
                    _run_object_doctest(obj, test_zipped_doctest)
            finally:
                del sys.modules["test_zipped_doctest"]

 def test_zipfile_error(self):
     with support.temp_dir() as script_dir:
         script_name = _make_test_script(script_dir, 'not_main')
         zip_name, run_name = make_zip_script(script_dir, 'test_zip', script_name)
         msg = "can't find '__main__' module in %r" % zip_name
         self._check_import_error(zip_name, msg)

 def test_zipfile(self):
     with support.temp_dir() as script_dir:
         script_name = _make_test_script(script_dir, '__main__')
         zip_name, run_name = make_zip_script(script_dir, 'test_zip', script_name)
         self._check_script(zip_name, run_name, zip_name, zip_name, '',
                            zipimport.zipimporter)

 def test_zipfile(self):
     with support.temp_dir() as script_dir:
         script_name = _make_test_script(script_dir, "__main__")
         zip_name, run_name = make_zip_script(script_dir, "test_zip", script_name)
         self._check_script(zip_name, run_name, zip_name, zip_name, "", zipimport.zipimporter)