def restore_files(self, saved_value):
     fn = support.TESTFN
     if fn not in saved_value and (fn + '/') not in saved_value:
         if os.path.isfile(fn):
             support.unlink(fn)
         elif os.path.isdir(fn):
             support.rmtree(fn)

    def test_getcwd_long_pathnames(self):
        dirname = 'getcwd-test-directory-0123456789abcdef-01234567890abcdef'
        curdir = os.getcwd()
        base_path = os.path.abspath(support.TESTFN) + '.getcwd'

        try:
            os.mkdir(base_path)
            os.chdir(base_path)
        except:
            #  Just returning nothing instead of the SkipTest exception, because
            #  the test results in Error in that case.  Is that ok?
            #  raise unittest.SkipTest("cannot create directory for testing")
            return

            def _create_and_do_getcwd(dirname, current_path_length = 0):
                try:
                    os.mkdir(dirname)
                except:
                    raise unittest.SkipTest("mkdir cannot create directory sufficiently deep for getcwd test")

                os.chdir(dirname)
                try:
                    os.getcwd()
                    if current_path_length < 1027:
                        _create_and_do_getcwd(dirname, current_path_length + len(dirname) + 1)
                finally:
                    os.chdir('..')
                    os.rmdir(dirname)

            _create_and_do_getcwd(dirname)

        finally:
            os.chdir(curdir)
            support.rmtree(base_path)

 def test_relative_imports_on_plain_module(self):
     # Validates running a plain module. See bpo32691
     self.module_name = 't_main'
     support.rmtree(self.module_name)
     main_file = self.module_name + '/runme.py'
     init_file = self.module_name + '/__init__.py'
     module_file = self.module_name + '/module.py'
     self.addCleanup(support.rmtree, self.module_name)
     os.mkdir(self.module_name)
     with open(init_file, 'w') as f:
         f.write(textwrap.dedent("""
             top_var = "VAR from top"
         """))
     with open(main_file, 'w') as f:
         f.write(textwrap.dedent("""
             from . import module
             pass # We'll stop here and print the vars
         """))
     with open(module_file, 'w') as f:
         f.write(textwrap.dedent("""
             var = "VAR from module"
         """))
     commands = """
         b 3
         c
         p module.var
         quit
     """
     stdout, _ = self._run_pdb(['-m', self.module_name + '.runme'], commands)
     self.assertTrue(any("VAR from module" in l for l in stdout.splitlines()), stdout)

 def clear_directory(self, path):
     for fn in os.listdir(path):
         fn = os.path.join(path, fn)
         if os.path.islink(fn) or os.path.isfile(fn):
             os.remove(fn)
         elif os.path.isdir(fn):
             rmtree(fn)

def remove_files(name):
    for f in (name + ".py",
              name + ".pyc",
              name + ".pyw",
              name + "$py.class"):
        unlink(f)
    rmtree('__pycache__')

 def test_defaults(self):
     """
     Test the create function with default arguments.
     """
     rmtree(self.env_dir)
     self.run_with_capture(venv.create, self.env_dir)
     self.isdir(self.bindir)
     self.isdir(self.include)
     self.isdir(*self.lib)
     # Issue 21197
     p = self.get_env_file('lib64')
     conditions = ((struct.calcsize('P') == 8) and (os.name == 'posix') and
                   (sys.platform != 'darwin'))
     if conditions:
         self.assertTrue(os.path.islink(p))
     else:
         self.assertFalse(os.path.exists(p))
     data = self.get_text_file_contents('pyvenv.cfg')
     if sys.platform == 'darwin' and ('__PYVENV_LAUNCHER__'
                                      in os.environ):
         executable =  os.environ['__PYVENV_LAUNCHER__']
     else:
         executable = sys.executable
     path = os.path.dirname(executable)
     self.assertIn('home = %s' % path, data)
     fn = self.get_env_file(self.bindir, self.exe)
     if not os.path.exists(fn):  # diagnostics for Windows buildbot failures
         bd = self.get_env_file(self.bindir)
         print('Contents of %r:' % bd)
         print('    %r' % os.listdir(bd))
     self.assertTrue(os.path.exists(fn), 'File %r should exist.' % fn)

def _inside_empty_temp_dir():
    dir = tempfile.mkdtemp()
    try:
        with support.swap_attr(tempfile, "tempdir", dir):
            yield
    finally:
        support.rmtree(dir)

    def test_collision_with_existing_directory(self):
        # _mkstemp_inner tries another name when a directory with
        # the chosen name already exists
        container_dir = tempfile.mkdtemp()
        try:
            def mock_get_candidate_names():
                return iter(['aaa', 'aaa', 'bbb'])
            with support.swap_attr(tempfile,
                                   '_get_candidate_names',
                                   mock_get_candidate_names):
                dir = tempfile.mkdtemp(dir=container_dir)
                self.assertTrue(dir.endswith('aaa'))

                flags = tempfile._bin_openflags
                (fd, name) = tempfile._mkstemp_inner(container_dir,
                                                     tempfile.template,
                                                     '',
                                                     flags)
                try:
                    self.assertTrue(name.endswith('bbb'))
                finally:
                    os.close(fd)
                    os.unlink(name)
        finally:
            support.rmtree(container_dir)

 def newdirinpath(dir):
     os.mkdir(dir)
     sys.path.insert(0, dir)
     try:
         yield
     finally:
         sys.path.pop(0)
         rmtree(dir)

 def test_mkdir_dir_fd(self):
     f = posix.open(posix.getcwd(), posix.O_RDONLY)
     try:
         posix.mkdir(support.TESTFN + 'dir', dir_fd=f)
         posix.stat(support.TESTFN + 'dir') # should not raise exception
     finally:
         posix.close(f)
         support.rmtree(support.TESTFN + 'dir')

 def tearDown(self):
     sys.path[:] = self.sys_path
     if self.orig_module is not None:
         sys.modules[self.module_name] = self.orig_module
     else:
         unload(self.module_name)
     unlink(self.file_name)
     unlink(self.compiled_name)
     rmtree(self.dir_name)

def create_modules(*names):
    """Temporarily create each named module with an attribute (named 'attr')
    that contains the name passed into the context manager that caused the
    creation of the module.

    All files are created in a temporary directory returned by
    tempfile.mkdtemp(). This directory is inserted at the beginning of
    sys.path. When the context manager exits all created files (source and
    bytecode) are explicitly deleted.

    No magic is performed when creating packages! This means that if you create
    a module within a package you must also create the package's __init__ as
    well.

    """
    source = 'attr = {0!r}'
    created_paths = []
    mapping = {}
    state_manager = None
    uncache_manager = None
    try:
        temp_dir = tempfile.mkdtemp()
        mapping['.root'] = temp_dir
        import_names = set()
        for name in names:
            if not name.endswith('__init__'):
                import_name = name
            else:
                import_name = name[:-len('.__init__')]
            import_names.add(import_name)
            if import_name in sys.modules:
                del sys.modules[import_name]
            name_parts = name.split('.')
            file_path = temp_dir
            for directory in name_parts[:-1]:
                file_path = os.path.join(file_path, directory)
                if not os.path.exists(file_path):
                    os.mkdir(file_path)
                    created_paths.append(file_path)
            file_path = os.path.join(file_path, name_parts[-1] + '.py')
            with open(file_path, 'w') as file:
                file.write(source.format(name))
            created_paths.append(file_path)
            mapping[name] = file_path
        uncache_manager = uncache(*import_names)
        uncache_manager.__enter__()
        state_manager = import_state(path=[temp_dir])
        state_manager.__enter__()
        yield mapping
    finally:
        if state_manager is not None:
            state_manager.__exit__(None, None, None)
        if uncache_manager is not None:
            uncache_manager.__exit__(None, None, None)
        support.rmtree(temp_dir)

 def test_executable(self):
     """
     Test that the sys.executable value is as expected.
     """
     rmtree(self.env_dir)
     self.run_with_capture(venv.create, self.env_dir)
     envpy = os.path.join(os.path.realpath(self.env_dir),
                          self.bindir, self.exe)
     out, err = check_output([envpy, '-c',
         'import sys; print(sys.executable)'])
     self.assertEqual(out.strip(), envpy.encode())

 def test_module_without_a_main(self):
     module_name = 't_main'
     support.rmtree(module_name)
     init_file = module_name + '/__init__.py'
     os.mkdir(module_name)
     with open(init_file, 'w') as f:
         pass
     self.addCleanup(support.rmtree, module_name)
     stdout, stderr = self._run_pdb(['-m', module_name], "")
     self.assertIn("ImportError: No module named t_main.__main__",
                   stdout.splitlines())

 def test_executable_symlinks(self):
     """
     Test that the sys.executable value is as expected.
     """
     rmtree(self.env_dir)
     builder = venv.EnvBuilder(clear=True, symlinks=True)
     builder.create(self.env_dir)
     envpy = os.path.join(os.path.realpath(self.env_dir),
                          self.bindir, self.exe)
     out, err = check_output([envpy, '-c',
         'import sys; print(sys.executable)'])
     self.assertEqual(out.strip(), envpy.encode())

 def test_executable(self):
     """
     Test that the sys.executable value is as expected.
     """
     rmtree(self.env_dir)
     self.run_with_capture(venv.create, self.env_dir)
     envpy = os.path.join(os.path.realpath(self.env_dir), self.bindir, self.exe)
     cmd = [envpy, '-c', 'import sys; print(sys.executable)']
     p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE)
     out, err = p.communicate()
     self.assertEqual(out.strip(), envpy.encode())

 def test_multiprocessing(self):
     """
     Test that the multiprocessing is able to spawn.
     """
     rmtree(self.env_dir)
     self.run_with_capture(venv.create, self.env_dir)
     envpy = os.path.join(os.path.realpath(self.env_dir),
                          self.bindir, self.exe)
     out, err = check_output([envpy, '-c',
         'from multiprocessing import Pool; ' +
         'print(Pool(1).apply_async("Python".lower).get(3))'])
     self.assertEqual(out.strip(), "python".encode())

 def test_executable_symlinks(self):
     """
     Test that the sys.executable value is as expected.
     """
     rmtree(self.env_dir)
     builder = venv.EnvBuilder(clear=True, symlinks=True)
     builder.create(self.env_dir)
     envpy = os.path.join(os.path.realpath(self.env_dir), self.bindir, self.exe)
     cmd = [envpy, '-c', 'import sys; print(sys.executable)']
     p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE)
     out, err = p.communicate()
     self.assertEqual(out.strip(), envpy.encode())

 def run_pdb_module(self, script, commands):
     """Runs the script code as part of a module"""
     self.module_name = 't_main'
     support.rmtree(self.module_name)
     main_file = self.module_name + '/__main__.py'
     init_file = self.module_name + '/__init__.py'
     os.mkdir(self.module_name)
     with open(init_file, 'w') as f:
         pass
     with open(main_file, 'w') as f:
         f.write(textwrap.dedent(script))
     self.addCleanup(support.rmtree, self.module_name)
     return self._run_pdb(['-m', self.module_name], commands)

    def test_temp_dir(self):
        """Test that temp_dir() creates and destroys its directory."""
        parent_dir = tempfile.mkdtemp()
        parent_dir = os.path.realpath(parent_dir)

        try:
            path = os.path.join(parent_dir, 'temp')
            self.assertFalse(os.path.isdir(path))
            with support.temp_dir(path) as temp_path:
                self.assertEqual(temp_path, path)
                self.assertTrue(os.path.isdir(path))
            self.assertFalse(os.path.isdir(path))
        finally:
            support.rmtree(parent_dir)