class FileBuilder:
def unicode_filename(self):
try:
- import test.support
+ from test.support import os_helper
except ImportError:
# outside CPython, hard-code a unicode snowman
return '☃'
- return test.support.FS_NONASCII or \
+ return os_helper.FS_NONASCII or \
self.skip("File system does not support non-ascii.")
import sys
import unittest
from test import support
+from test.support import import_helper
class ParentModuleTests:
try:
submodule = self.__import__(subname)
finally:
- support.unload(subname)
+ import_helper.unload(subname)
(Frozen_ParentTests,
import unittest
import warnings
-from test.support import make_legacy_pyc, unload
+from test.support.import_helper import make_legacy_pyc, unload
from test.test_py_compile import without_source_date_epoch
from test.test_py_compile import SourceDateEpochTestMeta
import stat
import sys
import tempfile
-from test.support import make_legacy_pyc
+from test.support.import_helper import make_legacy_pyc
import unittest
import warnings
import os
import sys
from test import support
+from test.support import import_helper
import types
import unittest
from unittest import mock
module_name = 'blah'
def setUp(self):
- support.unload(self.module_name)
- self.addCleanup(support.unload, self.module_name)
+ import_helper.unload(self.module_name)
+ self.addCleanup(import_helper.unload, self.module_name)
def load(self, loader):
spec = self.util.spec_from_loader(self.module_name, loader)
import os.path
import sys
from test import support
+from test.support import import_helper
+from test.support import os_helper
import types
import unittest
import warnings
def test_reload_modules(self):
for mod in ('tokenize', 'time', 'marshal'):
with self.subTest(module=mod):
- with support.CleanImport(mod):
+ with import_helper.CleanImport(mod):
module = self.init.import_module(mod)
self.init.reload(module)
self.assertEqual(reloaded.spam, 3)
def test_reload_missing_loader(self):
- with support.CleanImport('types'):
+ with import_helper.CleanImport('types'):
import types
loader = types.__loader__
del types.__loader__
self.assertEqual(reloaded.__loader__.path, loader.path)
def test_reload_loader_replaced(self):
- with support.CleanImport('types'):
+ with import_helper.CleanImport('types'):
import types
types.__loader__ = None
self.init.invalidate_caches()
def test_reload_location_changed(self):
name = 'spam'
- with support.temp_cwd(None) as cwd:
+ with os_helper.temp_cwd(None) as cwd:
with test_util.uncache('spam'):
- with support.DirsOnSysPath(cwd):
+ with import_helper.DirsOnSysPath(cwd):
# Start as a plain module.
self.init.invalidate_caches()
path = os.path.join(cwd, name + '.py')
'__cached__': cached,
'__doc__': None,
}
- support.create_empty_file(path)
+ os_helper.create_empty_file(path)
module = self.init.import_module(name)
ns = vars(module).copy()
loader = ns.pop('__loader__')
def test_reload_namespace_changed(self):
name = 'spam'
- with support.temp_cwd(None) as cwd:
+ with os_helper.temp_cwd(None) as cwd:
with test_util.uncache('spam'):
- with support.DirsOnSysPath(cwd):
+ with import_helper.DirsOnSysPath(cwd):
# Start as a namespace package.
self.init.invalidate_caches()
bad_path = os.path.join(cwd, name, '__init.py')
import unittest
from importlib.util import cache_from_source
-from test.support import create_empty_file
+from test.support.os_helper import create_empty_file
class TestImport(unittest.TestCase):
import os.path
import pathlib
-from test.support import CleanImport
+from test.support.import_helper import CleanImport
import unittest
import sys
import warnings
import threading
import unittest
from unittest import mock
-from test.support import (
- verbose, run_unittest, TESTFN,
- forget, unlink, rmtree)
+from test.support import (verbose, run_unittest)
+from test.support.import_helper import forget
+from test.support.os_helper import (TESTFN, unlink, rmtree)
from test.support import threading_helper
def task(N, done, done_tasks, errors):
import sys
import unittest
from test import support
+from test.support import import_helper
from distutils.util import get_platform
from contextlib import contextmanager
from .util import temp_module
-support.import_module('winreg', required_on=['win'])
+import_helper.import_module('winreg', required_on=['win'])
from winreg import (
CreateKey, HKEY_CURRENT_USER,
SetValue, REG_SZ, KEY_ALL_ACCESS,
from pathlib import Path, PurePath
from test import support
from test.support import import_helper
+from test.support import os_helper
import unittest
import sys
import tempfile
@contextlib.contextmanager
def temp_module(name, content='', *, pkg=False):
conflicts = [n for n in sys.modules if n.partition('.')[0] == name]
- with support.temp_cwd(None) as cwd:
+ with os_helper.temp_cwd(None) as cwd:
with uncache(name, *conflicts):
- with support.DirsOnSysPath(cwd):
+ with import_helper.DirsOnSysPath(cwd):
invalidate_caches()
location = os.path.join(cwd, name)
state_manager.__exit__(None, None, None)
if uncache_manager is not None:
uncache_manager.__exit__(None, None, None)
- support.rmtree(temp_dir)
+ os_helper.rmtree(temp_dir)
def mock_path_hook(*entries, importer):
pass
def setUp(self):
- modules = support.modules_setup()
- self.addCleanup(support.modules_cleanup, *modules)
+ modules = import_helper.modules_setup()
+ self.addCleanup(import_helper.modules_cleanup, *modules)
class ZipSetup(ZipSetupBase):
except ImportError:
ThreadPoolExecutor = None
-from test.support import run_unittest, TESTFN, DirsOnSysPath, cpython_only
+from test.support import run_unittest, cpython_only
from test.support import MISSING_C_DOCSTRINGS, ALWAYS_EQ
+from test.support.import_helper import DirsOnSysPath
+from test.support.os_helper import TESTFN
from test.support.script_helper import assert_python_ok, assert_python_failure
from test import inspect_fodder as mod
from test import inspect_fodder2 as mod2
import test.support
from test import support
from test.support import socket_helper
-from test.support import (captured_stderr, TESTFN, EnvironmentVarGuard,
- change_cwd)
+from test.support import captured_stderr
+from test.support.os_helper import TESTFN, EnvironmentVarGuard, change_cwd
import builtins
import encodings
import glob
import runpy
import sys
from test import support
+from test.support import os_helper
from test.test_tools import skip_if_missing, scriptsdir
import unittest
)
def test_directory(self):
- os.mkdir(support.TESTFN)
- self.addCleanup(support.rmtree, support.TESTFN)
- c_filename = os.path.join(support.TESTFN, "file.c")
+ os.mkdir(os_helper.TESTFN)
+ self.addCleanup(os_helper.rmtree, os_helper.TESTFN)
+ c_filename = os.path.join(os_helper.TESTFN, "file.c")
with open(c_filename, "w") as file:
file.write("int xx;\n")
- with open(os.path.join(support.TESTFN, "file.py"), "w") as file:
+ with open(os.path.join(os_helper.TESTFN, "file.py"), "w") as file:
file.write("xx = 'unaltered'\n")
script = os.path.join(scriptsdir, "fixcid.py")
- output = self.run_script(args=(support.TESTFN,))
+ output = self.run_script(args=(os_helper.TESTFN,))
self.assertMultiLineEqual(output,
"{}:\n"
"1\n"
)
def run_script(self, input="", *, args=("-",), substfile="xx yy\n"):
- substfilename = support.TESTFN + ".subst"
+ substfilename = os_helper.TESTFN + ".subst"
with open(substfilename, "w") as file:
file.write(substfile)
- self.addCleanup(support.unlink, substfilename)
+ self.addCleanup(os_helper.unlink, substfilename)
argv = ["fixcid.py", "-s", substfilename] + list(args)
script = os.path.join(scriptsdir, "fixcid.py")
from test.support.script_helper import assert_python_ok
from test.test_tools import skip_if_missing, toolsdir
-from test.support import temp_cwd, temp_dir
+from test.support.os_helper import temp_cwd, temp_dir
skip_if_missing()
import os
import tempfile
from test import support
+from test.support import os_helper
from test.test_tools import skip_if_missing, import_tool
import unittest
def setUp(self):
self.lll = import_tool('lll')
- @support.skip_unless_symlink
+ @os_helper.skip_unless_symlink
def test_lll_multiple_dirs(self):
with tempfile.TemporaryDirectory() as dir1, \
tempfile.TemporaryDirectory() as dir2:
import sys
import unittest
from test import support
+from test.support import os_helper
from test.test_tools import scriptsdir, skip_if_missing
script = os.path.join(scriptsdir, 'pathfix.py')
def setUp(self):
- self.addCleanup(support.unlink, support.TESTFN)
+ self.addCleanup(os_helper.unlink, os_helper.TESTFN)
def pathfix(self, shebang, pathfix_flags, exitcode=0, stdout='', stderr='',
directory=''):
filename = os.path.join(directory, 'script-A_1.py')
pathfix_arg = directory
else:
- filename = support.TESTFN
+ filename = os_helper.TESTFN
pathfix_arg = filename
with open(filename, 'w', encoding='utf8') as f:
return new_shebang
def test_recursive(self):
- tmpdir = support.TESTFN + '.d'
- self.addCleanup(support.rmtree, tmpdir)
+ tmpdir = os_helper.TESTFN + '.d'
+ self.addCleanup(os_helper.rmtree, tmpdir)
os.mkdir(tmpdir)
expected_stderr = f"recursedown('{os.path.basename(tmpdir)}')\n"
self.assertEqual(
import subprocess
import textwrap
from test import support
+from test.support import os_helper
from test.support.script_helper import assert_python_ok
from test.test_tools import scriptsdir, skip_if_missing
def test_selftest(self):
self.maxDiff = None
- with support.temp_dir() as directory:
+ with os_helper.temp_dir() as directory:
data_path = os.path.join(directory, '_test.py')
with open(self.script) as f:
closed = f.read()
import os
import sys
import unittest
-from test import support
+from test.support import import_helper
from test.test_tools import scriptsdir, import_tool, skip_if_missing
skiplist = blacklist + whitelist + windows_only + other
def test_sundry(self):
- old_modules = support.modules_setup()
+ old_modules = import_helper.modules_setup()
try:
for fn in os.listdir(scriptsdir):
if not fn.endswith('.py'):
import_tool(name)
finally:
# Unload all modules loaded in this test
- support.modules_cleanup(*old_modules)
+ import_helper.modules_cleanup(*old_modules)
@unittest.skipIf(sys.platform != "win32", "Windows-only test")
def test_sundry_windows(self):