Patch by Christie Wilson.
from asyncio import test_utils
try:
from test import support
- from test.script_helper import assert_python_ok
+ from test.support.script_helper import assert_python_ok
except ImportError:
from asyncio import test_support as support
from asyncio.test_support import assert_python_ok
from asyncio import test_utils
try:
from test import support
- from test.script_helper import assert_python_ok
+ from test.support.script_helper import assert_python_ok
except ImportError:
from asyncio import test_support as support
from asyncio.test_support import assert_python_ok
import warnings
from operator import neg
from test.support import TESTFN, unlink, run_unittest, check_warnings
-from test.script_helper import assert_python_ok
+from test.support.script_helper import assert_python_ok
try:
import pty, signal
except ImportError:
import unittest
from test import support
-from test.script_helper import assert_python_ok, assert_python_failure
+from test.support.script_helper import assert_python_ok, assert_python_failure
import time
import locale
import sys
import unittest
from test import support
from test.support import MISSING_C_DOCSTRINGS
-from test.script_helper import assert_python_failure
+from test.support.script_helper import assert_python_failure
try:
import _posixsubprocess
except ImportError:
-from test.script_helper import assert_python_failure, temp_dir
+from test.support import temp_dir
+from test.support.script_helper import assert_python_failure
import unittest
import sys
import cgitb
import sys
import subprocess
import tempfile
-from test import script_helper
-from test.script_helper import (spawn_python, kill_python, assert_python_ok,
+from test.support import script_helper
+from test.support.script_helper import (spawn_python, kill_python, assert_python_ok,
assert_python_failure)
def test_xoptions(self):
def get_xoptions(*args):
- # use subprocess module directly because test.script_helper adds
+ # use subprocess module directly because test.support.script_helper adds
# "-X faulthandler" to the command line
args = (sys.executable, '-E') + args
args += ('-c', 'import sys; print(sys._xoptions)')
import textwrap
from test import support
-from test.script_helper import (
+from test.support.script_helper import (
make_pkg, make_script, make_zip_pkg, make_zip_script,
- assert_python_ok, assert_python_failure, temp_dir,
- spawn_python, kill_python)
+ assert_python_ok, assert_python_failure, spawn_python, kill_python)
verbose = support.verbose
self.check_repl_stderr_flush(True)
def test_basic_script(self):
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
script_name = _make_test_script(script_dir, 'script')
self._check_script(script_name, script_name, script_name,
script_dir, None,
importlib.machinery.SourceFileLoader)
def test_script_compiled(self):
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
script_name = _make_test_script(script_dir, 'script')
py_compile.compile(script_name, doraise=True)
os.remove(script_name)
importlib.machinery.SourcelessFileLoader)
def test_directory(self):
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
script_name = _make_test_script(script_dir, '__main__')
self._check_script(script_dir, script_name, script_dir,
script_dir, '',
importlib.machinery.SourceFileLoader)
def test_directory_compiled(self):
- with temp_dir() as script_dir:
+ 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)
importlib.machinery.SourcelessFileLoader)
def test_directory_error(self):
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
msg = "can't find '__main__' module in %r" % script_dir
self._check_import_error(script_dir, msg)
def test_zipfile(self):
- with temp_dir() as script_dir:
+ 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_compiled(self):
- with temp_dir() as script_dir:
+ 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)
zipimport.zipimporter)
def test_zipfile_error(self):
- with temp_dir() as script_dir:
+ 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_module_in_package(self):
- with temp_dir() as script_dir:
+ 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, 'script')
importlib.machinery.SourceFileLoader)
def test_module_in_package_in_zipfile(self):
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
zip_name, run_name = _make_test_zip_pkg(script_dir, 'test_zip', 'test_pkg', 'script')
launch_name = _make_launch_script(script_dir, 'launch', 'test_pkg.script', zip_name)
self._check_script(launch_name, run_name, run_name,
zip_name, 'test_pkg', zipimport.zipimporter)
def test_module_in_subpackage_in_zipfile(self):
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
zip_name, run_name = _make_test_zip_pkg(script_dir, 'test_zip', 'test_pkg', 'script', depth=2)
launch_name = _make_launch_script(script_dir, 'launch', 'test_pkg.test_pkg.script', zip_name)
self._check_script(launch_name, run_name, run_name,
zipimport.zipimporter)
def test_package(self):
- with temp_dir() as script_dir:
+ 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__')
importlib.machinery.SourceFileLoader)
def test_package_compiled(self):
- with temp_dir() as script_dir:
+ 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__')
importlib.machinery.SourcelessFileLoader)
def test_package_error(self):
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
pkg_dir = os.path.join(script_dir, 'test_pkg')
make_pkg(pkg_dir)
msg = ("'test_pkg' is a package and cannot "
self._check_import_error(launch_name, msg)
def test_package_recursion(self):
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
pkg_dir = os.path.join(script_dir, 'test_pkg')
make_pkg(pkg_dir)
main_dir = os.path.join(pkg_dir, '__main__')
def test_issue8202(self):
# Make sure package __init__ modules see "-m" in sys.argv0 while
# searching for the module to execute
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
with support.change_cwd(path=script_dir):
pkg_dir = os.path.join(script_dir, 'test_pkg')
make_pkg(pkg_dir, "import sys; print('init_argv0==%r' % sys.argv[0])")
def test_issue8202_dash_c_file_ignored(self):
# Make sure a "-c" file in the current directory
# does not alter the value of sys.path[0]
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
with support.change_cwd(path=script_dir):
with open("-c", "w") as f:
f.write("data")
def test_issue8202_dash_m_file_ignored(self):
# Make sure a "-m" file in the current directory
# does not alter the value of sys.path[0]
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
script_name = _make_test_script(script_dir, 'other')
with support.change_cwd(path=script_dir):
with open("-m", "w") as f:
# If a module is invoked with the -m command line flag
# and results in an error that the return code to the
# shell is '1'
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
with support.change_cwd(path=script_dir):
pkg_dir = os.path.join(script_dir, 'test_pkg')
make_pkg(pkg_dir)
except:
raise NameError from None
""")
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
script_name = _make_test_script(script_dir, 'script', script)
exitcode, stdout, stderr = assert_python_failure(script_name)
text = stderr.decode('ascii').split('\n')
if error:
sys.exit(error)
""")
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
script_name = _make_test_script(script_dir, 'script', script)
exitcode, stdout, stderr = assert_python_failure(script_name)
text = stderr.decode('ascii')
except ImportError:
_have_multiprocessing = False
-from test import support, script_helper
+from test import support
+from test.support import script_helper
class CompileallTests(unittest.TestCase):
# without thread support.
test.support.import_module('threading')
-from test.script_helper import assert_python_ok
+from test.support.script_helper import assert_python_ok
import os
import sys
import glob
import os.path
import test.support
-from test.script_helper import assert_python_failure
+from test.support.script_helper import assert_python_failure
CRASHER_DIR = os.path.join(os.path.dirname(__file__), "crashers")
CRASHER_FILES = os.path.join(CRASHER_DIR, "*.py")
simple tests and no errors. We'll run both the unadorned doctest command, and
the verbose version, and then check the output:
- >>> from test import script_helper
- >>> with script_helper.temp_dir() as tmpdir:
+ >>> from test.support import script_helper, temp_dir
+ >>> with temp_dir() as tmpdir:
... fn = os.path.join(tmpdir, 'myfile.doc')
... with open(fn, 'w') as f:
... _ = f.write('This is a very simple test file.\n')
file ends in '.py', its handling of python module files (as opposed to straight
text files).
- >>> from test import script_helper
- >>> with script_helper.temp_dir() as tmpdir:
+ >>> from test.support import script_helper, temp_dir
+ >>> with temp_dir() as tmpdir:
... fn = os.path.join(tmpdir, 'myfile.doc')
... with open(fn, 'w') as f:
... _ = f.write('This is another simple test file.\n')
import signal
import unittest
-from test import script_helper, support
+from test import support
+from test.support import script_helper
@unittest.skipUnless(os.name == "posix", "only supported on Unix")
import signal
import subprocess
import sys
-from test import support, script_helper
-from test.script_helper import assert_python_ok
+from test import support
+from test.support import script_helper
import tempfile
import unittest
from textwrap import dedent
import unittest
from test.support import (verbose, refcount_test, run_unittest,
- strip_python_stderr, cpython_only, start_threads)
-from test.script_helper import assert_python_ok, make_script, temp_dir
+ strip_python_stderr, cpython_only, start_threads,
+ temp_dir)
+from test.support.script_helper import assert_python_ok, make_script
import sys
import time
import os
import sys
import unittest
-from test.script_helper import assert_python_ok
+from test.support.script_helper import assert_python_ok
from collections import Hashable
IS_64BIT = sys.maxsize > 2**32
from test.support import (
EnvironmentVarGuard, TESTFN, check_warnings, forget, is_jython,
make_legacy_pyc, rmtree, run_unittest, swap_attr, swap_item, temp_umask,
- unlink, unload, create_empty_file, cpython_only, TESTFN_UNENCODABLE)
-from test import script_helper
+ unlink, unload, create_empty_file, cpython_only, TESTFN_UNENCODABLE,
+ temp_dir)
+from test.support import script_helper
skip_if_dont_write_bytecode = unittest.skipIf(
# temporarily clears the module from sys.modules (if any)
# reverts or removes the module when cleaning up
name = name or "spam"
- with script_helper.temp_dir() as tempdir:
+ with temp_dir() as tempdir:
path = script_helper.make_script(tempdir, name, source)
old_module = sys.modules.pop(name, None)
try:
from test.support import run_unittest, TESTFN, DirsOnSysPath, cpython_only
from test.support import MISSING_C_DOCSTRINGS, cpython_only
-from test.script_helper import assert_python_ok, assert_python_failure
+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
from collections import deque, UserList
from itertools import cycle, count
from test import support
-from test.script_helper import assert_python_ok, run_python_until_end
+from test.support.script_helper import assert_python_ok, run_python_until_end
import codecs
import io # C implementation of io
import unittest
import subprocess
from test import support
-from test.script_helper import assert_python_ok
+from test.support.script_helper import assert_python_ok
class TestTool(unittest.TestCase):
import struct
import sys
import tempfile
-from test.script_helper import assert_python_ok
+from test.support.script_helper import assert_python_ok
from test import support
import textwrap
import time
import unittest
import weakref
from test.support import gc_collect
-from test.script_helper import assert_python_ok
+from test.support.script_helper import assert_python_ok
import sys
ModuleType = type(sys)
import os.path
import py_compile
-from test.script_helper import (
+from test.support.script_helper import (
make_pkg, make_script, make_zip_pkg, make_zip_script,
- assert_python_ok, assert_python_failure, temp_dir,
- spawn_python, kill_python)
+ assert_python_ok, assert_python_failure, spawn_python, kill_python)
# Look up which start methods are available to test
import multiprocessing
self._check_output(script_name, rc, out, err)
def test_basic_script(self):
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
script_name = _make_test_script(script_dir, 'script')
self._check_script(script_name)
def test_basic_script_no_suffix(self):
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
script_name = _make_test_script(script_dir, 'script',
omit_suffix=True)
self._check_script(script_name)
# a workaround for that case
# See https://github.com/ipython/ipython/issues/4698
source = test_source_main_skipped_in_children
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
script_name = _make_test_script(script_dir, 'ipython',
source=source)
self._check_script(script_name)
self._check_script(script_no_suffix)
def test_script_compiled(self):
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
script_name = _make_test_script(script_dir, 'script')
py_compile.compile(script_name, doraise=True)
os.remove(script_name)
def test_directory(self):
source = self.main_in_children_source
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
script_name = _make_test_script(script_dir, '__main__',
source=source)
self._check_script(script_dir)
def test_directory_compiled(self):
source = self.main_in_children_source
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
script_name = _make_test_script(script_dir, '__main__',
source=source)
py_compile.compile(script_name, doraise=True)
def test_zipfile(self):
source = self.main_in_children_source
- with temp_dir() as script_dir:
+ 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)
def test_zipfile_compiled(self):
source = self.main_in_children_source
- with temp_dir() as script_dir:
+ 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)
self._check_script(zip_name)
def test_module_in_package(self):
- with temp_dir() as script_dir:
+ 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, 'check_sibling')
self._check_script(launch_name)
def test_module_in_package_in_zipfile(self):
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
zip_name, run_name = _make_test_zip_pkg(script_dir, 'test_zip', 'test_pkg', 'script')
launch_name = _make_launch_script(script_dir, 'launch', 'test_pkg.script', zip_name)
self._check_script(launch_name)
def test_module_in_subpackage_in_zipfile(self):
- with temp_dir() as script_dir:
+ with support.temp_dir() as script_dir:
zip_name, run_name = _make_test_zip_pkg(script_dir, 'test_zip', 'test_pkg', 'script', depth=2)
launch_name = _make_launch_script(script_dir, 'launch', 'test_pkg.test_pkg.script', zip_name)
self._check_script(launch_name)
def test_package(self):
source = self.main_in_children_source
- with temp_dir() as script_dir:
+ 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__',
def test_package_compiled(self):
source = self.main_in_children_source
- with temp_dir() as script_dir:
+ 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__',
except ImportError:
INT_MAX = PY_SSIZE_T_MAX = sys.maxsize
-from test.script_helper import assert_python_ok
+from test.support.script_helper import assert_python_ok
root_in_posix = False
if hasattr(os, 'geteuid'):
import operator
import struct
from test import support
-from test.script_helper import assert_python_failure
+from test.support.script_helper import assert_python_failure
#
# First, we test that we can generate trees from valid source fragments,
import textwrap
from io import StringIO
from collections import namedtuple
-from test.script_helper import assert_python_ok
+from test.support.script_helper import assert_python_ok
from test.support import (
TESTFN, rmtree,
reap_children, reap_threads, captured_output, captured_stdout,
import tempfile
import unittest
from test.support import import_module, unlink
-from test.script_helper import assert_python_ok
+from test.support.script_helper import assert_python_ok
# Skip tests if there is no readline module
readline = import_module('readline')
import py_compile
from test.support import (
forget, make_legacy_pyc, unload, verbose, no_tracing,
- create_empty_file)
-from test.script_helper import (
- make_pkg, make_script, make_zip_pkg, make_zip_script, temp_dir)
+ create_empty_file, temp_dir)
+from test.support.script_helper import (
+ make_pkg, make_script, make_zip_pkg, make_zip_script)
import runpy
-"""Unittests for test.script_helper. Who tests the test helper?"""
+"""Unittests for test.support.script_helper. Who tests the test helper?"""
import subprocess
import sys
-from test import script_helper
+from test.support import script_helper
import unittest
from unittest import mock
import subprocess
import traceback
import sys, os, time, errno
-from test.script_helper import assert_python_ok, spawn_python
+from test.support.script_helper import assert_python_ok, spawn_python
try:
import threading
except ImportError:
import unittest
-from test import script_helper
+from test.support import script_helper
from test import support
import subprocess
import sys
python_dir, python_base = self._split_python_path()
abs_python = os.path.join(python_dir, python_base)
rel_python = os.path.join(os.curdir, python_base)
- with script_helper.temp_dir() as wrong_dir:
+ with support.temp_dir() as wrong_dir:
# Before calling with an absolute path, confirm that using a
# relative path fails.
self.assertRaises(FileNotFoundError, subprocess.Popen,
import unittest, test.support
-from test.script_helper import assert_python_ok, assert_python_failure
+from test.support.script_helper import assert_python_ok, assert_python_failure
import sys, io, os
import struct
import subprocess
@test.support.cpython_only
def test_debugmallocstats(self):
# Test sys._debugmallocstats()
- from test.script_helper import assert_python_ok
+ from test.support.script_helper import assert_python_ok
args = ['-c', 'import sys; sys._debugmallocstats()']
ret, out, err = assert_python_ok(*args)
self.assertIn(b"free PyDictObjects", err)
import unittest.mock
import tarfile
-from test import support, script_helper
+from test import support
+from test.support import script_helper
# Check for our compression modules.
try:
from unittest import mock
import unittest
-from test import support, script_helper
+from test import support
+from test.support import script_helper
if hasattr(os, 'stat'):
import test.support
from test.support import verbose, strip_python_stderr, import_module, cpython_only
-from test.script_helper import assert_python_ok, assert_python_failure
+from test.support.script_helper import assert_python_ok, assert_python_failure
import random
import re
import sys
import unittest
from test import support
-from test.script_helper import assert_python_ok, assert_python_failure
+from test.support.script_helper import assert_python_ok, assert_python_failure
from test.test_tools import scriptsdir, import_tool, skip_if_missing
import subprocess
import textwrap
from test import support
-from test.script_helper import assert_python_ok
+from test.support.script_helper import assert_python_ok
from test.test_tools import scriptsdir, skip_if_missing
import os
import unittest
-from test.script_helper import assert_python_ok
+from test.support.script_helper import assert_python_ok
from test.test_tools import scriptsdir, skip_if_missing
import re
from test import support
from test.support import TESTFN, Error, captured_output, unlink, cpython_only
-from test.script_helper import assert_python_ok
+from test.support.script_helper import assert_python_ok
import textwrap
import traceback
import tracemalloc
import unittest
from unittest.mock import patch
-from test.script_helper import assert_python_ok, assert_python_failure
-from test import script_helper, support
+from test.support.script_helper import (assert_python_ok, assert_python_failure,
+ interpreter_requires_environment)
+from test import support
try:
import threading
except ImportError:
stdout = stdout.rstrip()
self.assertEqual(stdout, b'False')
- @unittest.skipIf(script_helper.interpreter_requires_environment(),
+ @unittest.skipIf(interpreter_requires_environment(),
'Cannot run -E tests when PYTHON env vars are required.')
def test_env_var_ignored_with_E(self):
"""PYTHON* environment variables must be ignored when -E is present."""
import sys
import unittest
from test import support
-from test.script_helper import assert_python_ok, assert_python_failure
+from test.support.script_helper import assert_python_ok, assert_python_failure
from test import warning_tests
import contextlib
import copy
-from test import support, script_helper
+from test import support
+from test.support import script_helper
# Used in ReferencesTestCase.test_ref_created_during_del() .
ref_from_del = None
import linecache
import pdb
import unittest
-from test.script_helper import (spawn_python, kill_python, assert_python_ok,
- temp_dir, make_script, make_zip_script)
+from test.support.script_helper import (spawn_python, kill_python, assert_python_ok,
+ make_script, make_zip_script)
verbose = test.support.verbose
def test_inspect_getsource_issue4223(self):
test_src = "def foo(): pass\n"
- with temp_dir() as d:
+ 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))
mod_name = mod_name.replace("sample_", "sample_zipped_")
sample_sources[mod_name] = src
- with temp_dir() as d:
+ 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',
doctest.testmod()
""")
pattern = 'File "%s", line 2, in %s'
- with temp_dir() as d:
+ 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")
import pdb
pdb.Pdb(nosigint=True).runcall(f)
""")
- with temp_dir() as d:
+ 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')
- Issue #23887: urllib.error.HTTPError now has a proper repr() representation.
Patch by Berker Peksag.
+Tests
+-----
+
+- Issue #9517: Move script_helper into the support package.
+ Patch by Christie Wilson.
+
Documentation
-------------
projects / thirdparty / Python / cpython.git / commitdiff
