-from test.support import findfile, TESTFN, unlink
+from test.support import findfile
+from test.support.os_helper import TESTFN, unlink
import array
import io
import pickle
import os
import sys
from test import support
+from test.support import os_helper
USAGE = """\
def relative_filename(string):
# CWD is replaced with a temporary dir before calling main(), so we
# join it with the saved CWD so it ends up where the user expects.
- return os.path.join(support.SAVEDCWD, string)
+ return os.path.join(os_helper.SAVEDCWD, string)
def huntrleaks(string):
# regex to match 'test_builtin' in line:
# '0:00:00 [ 4/400] test_builtin -- test_dict took 1 sec'
regex = re.compile(r'\btest_[a-zA-Z0-9_]+\b')
- with open(os.path.join(support.SAVEDCWD, self.ns.fromfile)) as fp:
+ with open(os.path.join(os_helper.SAVEDCWD, self.ns.fromfile)) as fp:
for line in fp:
line = line.split('#', 1)[0]
line = line.strip()
for k, v in totals.items():
root.set(k, str(v))
- xmlpath = os.path.join(support.SAVEDCWD, self.ns.xmlpath)
+ xmlpath = os.path.join(os_helper.SAVEDCWD, self.ns.xmlpath)
with open(xmlpath, 'wb') as f:
for s in ET.tostringlist(root):
f.write(s)
test_cwd = 'test_python_worker_{}'.format(pid)
else:
test_cwd = 'test_python_{}'.format(pid)
- test_cwd += support.FS_NONASCII
+ test_cwd += os_helper.FS_NONASCII
test_cwd = os.path.join(self.tmp_dir, test_cwd)
return test_cwd
for name in glob.glob(path):
if os.path.isdir(name):
print("Remove directory: %s" % name)
- support.rmtree(name)
+ os_helper.rmtree(name)
else:
print("Remove file: %s" % name)
- support.unlink(name)
+ os_helper.unlink(name)
def main(self, tests=None, **kwargs):
self.parse_args(kwargs)
# Run the tests in a context manager that temporarily changes the CWD
# to a temporary and writable directory. If it's not possible to
# create or change the CWD, the original CWD will be used.
- # The original CWD is available from support.SAVEDCWD.
+ # The original CWD is available from os_helper.SAVEDCWD.
with os_helper.temp_cwd(test_cwd, quiet=True):
# When using multiprocessing, worker processes will use test_cwd
# as their parent temporary directory. So when the main process
import traceback
import types
from test import support
+from test.support import os_helper
from test.libregrtest.runtest import (
runtest, INTERRUPTED, CHILD_ERROR, PROGRESS_MIN_TIME,
stderr=subprocess.PIPE,
universal_newlines=True,
close_fds=(os.name != 'nt'),
- cwd=support.SAVEDCWD,
+ cwd=os_helper.SAVEDCWD,
**kw)
-from test.support import check_no_resource_warning, findfile, TESTFN, unlink
+from test.support import findfile
+from test.support.os_helper import TESTFN, unlink
+from test.support.warnings_helper import check_no_resource_warning
import unittest
from unittest import mock
from test import audiotests
import shutil
import subprocess
import threading
+from test.support import import_helper
from test.support import threading_helper
-from test.support import unlink
+from test.support.os_helper import unlink
import _compression
import sys
# Skip tests if the bz2 module doesn't exist.
-bz2 = support.import_module('bz2')
+bz2 = import_helper.import_module('bz2')
from bz2 import BZ2File, BZ2Compressor, BZ2Decompressor
has_cmdline_bunzip2 = None
from weakref import proxy
import contextlib
+from test.support import import_helper
from test.support import threading_helper
from test.support.script_helper import assert_python_ok
import functools
-py_functools = support.import_fresh_module('functools', blocked=['_functools'])
-c_functools = support.import_fresh_module('functools', fresh=['_functools'])
+py_functools = import_helper.import_fresh_module('functools',
+ blocked=['_functools'])
+c_functools = import_helper.import_fresh_module('functools',
+ fresh=['_functools'])
-decimal = support.import_fresh_module('decimal', fresh=['_decimal'])
+decimal = import_helper.import_fresh_module('decimal', fresh=['_decimal'])
@contextlib.contextmanager
def replaced_module(name, replacement):
import ast
import unittest
from test import support
+from test.support import import_helper
from textwrap import dedent
import os
import re
self.assertEqual(err.offset, offset)
def test_future1(self):
- with support.CleanImport('future_test1'):
+ with import_helper.CleanImport('future_test1'):
from test import future_test1
self.assertEqual(future_test1.result, 6)
def test_future2(self):
- with support.CleanImport('future_test2'):
+ with import_helper.CleanImport('future_test2'):
from test import future_test2
self.assertEqual(future_test2.result, 6)
def test_future3(self):
- with support.CleanImport('test_future3'):
+ with import_helper.CleanImport('test_future3'):
from test import test_future3
def test_badfuture3(self):
self.fail("syntax error didn't occur")
def test_multiple_features(self):
- with support.CleanImport("test.test_future5"):
+ with import_helper.CleanImport("test.test_future5"):
from test import test_future5
def test_unicode_literals_exec(self):
import tempfile
from test.support.script_helper import assert_python_ok, assert_python_failure
from test import support
+from test.support import os_helper
from test.support import socket_helper
from test.support import threading_helper
+from test.support import warnings_helper
from test.support.logging_helper import TestHandler
import textwrap
import threading
"""Reading logging config from a .ini-style config file."""
- check_no_resource_warning = support.check_no_resource_warning
+ check_no_resource_warning = warnings_helper.check_no_resource_warning
expected_log_pat = r"^(\w+) \+\+ (\w+)$"
# config0 is a standard configuration.
def tearDown(self):
SocketHandlerTest.tearDown(self)
- support.unlink(self.address)
+ os_helper.unlink(self.address)
class DatagramHandlerTest(BaseTest):
def tearDown(self):
DatagramHandlerTest.tearDown(self)
- support.unlink(self.address)
+ os_helper.unlink(self.address)
class SysLogHandlerTest(BaseTest):
def tearDown(self):
SysLogHandlerTest.tearDown(self)
- support.unlink(self.address)
+ os_helper.unlink(self.address)
@unittest.skipUnless(socket_helper.IPV6_ENABLED,
'IPv6 support required for this test.')
"""Reading logging config from a dictionary."""
- check_no_resource_warning = support.check_no_resource_warning
+ check_no_resource_warning = warnings_helper.check_no_resource_warning
expected_log_pat = r"^(\w+) \+\+ (\w+)$"
# config0 is a standard configuration.
import threading
import time
import unittest
-from test.support import TESTFN, run_unittest, cpython_only
+from test.support import run_unittest, cpython_only
from test.support import threading_helper
+from test.support.os_helper import TESTFN
+
try:
select.poll
import unittest
from test import libregrtest
from test import support
+from test.support import os_helper
from test.libregrtest import utils
self.assertEqual(ns.ignore_tests, ['pattern'])
self.checkError([opt], 'expected one argument')
- self.addCleanup(support.unlink, support.TESTFN)
- with open(support.TESTFN, "w") as fp:
+ self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+ with open(os_helper.TESTFN, "w") as fp:
print('matchfile1', file=fp)
print('matchfile2', file=fp)
- filename = os.path.abspath(support.TESTFN)
+ filename = os.path.abspath(os_helper.TESTFN)
ns = libregrtest._parse_args(['-m', 'match',
'--ignorefile', filename])
self.assertEqual(ns.ignore_tests,
'-m', 'pattern2'])
self.assertEqual(ns.match_tests, ['pattern1', 'pattern2'])
- self.addCleanup(support.unlink, support.TESTFN)
- with open(support.TESTFN, "w") as fp:
+ self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+ with open(os_helper.TESTFN, "w") as fp:
print('matchfile1', file=fp)
print('matchfile2', file=fp)
- filename = os.path.abspath(support.TESTFN)
+ filename = os.path.abspath(os_helper.TESTFN)
ns = libregrtest._parse_args(['-m', 'match',
'--matchfile', filename])
self.assertEqual(ns.match_tests,
def test_testdir(self):
ns = libregrtest._parse_args(['--testdir', 'foo'])
- self.assertEqual(ns.testdir, os.path.join(support.SAVEDCWD, 'foo'))
+ self.assertEqual(ns.testdir, os.path.join(os_helper.SAVEDCWD, 'foo'))
self.checkError(['--testdir'], 'expected one argument')
def test_runleaks(self):
with self.subTest(opt=opt):
ns = libregrtest._parse_args([opt, 'foo'])
self.assertEqual(ns.coverdir,
- os.path.join(support.SAVEDCWD, 'foo'))
+ os.path.join(os_helper.SAVEDCWD, 'foo'))
self.checkError([opt], 'expected one argument')
def test_nocoverdir(self):
self.testdir = os.path.realpath(os.path.dirname(__file__))
self.tmptestdir = tempfile.mkdtemp()
- self.addCleanup(support.rmtree, self.tmptestdir)
+ self.addCleanup(os_helper.rmtree, self.tmptestdir)
def create_test(self, name=None, code=None):
if not name:
name = self.TESTNAME_PREFIX + name
path = os.path.join(self.tmptestdir, name + '.py')
- self.addCleanup(support.unlink, path)
+ self.addCleanup(os_helper.unlink, path)
# Use 'x' mode to ensure that we do not override existing tests
try:
with open(path, 'x', encoding='utf-8') as fp:
# Write the list of files using a format similar to regrtest output:
# [1/2] test_1
# [2/2] test_2
- filename = support.TESTFN
- self.addCleanup(support.unlink, filename)
+ filename = os_helper.TESTFN
+ self.addCleanup(os_helper.unlink, filename)
# test format '0:00:00 [2/7] test_opcodes -- test_grammar took 0 sec'
with open(filename, "w") as fp:
test = self.create_test('huntrleaks', code=code)
filename = 'reflog.txt'
- self.addCleanup(support.unlink, filename)
+ self.addCleanup(os_helper.unlink, filename)
output = self.run_tests('--huntrleaks', '3:3:', test,
exitcode=2,
stderr=subprocess.STDOUT)
testname = self.create_test(code=code)
# only run a subset
- filename = support.TESTFN
- self.addCleanup(support.unlink, filename)
+ filename = os_helper.TESTFN
+ self.addCleanup(os_helper.unlink, filename)
subset = [
# only ignore the method name
self.assertEqual(methods, all_methods)
# only run a subset
- filename = support.TESTFN
- self.addCleanup(support.unlink, filename)
+ filename = os_helper.TESTFN
+ self.addCleanup(os_helper.unlink, filename)
subset = [
# only match the method name
import textwrap
from test import support, mock_socket
from test.support import socket_helper
+from test.support import warnings_helper
import socket
import io
import smtpd
b'recognized\r\n')
def test_attribute_deprecations(self):
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
spam = self.channel._SMTPChannel__server
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
self.channel._SMTPChannel__server = 'spam'
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
spam = self.channel._SMTPChannel__line
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
self.channel._SMTPChannel__line = 'spam'
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
spam = self.channel._SMTPChannel__state
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
self.channel._SMTPChannel__state = 'spam'
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
spam = self.channel._SMTPChannel__greeting
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
self.channel._SMTPChannel__greeting = 'spam'
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
spam = self.channel._SMTPChannel__mailfrom
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
self.channel._SMTPChannel__mailfrom = 'spam'
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
spam = self.channel._SMTPChannel__rcpttos
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
self.channel._SMTPChannel__rcpttos = 'spam'
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
spam = self.channel._SMTPChannel__data
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
self.channel._SMTPChannel__data = 'spam'
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
spam = self.channel._SMTPChannel__fqdn
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
self.channel._SMTPChannel__fqdn = 'spam'
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
spam = self.channel._SMTPChannel__peer
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
self.channel._SMTPChannel__peer = 'spam'
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
spam = self.channel._SMTPChannel__conn
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
self.channel._SMTPChannel__conn = 'spam'
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
spam = self.channel._SMTPChannel__addr
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
self.channel._SMTPChannel__addr = 'spam'
@unittest.skipUnless(socket_helper.IPV6_ENABLED, "IPv6 not enabled")
from test import support
+from test.support import warnings_helper
import decimal
import enum
import locale
# not change output based on its value and no test for year
# because systems vary in their support for year 0.
expected = "2000 01 01 00 00 00 1 001"
- with support.check_warnings():
+ with warnings_helper.check_warnings():
result = time.strftime("%Y %m %d %H %M %S %w %j", (2000,)+(0,)*8)
self.assertEqual(expected, result)
import unicodedata
import unittest
-from test.support import (run_unittest, rmtree, change_cwd,
- TESTFN_UNICODE, TESTFN_UNENCODABLE, create_empty_file)
+from test.support import run_unittest
+from test.support.os_helper import (rmtree, change_cwd, TESTFN_UNICODE,
+ TESTFN_UNENCODABLE, create_empty_file)
+
if not os.path.supports_unicode_filenames:
try:
import unittest
from unittest.mock import patch
from test import support
+from test.support import os_helper
+from test.support import warnings_helper
import os
try:
import ssl
def FancyURLopener():
- with support.check_warnings(
+ with warnings_helper.check_warnings(
('FancyURLopener style of invoking requests is deprecated.',
DeprecationWarning)):
return urllib.request.FancyURLopener()
# Create a temp file to use for testing
self.text = bytes("test_urllib: %s\n" % self.__class__.__name__,
"ascii")
- f = open(support.TESTFN, 'wb')
+ f = open(os_helper.TESTFN, 'wb')
try:
f.write(self.text)
finally:
f.close()
- self.pathname = support.TESTFN
+ self.pathname = os_helper.TESTFN
self.quoted_pathname = urllib.parse.quote(self.pathname)
self.returned_obj = urlopen("file:%s" % self.quoted_pathname)
def tearDown(self):
"""Shut down the open object"""
self.returned_obj.close()
- os.remove(support.TESTFN)
+ os.remove(os_helper.TESTFN)
def test_interface(self):
# Make sure object returned by urlopen() has the specified methods
def setUp(self):
# Records changes to env vars
- self.env = support.EnvironmentVarGuard()
+ self.env = os_helper.EnvironmentVarGuard()
# Delete all proxy related env vars
for k in list(os.environ):
if 'proxy' in k.lower():
self.unfakehttp()
def test_URLopener_deprecation(self):
- with support.check_warnings(('',DeprecationWarning)):
+ with warnings_helper.check_warnings(('',DeprecationWarning)):
urllib.request.URLopener()
@unittest.skipUnless(ssl, "ssl module required")
def test_cafile_and_context(self):
context = ssl.create_default_context()
- with support.check_warnings(('', DeprecationWarning)):
+ with warnings_helper.check_warnings(('', DeprecationWarning)):
with self.assertRaises(ValueError):
urllib.request.urlopen(
"https://localhost", cafile="/nonexistent/path", context=context
self.tempFiles = []
# Create a temporary file.
- self.registerFileForCleanUp(support.TESTFN)
+ self.registerFileForCleanUp(os_helper.TESTFN)
self.text = b'testing urllib.urlretrieve'
try:
- FILE = open(support.TESTFN, 'wb')
+ FILE = open(os_helper.TESTFN, 'wb')
FILE.write(self.text)
FILE.close()
finally:
def test_basic(self):
# Make sure that a local file just gets its own location returned and
# a headers value is returned.
- result = urllib.request.urlretrieve("file:%s" % support.TESTFN)
- self.assertEqual(result[0], support.TESTFN)
+ result = urllib.request.urlretrieve("file:%s" % os_helper.TESTFN)
+ self.assertEqual(result[0], os_helper.TESTFN)
self.assertIsInstance(result[1], email.message.Message,
"did not get an email.message.Message instance "
"as second returned value")
def test_copy(self):
# Test that setting the filename argument works.
- second_temp = "%s.2" % support.TESTFN
+ second_temp = "%s.2" % os_helper.TESTFN
self.registerFileForCleanUp(second_temp)
result = urllib.request.urlretrieve(self.constructLocalFileUrl(
- support.TESTFN), second_temp)
+ os_helper.TESTFN), second_temp)
self.assertEqual(second_temp, result[0])
self.assertTrue(os.path.exists(second_temp), "copy of the file was not "
"made")
self.assertIsInstance(file_size, int)
self.assertEqual(block_count, count_holder[0])
count_holder[0] = count_holder[0] + 1
- second_temp = "%s.2" % support.TESTFN
+ second_temp = "%s.2" % os_helper.TESTFN
self.registerFileForCleanUp(second_temp)
urllib.request.urlretrieve(
- self.constructLocalFileUrl(support.TESTFN),
+ self.constructLocalFileUrl(os_helper.TESTFN),
second_temp, hooktester)
def test_reporthook_0_bytes(self):
_report.append((block_count, block_read_size, file_size))
srcFileName = self.createNewTempFile()
urllib.request.urlretrieve(self.constructLocalFileUrl(srcFileName),
- support.TESTFN, hooktester)
+ os_helper.TESTFN, hooktester)
self.assertEqual(len(report), 1)
self.assertEqual(report[0][2], 0)
_report.append((block_count, block_read_size, file_size))
srcFileName = self.createNewTempFile(b"x" * 5)
urllib.request.urlretrieve(self.constructLocalFileUrl(srcFileName),
- support.TESTFN, hooktester)
+ os_helper.TESTFN, hooktester)
self.assertEqual(len(report), 2)
self.assertEqual(report[0][2], 5)
self.assertEqual(report[1][2], 5)
_report.append((block_count, block_read_size, file_size))
srcFileName = self.createNewTempFile(b"x" * 8193)
urllib.request.urlretrieve(self.constructLocalFileUrl(srcFileName),
- support.TESTFN, hooktester)
+ os_helper.TESTFN, hooktester)
self.assertEqual(len(report), 3)
self.assertEqual(report[0][2], 8193)
self.assertEqual(report[0][1], 8192)
class DummyURLopener(urllib.request.URLopener):
def open_spam(self, url):
return url
- with support.check_warnings(
+ with warnings_helper.check_warnings(
('DummyURLopener style of invoking requests is deprecated.',
DeprecationWarning)):
self.assertEqual(DummyURLopener().open(
"spam://c:|windows%/:=&?~#+!$,;'@()*[]|/path/"),
"//c:|windows%/:=&?~#+!$,;'@()*[]|/path/")
- @support.ignore_warnings(category=DeprecationWarning)
+ @warnings_helper.ignore_warnings(category=DeprecationWarning)
def test_urlopener_retrieve_file(self):
- with support.temp_dir() as tmpdir:
+ with os_helper.temp_dir() as tmpdir:
fd, tmpfile = tempfile.mkstemp(dir=tmpdir)
os.close(fd)
fileurl = "file:" + urllib.request.pathname2url(tmpfile)
# Some buildbots have TEMP folder that uses a lowercase drive letter.
self.assertEqual(os.path.normcase(filename), os.path.normcase(tmpfile))
- @support.ignore_warnings(category=DeprecationWarning)
+ @warnings_helper.ignore_warnings(category=DeprecationWarning)
def test_urlopener_retrieve_remote(self):
url = "http://www.python.org/file.txt"
self.fakehttp(b"HTTP/1.1 200 OK\r\n\r\nHello!")
filename, _ = urllib.request.URLopener().retrieve(url)
self.assertEqual(os.path.splitext(filename)[1], ".txt")
- @support.ignore_warnings(category=DeprecationWarning)
+ @warnings_helper.ignore_warnings(category=DeprecationWarning)
def test_local_file_open(self):
# bpo-35907, CVE-2019-9948: urllib must reject local_file:// scheme
class DummyURLopener(urllib.request.URLopener):
import inspect
import linecache
import unittest
+from test.support import os_helper
from test.support.script_helper import (spawn_python, kill_python, assert_python_ok,
make_script, make_zip_script)
def test_inspect_getsource_issue4223(self):
test_src = "def foo(): pass\n"
- with test.support.temp_dir() as d:
+ with os_helper.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 test.support.temp_dir() as d:
+ with os_helper.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 test.support.temp_dir() as d:
+ with os_helper.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 test.support.temp_dir() as d:
+ with os_helper.temp_dir() as d:
script_name = make_script(d, 'script', test_src)
p = spawn_python(script_name)
p.stdin.write(b'l\n')
projects / thirdparty / Python / cpython.git / commitdiff
