def test_zipfile_compiled(self):
     with 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_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 temp_dir() as d:
            script_name = make_script(d, 'script', test_src)
            exit_code, data = run_python(script_name)
            expected = pattern % (script_name, "__main__.Test")
            if verbose:
                print "Expected line", expected
                print "Got stdout:"
                print data
            self.assertIn(expected, data)
            zip_name, run_name = make_zip_script(d, "test_zip",
                                                script_name, '__main__.py')
            exit_code, data = run_python(zip_name)
            expected = pattern % (run_name, "__main__.Test")
            if verbose:
                print "Expected line", expected
                print "Got stdout:"
                print data
            self.assertIn(expected, data)

 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(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_zipfile(self):
     source = self.main_in_children_source
     with 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 temp_dir() as script_dir:
         mod_name = '__main__'
         script_name = self._make_test_script(script_dir, mod_name)
         compiled_name = compile_script(script_name)
         zip_name, fname = make_zip_script(script_dir, 'test_zip', compiled_name)
         self._check_script(zip_name, "<run_path>", fname, zip_name, '')

 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, "")

 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.assertRaisesRegexp(RuntimeError, msg, run_path, zip_name)

 def test_zipfile_compiled(self):
     source = self.main_in_children_source
     with 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_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_inspect_getsource_issue4223(self):
     test_src = "def foo(): pass\n"
     with 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
         self.assertEqual(inspect.getsource(zip_pkg.foo), test_src)

    def test_inspect_getsource_issue4223(self):
        test_src = "def foo(): pass\n"
        with 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 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_pdb_issue4201(self):
        test_src = textwrap.dedent("""\
                    def f():
                        pass

                    import pdb
                    pdb.runcall(f)
                    """)

        with temp_dir() as d:
            script_name = make_script(d, 'script', test_src)
            p = spawn_python(script_name)
            p.stdin.write('l\n')
            data = kill_python(p)
            # Back-port from CPython 3 (see CPython Issue 14255).
            self.assertNormalisedIn(script_name, data)

            zip_name, run_name = make_zip_script(d, "test_zip",
                                                script_name, '__main__.py')
            p = spawn_python(zip_name)
            p.stdin.write('l\n')
            data = kill_python(p)
            # Back-port from CPython 3 (see CPython Issue 14255).
            self.assertNormalisedIn(run_name, data)

 def test_zipfile(self):
     with 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, "")

 def test_zipfile(self):
     with 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_compiled(self):
     with temp_dir() as script_dir:
         script_name = _make_test_script(script_dir, '__main__')
         compiled_name = compile_script(script_name)
         zip_name, run_name = make_zip_script(script_dir, 'test_zip', compiled_name)
         self._check_script(zip_name, run_name, zip_name, '')

 def test_zipfile_error(self):
     with 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 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, "")

 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")
     sample_src = inspect.getsource(sample_doctest)
     sample_src = sample_src.replace("test.test_doctest",
                                     "test_zipped_doctest")
     with 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')
         z.writestr("sample_zipped_doctest.py", sample_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
         # 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.old_test1,
             test_zipped_doctest.old_test2,
             test_zipped_doctest.old_test3,
             test_zipped_doctest.old_test4,
             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_pdb_set_trace,
             test_zipped_doctest.test_pdb_set_trace_nested,
             test_zipped_doctest.test_testsource,
             test_zipped_doctest.test_trailing_space_in_test,
             test_zipped_doctest.test_DocTestSuite,
             test_zipped_doctest.test_DocTestFinder,
         ]
         # These remaining 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,
         ]
         # Needed for test_DocTestParser and test_debug
         deprecations = [
             # Ignore all warnings about the use of class Tester in this module.
             ("class Tester is deprecated", DeprecationWarning)]
         if sys.py3kwarning:
             deprecations += [
                 ("backquote not supported", SyntaxWarning),
                 ("execfile.. not supported", DeprecationWarning)]
         with test.test_support.check_warnings(*deprecations):
             for obj in known_good_tests:
                 _run_object_doctest(obj, test_zipped_doctest)