test — Regression tests package for PythonPython回归测试包

Note

The test package is meant for internal use by Python only. test包只供Python内部使用。It is documented for the benefit of the core developers of Python. 它是为了Python的核心开发人员而编写的。Any use of this package outside of Python’s standard library is discouraged as code mentioned here can change or be removed without notice between releases of Python.不鼓励在Python的标准库之外使用此包，因为这里提到的代码可以在Python的不同版本之间更改或删除，恕不另行通知。

The test package contains all regression tests for Python as well as the modules test.support and test.regrtest. test包包含Python的所有回归测试以及模块test.support和test.regrtest。test.support is used to enhance your tests while test.regrtest drives the testing suite.用于在test.regrtest驱动测试套件时增强测试。

Each module in the test package whose name starts with test_ is a testing suite for a specific module or feature. test包中名称以test_开头的每个模块都是特定模块或功能的测试套件。All new tests should be written using the unittest or doctest module. 所有新的测试都应该使用unittest或doctest模块编写。Some older tests are written using a “traditional” testing style that compares output printed to sys.stdout; this style of test is considered deprecated.一些旧的测试是使用“传统”测试风格编写的，它将打印到sys.stdout的输出进行比较；这种类型的测试被认为是不推荐的。

See also

Module unittest

Writing PyUnit regression tests.编写PyUnit回归测试。

Module doctest

Tests embedded in documentation strings.嵌入在文档字符串中的测试。

Writing Unit Tests for the test package为test包编写单元测试

It is preferred that tests that use the unittest module follow a few guidelines. 使用unittest模块的测试最好遵循一些准则。One is to name the test module by starting it with test_ and end it with the name of the module being tested. 一种是通过以test_开头并以被测试模块的名称结束来命名测试模块。The test methods in the test module should start with test_ and end with a description of what the method is testing. 测试模块中的测试方法应以test_开始，并以方法测试内容的描述结束。This is needed so that the methods are recognized by the test driver as test methods. 这是必要的，以便测试驱动程序将这些方法识别为测试方法。Also, no documentation string for the method should be included. 此外，不应包含该方法的文档字符串。A comment (such as # Tests function returns only True or False) should be used to provide documentation for test methods. 注释（如# Tests function returns only True or False）应用于提供测试方法的文档。This is done because documentation strings get printed out if they exist and thus what test is being run is not stated.这样做是因为文档字符串在存在时会打印出来，因此没有说明正在运行什么测试。

A basic boilerplate is often used:通常使用基本样板：

import unittest
from test import support
class MyTestCase1(unittest.TestCase):

    # Only use setUp() and tearDown() if necessary

    def setUp(self):
        ... code to execute in preparation for tests ...

    def tearDown(self):
        ... code to execute to clean up after tests ...

    def test_feature_one(self):
        # Test feature one.
        ... testing code ...

    def test_feature_two(self):
        # Test feature two.
        ... testing code ...

    ... more test methods ...

class MyTestCase2(unittest.TestCase):
    ... same structure as MyTestCase1 ...

... more test classes ...

if __name__ == '__main__':
    unittest.main()

This code pattern allows the testing suite to be run by test.regrtest, on its own as a script that supports the unittest CLI, or via the python -m unittest CLI.此代码模式允许test.regrtest单独运行测试套件，将其作为支持unittest CLI的脚本运行，或通过python -m unittest CLI运行。

The goal for regression testing is to try to break code. 回归测试的目标是尝试破坏代码。This leads to a few guidelines to be followed:这就需要遵循一些准则：

  • The testing suite should exercise all classes, functions, and constants. 测试套件应使用所有类、函数和常量。This includes not just the external API that is to be presented to the outside world but also “private” code.这不仅包括要呈现给外部世界的外部API，还包括“私有”代码。

  • Whitebox testing (examining the code being tested when the tests are being written) is preferred. 首选白盒测试（在编写测试时检查正在测试的代码）。Blackbox testing (testing only the published user interface) is not complete enough to make sure all boundary and edge cases are tested.黑盒测试（仅测试已发布的用户界面）不够完整，无法确保测试所有边界和边缘情况。

  • Make sure all possible values are tested including invalid ones. 确保测试了所有可能的值，包括无效值。This makes sure that not only all valid values are acceptable but also that improper values are handled correctly.这确保不仅所有有效值都是可接受的，而且正确处理不正确的值。

  • Exhaust as many code paths as possible. 尽可能多地排出代码路径。Test where branching occurs and thus tailor input to make sure as many different paths through the code are taken.测试分支发生的位置，从而调整输入，以确保通过代码的路径尽可能多。

  • Add an explicit test for any bugs discovered for the tested code. 为测试代码中发现的任何错误添加显式测试。This will make sure that the error does not crop up again if the code is changed in the future.这将确保在将来更改代码时不会再次出现错误。

  • Make sure to clean up after your tests (such as close and remove all temporary files).确保在测试后进行清理（例如关闭并删除所有临时文件）。

  • If a test is dependent on a specific condition of the operating system then verify the condition already exists before attempting the test.如果测试依赖于操作系统的特定条件，则在尝试测试之前验证该条件是否已存在。

  • Import as few modules as possible and do it as soon as possible. 导入尽可能少的模块，并尽快完成。This minimizes external dependencies of tests and also minimizes possible anomalous behavior from side-effects of importing a module.这最小化了测试的外部依赖性，也最小化了导入模块的副作用可能导致的异常行为。

  • Try to maximize code reuse. 尽量最大化代码重用。On occasion, tests will vary by something as small as what type of input is used. 有时，测试会因使用哪种类型的输入而有所不同。Minimize code duplication by subclassing a basic test class with a class that specifies the input:通过使用指定输入的类子类化基本测试类来最小化代码重复：

    class TestFuncAcceptsSequencesMixin:
        func = mySuperWhammyFunction

        def test_func(self):
            self.func(self.arg)

    class AcceptLists(TestFuncAcceptsSequencesMixin, unittest.TestCase):
        arg = [1, 2, 3]

    class AcceptStrings(TestFuncAcceptsSequencesMixin, unittest.TestCase):
        arg = 'abc'

    class AcceptTuples(TestFuncAcceptsSequencesMixin, unittest.TestCase):
        arg = (1, 2, 3)

    When using this pattern, remember that all classes that inherit from unittest.TestCase are run as tests. 使用此模式时，请记住从unittest.TestCase继承的所有类都作为测试运行。The Mixin class in the example above does not have any data and so can’t be run by itself, thus it does not inherit from unittest.TestCase.上面示例中的Mixin类没有任何数据，因此不能单独运行，因此它不会从unittest.TestCase继承。

See also另见

Test Driven Development测试驱动开发

A book by Kent Beck on writing tests before code.Kent Beck写的一本关于在编写代码之前编写测试的书。

Running tests using the command-line interface使用命令行界面运行测试

The test package can be run as a script to drive Python’s regression test suite, thanks to the -m option: python -m test. test包可以作为脚本运行，以驱动Python的回归测试套件，这要归功于-m选项：Python-m测试。Under the hood, it uses test.regrtest; the call python -m test.regrtest used in previous Python versions still works. 在发动机罩下，它使用test.regrtest；在以前的python版本中使用的调用python -m test.gregtest仍然有效。Running the script by itself automatically starts running all regression tests in the test package. 单独运行脚本会自动开始运行test包中的所有回归测试。It does this by finding all modules in the package whose name starts with test_, importing them, and executing the function test_main() if present or loading the tests via unittest.TestLoader.loadTestsFromModule if test_main does not exist. 它通过查找包中名称以test_开头的所有模块，导入它们，并执行函数test_main()（如果test_main存在），或者通过unittest.TestLoader.loadTestsFromModule加载测试（如果test_main不存在）。The names of tests to execute may also be passed to the script. Specifying a single regression test (python -m test test_spam) will minimize output and only print whether the test passed or failed.

Running test directly allows what resources are available for tests to use to be set. 直接运行test允许设置可供测试使用的资源。You do this by using the -u command-line option. 您可以使用-u命令行选项来执行此操作。Specifying all as the value for the -u option enables all possible resources: python -m test -uall. 指定all作为-u选项的值将启用所有可能的资源：python-m test -ual。If all but one resource is desired (a more common case), a comma-separated list of resources that are not desired may be listed after all. 如果只需要一个资源（更常见的情况），则可以在all后面列出不需要的资源的逗号分隔列表。The command python -m test -uall,-audio,-largefile will run test with all resources except the audio and largefile resources. 命令python -m test -uall,-audio,-largefile将使用除audio和largefile资源之外的所有资源运行test。For a list of all resources and more command-line options, run python -m test -h.要获得所有资源和更多命令行选项的列表，请运行python -m test -h。

Some other ways to execute the regression tests depend on what platform the tests are being executed on. 执行回归测试的其他一些方式取决于测试在哪个平台上执行。On Unix, you can run make test at the top-level directory where Python was built. 在Unix上，您可以在构建Python的顶级目录下运行make test。On Windows, executing rt.bat from your PCbuild directory will run all regression tests.在Windows上，从PCbuild目录执行rt.bat将运行所有回归测试。

test.support — Utilities for the Python test suitePython测试套件的实用程序

The test.support module provides support for Python’s regression test suite.test.support模块为Python的回归测试套件提供支持。

Note

test.support is not a public module. 不是公共模块。It is documented here to help Python developers write tests. 这里记录了它，以帮助Python开发人员编写测试。The API of this module is subject to change without backwards compatibility concerns between releases.此模块的API可能会更改，版本之间不会存在向后兼容性问题。

This module defines the following exceptions:

exceptiontest.support.TestFailed

Exception to be raised when a test fails. This is deprecated in favor of unittest-based tests and unittest.TestCase’s assertion methods.测试失败时引发的异常。为了支持基于unittest的测试和unittest.TestCase的断言方法，这是不推荐的。

exceptiontest.support.ResourceDenied

Subclass of unittest.SkipTest. unittest.SkipTest的子类。Raised when a resource (such as a network connection) is not available. 当资源（如网络连接）不可用时引发。Raised by the requires() function.由requires()函数引发。

The test.support module defines the following constants:test.support模块定义以下常量：

test.support.verbose

True when verbose output is enabled. 启用详细输出时为True。Should be checked when more detailed information is desired about a running test. 当需要关于运行测试的更详细信息时，应检查。verbose is set by test.regrtest.由test.regrtest设置。

test.support.is_jython

True if the running interpreter is Jython.如果运行的解释器是Jython，则为True。

test.support.is_android

True if the system is Android.如果系统是Android，则为True。

test.support.unix_shell

Path for shell if not on Windows; otherwise None.外壳的路径（如果不在Windows上）；否则为None。

test.support.LOOPBACK_TIMEOUT

Timeout in seconds for tests using a network server listening on the network local loopback interface like 127.0.0.1.使用网络服务器侦听网络本地环回接口（如127.0.0.1）的测试超时（秒）。

The timeout is long enough to prevent test failure: it takes into account that the client and the server can run in different threads or even different processes.超时时间足够长，可以防止测试失败：它考虑到客户端和服务器可以在不同的线程甚至不同的进程中运行。

The timeout should be long enough for connect(), recv() and send() methods of socket.socket.对于socket.socket的connect()、recv()和send()方法，超时应该足够长。

Its default value is 5 seconds.其默认值为5秒。

See also INTERNET_TIMEOUT.另请参见INTERNET_TIMEOUT。

test.support.INTERNET_TIMEOUT

Timeout in seconds for network requests going to the internet.网络请求到internet的超时（秒）。

The timeout is short enough to prevent a test to wait for too long if the internet request is blocked for whatever reason.超时时间足够短，以防止在internet请求因任何原因被阻止时测试等待太长时间。

Usually, a timeout using INTERNET_TIMEOUT should not mark a test as failed, but skip the test instead: see transient_internet().通常，使用INTERNET_TIMEOUT的超时不应将测试标记为失败，而应跳过测试：请参阅transient_internet()。

Its default value is 1 minute.

See also LOOPBACK_TIMEOUT.

test.support.SHORT_TIMEOUT

Timeout in seconds to mark a test as failed if the test takes “too long”.如果测试花费“太长”，则将测试标记为失败的超时（秒）。

The timeout value depends on the regrtest --timeout command line option.超时值取决于regrtest--timeout命令行选项。

If a test using SHORT_TIMEOUT starts to fail randomly on slow buildbots, use LONG_TIMEOUT instead.如果使用SHORT_TIMEOUT的测试在慢速构建机器人上开始随机失败，请改用LONG_TIMEOUT。

Its default value is 30 seconds.其默认值为30秒。

test.support.LONG_TIMEOUT

Timeout in seconds to detect when a test hangs.检测测试何时挂起的超时（秒）。

It is long enough to reduce the risk of test failure on the slowest Python buildbots. 它足够长，可以降低最慢的Python构建机器人上测试失败的风险。It should not be used to mark a test as failed if the test takes “too long”. 如果测试时间“过长”，则不应将其标记为失败。The timeout value depends on the regrtest --timeout command line option.超时值取决于regrtest--timeout命令行选项。

Its default value is 5 minutes.其默认值为5分钟。

See also LOOPBACK_TIMEOUT, INTERNET_TIMEOUT and SHORT_TIMEOUT.另请参阅LOOPBACK_TIMEOUT、INTERNET_TIMEOUT和SHORT_TIMEOUT。

test.support.PGO

Set when tests can be skipped when they are not useful for PGO.设置当测试对PGO不可用时可以跳过测试的时间。

test.support.PIPE_MAX_SIZE

A constant that is likely larger than the underlying OS pipe buffer size, to make writes blocking.一个可能大于底层操作系统管道缓冲区大小的常数，用于阻止写入。

test.support.SOCK_MAX_SIZE

A constant that is likely larger than the underlying OS socket buffer size, to make writes blocking.一个可能大于底层操作系统套接字缓冲区大小的常数，用于阻止写入。

test.support.TEST_SUPPORT_DIR

Set to the top level directory that contains test.support.设置为包含test.support的顶级目录。

test.support.TEST_HOME_DIR

Set to the top level directory for the test package.设置为测试包的顶级目录。

test.support.TEST_DATA_DIR

Set to the data directory within the test package.设置为测试包中的data目录。

test.support.MAX_Py_ssize_t

Set to sys.maxsize for big memory tests.对于大内存测试，设置为sys.maxsize。

test.support.max_memuse

Set by set_memlimit() as the memory limit for big memory tests. 通过set_memlimit()设置为大内存测试的内存限制。Limited by MAX_Py_ssize_t.受MAX_Py_ssize_t限制。

test.support.real_max_memuse

Set by set_memlimit() as the memory limit for big memory tests. 通过set_memlimit()设置为大内存测试的内存限制。Not limited by MAX_Py_ssize_t.不受MAX_Py_ssize_t限制。

test.support.MISSING_C_DOCSTRINGS

Return True if running on CPython, not on Windows, and configuration not set with WITH_DOC_STRINGS.如果在CPython上运行，而不是在Windows上运行，并且配置未设置为WITH_DOC_STRINGS，则返回True。

test.support.HAVE_DOCSTRINGS

Check for presence of docstrings.检查是否存在文档字符串。

test.support.TEST_HTTP_URL

Define the URL of a dedicated HTTP server for the network tests.为网络测试定义专用HTTP服务器的URL。

test.support.ALWAYS_EQ

Object that is equal to anything. Used to test mixed type comparison.等于任何东西的对象。用于测试混合类型比较。

test.support.NEVER_EQ

Object that is not equal to anything (even to ALWAYS_EQ). 对象不等于任何值（甚至等于ALWAYS_EQ）。Used to test mixed type comparison.用于测试混合类型比较。

test.support.LARGEST

Object that is greater than anything (except itself). Used to test mixed type comparison.大于任何东西（除自身外）的对象。用于测试混合类型比较。

test.support.SMALLEST

Object that is less than anything (except itself). Used to test mixed type comparison.小于任何值（除了自身）的对象。用于测试混合类型比较。

The test.support module defines the following functions:test.support模块定义了以下功能：

test.support.is_resource_enabled(resource)

Return True if resource is enabled and available. The list of available resources is only set when test.regrtest is executing the tests.

test.support.python_is_optimized()

Return True if Python was not built with -O0 or -Og.如果Python不是用-O0或-Og构建的，则返回True。

test.support.with_pymalloc()

Return _testcapi.WITH_PYMALLOC.返回_testcapi.WITH_PYMALLOC。

test.support.requires(resource, msg=None)

Raise ResourceDenied if resource is not available. msg is the argument to ResourceDenied if it is raised. Always returns True if called by a function whose __name__ is '__main__'. Used when tests are executed by test.regrtest.

test.support.system_must_validate_cert(f)

Raise unittest.SkipTest on TLS certification validation failures.

test.support.sortdict(dict)

Return a repr of dict with keys sorted.返回已排序关键字的dict的repr。

test.support.findfile(filename, subdir=None)

Return the path to the file named filename. If no match is found filename is returned. This does not equal a failure since it could be the path to the file.

Setting subdir indicates a relative path to use to find the file rather than looking directly in the path directories.

test.support.match_test(test)

Match test to patterns set in set_match_tests().

test.support.set_match_tests(patterns)

Define match test with regular expression patterns.

test.support.run_unittest(*classes)

Execute unittest.TestCase subclasses passed to the function. The function scans the classes for methods starting with the prefix test_ and executes the tests individually.

It is also legal to pass strings as parameters; these should be keys in sys.modules. Each associated module will be scanned by unittest.TestLoader.loadTestsFromModule(). This is usually seen in the following test_main() function:

def test_main():
    support.run_unittest(__name__)

This will run all tests defined in the named module.这将运行命名模块中定义的所有测试。

test.support.run_doctest(module, verbosity=None, optionflags=0)

Run doctest.testmod() on the given module. Return (failure_count, test_count).

If verbosity is None, doctest.testmod() is run with verbosity set to verbose. Otherwise, it is run with verbosity set to None. optionflags is passed as optionflags to doctest.testmod().

test.support.setswitchinterval(interval)

Set the sys.setswitchinterval() to the given interval. Defines a minimum interval for Android systems to prevent the system from hanging.

test.support.check_impl_detail(**guards)

Use this check to guard CPython’s implementation-specific tests or to run them only on the implementations guarded by the arguments:使用此检查来保护CPython的特定于实现的测试，或者仅在由参数保护的实现上运行这些测试：

check_impl_detail()               # Only on CPython (default).
check_impl_detail(jython=True)    # Only on Jython.
check_impl_detail(cpython=False)  # Everywhere except CPython.
test.support.set_memlimit(limit)

Set the values for max_memuse and real_max_memuse for big memory tests.

test.support.record_original_stdout(stdout)

Store the value from stdout. It is meant to hold the stdout at the time the regrtest began.

test.support.get_original_stdout()

Return the original stdout set by record_original_stdout() or sys.stdout if it’s not set.

test.support.args_from_interpreter_flags()

Return a list of command line arguments reproducing the current settings in sys.flags and sys.warnoptions.返回在sys.flags和sys.warnoptions中再现当前设置的命令行参数列表。

test.support.optim_args_from_interpreter_flags()

Return a list of command line arguments reproducing the current optimization settings in sys.flags.返回在sys.flags中再现当前优化设置的命令行参数列表。

test.support.captured_stdin()
test.support.captured_stdout()
test.support.captured_stderr()

A context managers that temporarily replaces the named stream with io.StringIO object.

Example use with output streams:用于输出流的示例：

with captured_stdout() as stdout, captured_stderr() as stderr:
    print("hello")
    print("error", file=sys.stderr)
assert stdout.getvalue() == "hello\n"
assert stderr.getvalue() == "error\n"

Example use with input stream:与输入流一起使用的示例：

with captured_stdin() as stdin:
    stdin.write('hello\n')
    stdin.seek(0)
    # call test code that consumes from sys.stdin
    captured = input()
self.assertEqual(captured, "hello")
test.support.disable_faulthandler()

A context manager that replaces sys.stderr with sys.__stderr__.

test.support.gc_collect()

Force as many objects as possible to be collected. This is needed because timely deallocation is not guaranteed by the garbage collector. This means that __del__ methods may be called later than expected and weakrefs may remain alive for longer than expected.

test.support.disable_gc()

A context manager that disables the garbage collector upon entry and reenables it upon exit.上下文管理器，在进入时禁用垃圾收集器，在退出时重新启用垃圾收集器。

test.support.swap_attr(obj, attr, new_val)

Context manager to swap out an attribute with a new object.上下文管理器将属性与新对象交换。

Usage:

with swap_attr(obj, "attr", 5):
    ...

This will set obj.attr to 5 for the duration of the with block, restoring the old value at the end of the block. If attr doesn’t exist on obj, it will be created and then deleted at the end of the block.

The old value (or None if it doesn’t exist) will be assigned to the target of the “as” clause, if there is one.

test.support.swap_item(obj, attr, new_val)

Context manager to swap out an item with a new object.上下文管理器将项与新对象交换。

Usage:

with swap_item(obj, "item", 5):
    ...

This will set obj["item"] to 5 for the duration of the with block, restoring the old value at the end of the block. If item doesn’t exist on obj, it will be created and then deleted at the end of the block.

The old value (or None if it doesn’t exist) will be assigned to the target of the “as” clause, if there is one.

test.support.print_warning(msg)

Print a warning into sys.__stderr__. Format the message as: f"Warning -- {msg}". If msg is made of multiple lines, add "Warning -- " prefix to each line.

New in version 3.9.版本3.9中新增。

test.support.wait_process(pid, *, exitcode, timeout=None)

Wait until process pid completes and check that the process exit code is exitcode.等待进程pid完成，并检查进程退出代码是否为exitcode。

Raise an AssertionError if the process exit code is not equal to exitcode.

If the process runs longer than timeout seconds (SHORT_TIMEOUT by default), kill the process and raise an AssertionError. The timeout feature is not available on Windows.

New in version 3.9.版本3.9中新增。

test.support.calcobjsize(fmt)

Return struct.calcsize() for nP{fmt}0n or, if gettotalrefcount exists, 2PnP{fmt}0P.

test.support.calcvobjsize(fmt)

Return struct.calcsize() for nPn{fmt}0n or, if gettotalrefcount exists, 2PnPn{fmt}0P.

test.support.checksizeof(test, o, size)

For testcase test, assert that the sys.getsizeof for o plus the GC header size equals size.

@test.support.anticipate_failure(condition)

A decorator to conditionally mark tests with unittest.expectedFailure(). Any use of this decorator should have an associated comment identifying the relevant tracker issue.

@test.support.run_with_locale(catstr, *locales)

A decorator for running a function in a different locale, correctly resetting it after it has finished. 用于在不同区域设置中运行函数，并在完成后正确重置该函数的修饰符。catstr is the locale category as a string (for example "LC_ALL"). 是字符串形式的区域设置类别（例如“LC_ALL”）。The locales passed will be tried sequentially, and the first valid locale will be used.传递的locales将按顺序尝试，并将使用第一个有效的区域设置。

@test.support.run_with_tz(tz)

A decorator for running a function in a specific timezone, correctly resetting it after it has finished.用于在特定时区中运行函数，并在完成后正确重置函数的修饰符。

@test.support.requires_freebsd_version(*min_version)

Decorator for the minimum version when running test on FreeBSD. 在FreeBSD上运行测试时最低版本的装饰器。If the FreeBSD version is less than the minimum, raise unittest.SkipTest.

@test.support.requires_linux_version(*min_version)

Decorator for the minimum version when running test on Linux. 在Linux上运行测试时的最低版本的装饰器。If the Linux version is less than the minimum, raise unittest.SkipTest.

@test.support.requires_mac_version(*min_version)

Decorator for the minimum version when running test on macOS. 在macOS上运行测试时的最低版本的装饰器。If the macOS version is less than the minimum, raise unittest.SkipTest.

@test.support.requires_IEEE_754

Decorator for skipping tests on non-IEEE 754 platforms.用于跳过非IEEE 754平台上的测试的装饰器。

@test.support.requires_zlib

Decorator for skipping tests if zlib doesn’t exist.如果zlib不存在，则跳过测试的装饰器。

@test.support.requires_gzip

Decorator for skipping tests if gzip doesn’t exist.

@test.support.requires_bz2

Decorator for skipping tests if bz2 doesn’t exist.

@test.support.requires_lzma

Decorator for skipping tests if lzma doesn’t exist.

@test.support.requires_resource(resource)

Decorator for skipping tests if resource is not available.用于在资源不可用时跳过测试的装饰器。

@test.support.requires_docstrings

Decorator for only running the test if HAVE_DOCSTRINGS.

@test.support.cpython_only(test)

Decorator for tests only applicable to CPython.仅适用于CPython的测试装饰器。

@test.support.impl_detail(msg=None, **guards)

Decorator for invoking check_impl_detail() on guards. If that returns False, then uses msg as the reason for skipping the test.如果返回False，则使用msg作为跳过测试的原因。

@test.support.no_tracing(func)

Decorator to temporarily turn off tracing for the duration of the test.在测试期间临时关闭跟踪的装饰器。

@test.support.refcount_test(test)

Decorator for tests which involve reference counting. 涉及引用计数的测试的装饰器。The decorator does not run the test if it is not run by CPython. 如果不是由CPython运行，则装饰器不会运行测试。Any trace function is unset for the duration of the test to prevent unexpected refcounts caused by the trace function.在测试期间，任何跟踪函数都会被取消设置，以防止跟踪函数导致意外的引用计数。

@test.support.bigmemtest(size, memuse, dry_run=True)

Decorator for bigmem tests.bigmem测试的装饰器。

size is a requested size for the test (in arbitrary, test-interpreted units.) memuse is the number of bytes per unit for the test, or a good estimate of it. For example, a test that needs two byte buffers, of 4 GiB each, could be decorated with @bigmemtest(size=_4G, memuse=2).

The size argument is normally passed to the decorated test method as an extra argument. If dry_run is True, the value passed to the test method may be less than the requested value. If dry_run is False, it means the test doesn’t support dummy runs when -M is not specified.

@test.support.bigaddrspacetest(f)

Decorator for tests that fill the address space. 填充地址空间的测试的装饰器。f is the function to wrap.是要包装的函数。

test.support.check_syntax_error(testcase, statement, errtext='', *, lineno=None, offset=None)

Test for syntax errors in statement by attempting to compile statement. testcase is the unittest instance for the test. errtext is the regular expression which should match the string representation of the raised SyntaxError. If lineno is not None, compares to the line of the exception. If offset is not None, compares to the offset of the exception.

test.support.open_urlresource(url, *args, **kw)

Open url. If open fails, raises TestFailed.

test.support.reap_children()

Use this at the end of test_main whenever sub-processes are started. This will help ensure that no extra children (zombies) stick around to hog resources and create problems when looking for refleaks.

test.support.get_attribute(obj, name)

Get an attribute, raising unittest.SkipTest if AttributeError is raised.

test.support.catch_unraisable_exception()

Context manager catching unraisable exception using sys.unraisablehook().

Storing the exception value (cm.unraisable.exc_value) creates a reference cycle. The reference cycle is broken explicitly when the context manager exits.

Storing the object (cm.unraisable.object) can resurrect it if it is set to an object which is being finalized. Exiting the context manager clears the stored object.

Usage:

with support.catch_unraisable_exception() as cm:
    # code creating an "unraisable exception"
    ...
    # check the unraisable exception: use cm.unraisable
    ...

# cm.unraisable attribute no longer exists at this point
# (to break a reference cycle)

New in version 3.8.版本3.8中新增。

test.support.load_package_tests(pkg_dir, loader, standard_tests, pattern)

Generic implementation of the unittest load_tests protocol for use in test packages. pkg_dir is the root directory of the package; loader, standard_tests, and pattern are the arguments expected by load_tests. In simple cases, the test package’s __init__.py can be the following:

import os
from test.support import load_package_tests
def load_tests(*args):
    return load_package_tests(os.path.dirname(__file__), *args)
test.support.detect_api_mismatch(ref_api, other_api, *, ignore=())

Returns the set of attributes, functions or methods of ref_api not found on other_api, except for a defined list of items to be ignored in this check specified in ignore.

By default this skips private attributes beginning with ‘_’ but includes all magic methods, i.e. those starting and ending in ‘__’.

New in version 3.5.版本3.5中新增。

test.support.patch(test_instance, object_to_patch, attr_name, new_value)

Override object_to_patch.attr_name with new_value. Also add cleanup procedure to test_instance to restore object_to_patch for attr_name. The attr_name should be a valid attribute for object_to_patch.

test.support.run_in_subinterp(code)

Run code in subinterpreter. Raise unittest.SkipTest if tracemalloc is enabled.

test.support.check_free_after_iterating(test, iter, cls, args=())

Assert that iter is deallocated after iterating.断言迭代后iter已解除分配。

test.support.missing_compiler_executable(cmd_names=[])

Check for the existence of the compiler executables whose names are listed in cmd_names or all the compiler executables when cmd_names is empty and return the first missing executable or None when none is found missing.

test.support.check__all__(test_case, module, name_of_module=None, extra=(), not_exported=())

Assert that the __all__ variable of module contains all public names.断言module的__all__变量包含所有公共名称。

The module’s public names (its API) are detected automatically based on whether they match the public name convention and were defined in module.模块的公共名称（其API）将根据它们是否符合公共名称约定并在module中定义而自动检测。

The name_of_module argument can specify (as a string or tuple thereof) what module(s) an API could be defined in order to be detected as a public API. One case for this is when module imports part of its public API from other modules, possibly a C backend (like csv and its _csv).

The extra argument can be a set of names that wouldn’t otherwise be automatically detected as “public”, like objects without a proper __module__ attribute. 额外的参数可以是一组名称，否则不会自动检测为“public”，就像没有适当的__module__属性的对象。If provided, it will be added to the automatically detected ones.如果提供，它将被添加到自动检测的数据中。

The not_exported argument can be a set of names that must not be treated as part of the public API even though their names indicate otherwise.not_exported参数可以是一组名称，这些名称不能作为公共API的一部分，即使它们的名称另有指示。

Example use:使用示例：

import bar
import foo
import unittest
from test import support
class MiscTestCase(unittest.TestCase):
    def test__all__(self):
        support.check__all__(self, foo)

class OtherTestCase(unittest.TestCase):
    def test__all__(self):
        extra = {'BAR_CONST', 'FOO_CONST'}
        not_exported = {'baz'}  # Undocumented name.
        # bar imports part of its API from _bar.
        support.check__all__(self, bar, ('bar', '_bar'),
                             extra=extra, not_exported=not_exported)

New in version 3.6.版本3.6中新增。

test.support.skip_if_broken_multiprocessing_synchronize()

Skip tests if the multiprocessing.synchronize module is missing, if there is no available semaphore implementation, or if creating a lock raises an OSError.如果缺少multiprocessing.synchronize模块，如果没有可用的信号量实现，或者如果创建锁会引发OSError，则跳过测试。

New in version 3.10.版本3.10中新增。

test.support.check_disallow_instantiation(test_case, tp, *args, **kwds)

Assert that type tp cannot be instantiated using args and kwds.断言不能使用args和kwds实例化类型tp。

New in version 3.10.版本3.10中新增。

The test.support module defines the following classes:test.support模块定义了以下类：

classtest.support.SuppressCrashReport

A context manager used to try to prevent crash dialog popups on tests that are expected to crash a subprocess.上下文管理器，用于尝试防止在预期将使子进程崩溃的测试上出现崩溃对话框。

On Windows, it disables Windows Error Reporting dialogs using SetErrorMode.在Windows上，它使用SetErrorMode禁用Windows错误报告对话框。

On UNIX, resource.setrlimit() is used to set resource.RLIMIT_CORE’s soft limit to 0 to prevent coredump file creation.在UNIX上，resource.setrlimit()用于将resource.RLIMIT_CORE的软限制设置为0，以防止创建coredump文件。

On both platforms, the old value is restored by __exit__().在两个平台上，旧值都由__exit__()恢复。

classtest.support.SaveSignals

Class to save and restore signal handlers registered by the Python signal handler.类来保存和恢复Python信号处理程序注册的信号处理程序。

classtest.support.Matcher
matches(self, d, **kwargs)

Try to match a single dict with the supplied arguments.尝试将单个dict与提供的参数匹配。

match_value(self, k, dv, v)

Try to match a single stored value (dv) with a supplied value (v).尝试将单个存储值（dv）与提供的值（v）匹配。

classtest.support.BasicTestRunner
run(test)

Run test and return the result.运行test并返回结果。

test.support.socket_helper — Utilities for socket tests套接字测试的实用程序

The test.support.socket_helper module provides support for socket tests.test.support.socket_helper模块提供对套接字测试的支持。

New in version 3.9.版本3.9中新增。

test.support.socket_helper.IPV6_ENABLED

Set to True if IPv6 is enabled on this host, False otherwise.如果在此主机上启用了IPv6，则设置为True，否则设置为False。

test.support.socket_helper.find_unused_port(family=socket.AF_INET, socktype=socket.SOCK_STREAM)

Returns an unused port that should be suitable for binding. 返回应适合绑定的未使用端口。This is achieved by creating a temporary socket with the same family and type as the sock parameter (default is AF_INET, SOCK_STREAM), and binding it to the specified host address (defaults to 0.0.0.0) with the port set to 0, eliciting an unused ephemeral port from the OS. The temporary socket is then closed and deleted, and the ephemeral port is returned.然后关闭并删除临时套接字，并返回临时端口。

Either this method or bind_port() should be used for any tests where a server socket needs to be bound to a particular port for the duration of the test. Which one to use depends on whether the calling code is creating a Python socket, or if an unused port needs to be provided in a constructor or passed to an external program (i.e. the -accept argument to openssl’s s_server mode). Always prefer bind_port() over find_unused_port() where possible. Using a hard coded port is discouraged since it can make multiple instances of the test impossible to run simultaneously, which is a problem for buildbots.不鼓励使用硬编码端口，因为它会使测试的多个实例无法同时运行，这对于构建机器人来说是一个问题。

test.support.socket_helper.bind_port(sock, host=HOST)

Bind the socket to a free port and return the port number. 将套接字绑定到空闲端口并返回端口号。Relies on ephemeral ports in order to ensure we are using an unbound port. 依赖临时端口，以确保我们使用的是未绑定端口。This is important as many tests may be running simultaneously, especially in a buildbot environment. 这很重要，因为许多测试可能同时运行，特别是在buildbot环境中。This method raises an exception if the sock.family is AF_INET and sock.type is SOCK_STREAM, and the socket has SO_REUSEADDR or SO_REUSEPORT set on it. Tests should never set these socket options for TCP/IP sockets. 测试不应为TCP/IP套接字设置这些套接字选项。The only case for setting these options is testing multicasting via multiple UDP sockets.设置这些选项的唯一情况是通过多个UDP套接字测试多播。

Additionally, if the SO_EXCLUSIVEADDRUSE socket option is available (i.e. on Windows), it will be set on the socket. 此外，如果SO_EXCLUSIVEADDRUSE套接字选项可用（即在Windows上），它将在套接字上设置。This will prevent anyone else from binding to our host/port for the duration of the test.这将防止任何其他人在测试期间绑定到主机/端口。

test.support.socket_helper.bind_unix_socket(sock, addr)

Bind a unix socket, raising unittest.SkipTest if PermissionError is raised.绑定unix套接字，如果引发PermissionError，则引发unittest.SkipTest。

@test.support.socket_helper.skip_unless_bind_unix_socket

A decorator for running tests that require a functional bind() for Unix sockets.用于运行需要Unix套接字的函数bind()的测试的修饰符。

test.support.socket_helper.transient_internet(resource_name, *, timeout=30.0, errnos=())

A context manager that raises ResourceDenied when various issues with the internet connection manifest themselves as exceptions.当internet连接的各种问题表现为异常时，上下文管理器会引发ResourceDenied。

test.support.script_helper — Utilities for the Python execution testsPython执行测试的实用程序

The test.support.script_helper module provides support for Python’s script execution tests.test.support.script_helper模块为Python的脚本执行测试提供支持。

test.support.script_helper.interpreter_requires_environment()

Return True if sys.executable interpreter requires environment variables in order to be able to run at all.如果sys.executable interpreter需要环境变量才能运行，则返回True。

This is designed to be used with @unittest.skipIf() to annotate tests that need to use an assert_python*() function to launch an isolated mode (-I) or no environment mode (-E) sub-interpreter process.

A normal build & test does not run into this situation but it can happen when trying to run the standard library test suite from an interpreter that doesn’t have an obvious home with Python’s current home finding logic.正常的构建和测试不会遇到这种情况，但当试图从一个解释器运行标准库测试套件时，可能会发生这种情况，该解释器没有明显的Python当前主查找逻辑。

Setting PYTHONHOME is one way to get most of the testsuite to run in that situation. PYTHONPATH or PYTHONUSERSITE are other common environment variables that might impact whether or not the interpreter can start.

test.support.script_helper.run_python_until_end(*args, **env_vars)

Set up the environment based on env_vars for running the interpreter in a subprocess. 基于env_vars设置环境，以便在子进程中运行解释器。The values can include __isolated, __cleanenv, __cwd, and TERM.这些值可以包括__isolated、__cleanenv、__cwd和TERM。

Changed in version 3.9:版本3.9中更改： The function no longer strips whitespaces from stderr.该函数不再从stderr中删除空格。

test.support.script_helper.assert_python_ok(*args, **env_vars)

Assert that running the interpreter with args and optional environment variables env_vars succeeds (rc == 0) and return a (return code, stdout, stderr) tuple.

If the __cleanenv keyword is set, env_vars is used as a fresh environment.如果设置了__cleannev关键字，则将env_vars用作新环境。

Python is started in isolated mode (command line option -I), except if the __isolated keyword is set to False.Python在隔离模式下启动（命令行选项-I），除非__isolated关键字设置为False。

Changed in version 3.9:版本3.9中更改： The function no longer strips whitespaces from stderr.该函数不再从stderr中删除空格。

test.support.script_helper.assert_python_failure(*args, **env_vars)

Assert that running the interpreter with args and optional environment variables env_vars fails (rc != 0) and return a (return code, stdout, stderr) tuple.断言使用args和可选环境变量env_vars运行解释器失败（rc != 0），并返回(return code, stdout, stderr)元组。

See assert_python_ok() for more options.有关更多选项，请参阅assert_python_ok()。

Changed in version 3.9:版本3.9中更改： The function no longer strips whitespaces from stderr.该函数不再从stderr中删除空格。

test.support.script_helper.spawn_python(*args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, **kw)

Run a Python subprocess with the given arguments.使用给定的参数运行Python子进程。

kw is extra keyword args to pass to subprocess.Popen(). Returns a subprocess.Popen object.

test.support.script_helper.kill_python(p)

Run the given subprocess.Popen process until completion and return stdout.运行给定的subprocess.Popen进程，直到完成并返回标准输出。

test.support.script_helper.make_script(script_dir, script_basename, source, omit_suffix=False)

Create script containing source in path script_dir and script_basename. If omit_suffix is False, append .py to the name. Return the full script path.

test.support.script_helper.make_zip_script(zip_dir, zip_basename, script_name, name_in_zip=None)

Create zip file at zip_dir and zip_basename with extension zip which contains the files in script_name. name_in_zip is the archive name. Return a tuple containing (full path, full path of archive name).

test.support.script_helper.make_pkg(pkg_dir, init_source='')

Create a directory named pkg_dir containing an __init__ file with init_source as its contents.

test.support.script_helper.make_zip_pkg(zip_dir, zip_basename, pkg_name, script_basename, source, depth=1, compiled=False)

Create a zip package directory with a path of zip_dir and zip_basename containing an empty __init__ file and a file script_basename containing the source. If compiled is True, both source files will be compiled and added to the zip package. Return a tuple of the full zip path and the archive name for the zip file.返回zip文件的完整zip路径和存档名称的元组。

test.support.bytecode_helper — Support tools for testing correct bytecode generation支持测试正确字节码生成的工具

The test.support.bytecode_helper module provides support for testing and inspecting bytecode generation.test.support.bytecode_helper模块为测试和检查字节码生成提供支持。

New in version 3.9.版本3.9中新增。

The module defines the following class:该模块定义了以下类：

classtest.support.bytecode_helper.BytecodeTestCase(unittest.TestCase)

This class has custom assertion methods for inspecting bytecode.此类具有用于检查字节码的自定义断言方法。

BytecodeTestCase.get_disassembly_as_string(co)

Return the disassembly of co as string.将co的反汇编作为字符串返回。

BytecodeTestCase.assertInBytecode(x, opname, argval=_UNSPECIFIED)

Return instr if opname is found, otherwise throws AssertionError.如果找到opname，则返回instr，否则抛出AssertionError。

BytecodeTestCase.assertNotInBytecode(x, opname, argval=_UNSPECIFIED)

Throws AssertionError if opname is found.如果找到opname，则抛出AssertionError。

test.support.threading_helper — Utilities for threading tests线程测试实用程序

The test.support.threading_helper module provides support for threading tests.test.support.threading_helper模块提供对线程测试的支持。

New in version 3.10.版本3.10中新增。

test.support.threading_helper.join_thread(thread, timeout=None)

Join a thread within timeout. Raise an AssertionError if thread is still alive after timeout seconds.

@test.support.threading_helper.reap_threads(func)

Decorator to ensure the threads are cleaned up even if the test fails.Decorator，以确保即使测试失败也能清理线程。

test.support.threading_helper.start_threads(threads, unlock=None)

Context manager to start threads. 启动threads的上下文管理器。It attempts to join the threads upon exit.它尝试在退出时加入线程。

test.support.threading_helper.threading_cleanup(*original_values)

Cleanup up threads not specified in original_values. 清除original_values中未指定的线程。Designed to emit a warning if a test leaves running threads in the background.设计用于在测试将运行线程留在后台时发出警告。

test.support.threading_helper.threading_setup()

Return current thread count and copy of dangling threads.返回当前线程计数和挂起线程的副本。

test.support.threading_helper.wait_threads_exit(timeout=None)

Context manager to wait until all threads created in the with statement exit.上下文管理器等待，直到with语句中创建的所有线程退出。

test.support.threading_helper.catch_threading_exception()

Context manager catching threading.Thread exception using threading.excepthook().上下文管理器正在使用threading.excepthook()捕获threading.Thread异常。

Attributes set when an exception is caught:捕获异常时设置的属性：

  • exc_type

  • exc_value

  • exc_traceback

  • thread

See threading.excepthook() documentation.请参阅threading.excepthook()文档。

These attributes are deleted at the context manager exit.这些属性将在上下文管理器出口处删除。

Usage:

with threading_helper.catch_threading_exception() as cm:
    # code spawning a thread which raises an exception
    ...
    # check the thread exception, use cm attributes:
    # exc_type, exc_value, exc_traceback, thread
    ...

# exc_type, exc_value, exc_traceback, thread attributes of cm no longer
# exists at this point
# (to avoid reference cycles)

New in version 3.8.版本3.8中新增。

test.support.os_helper — Utilities for os tests操作系统测试实用程序

The test.support.os_helper module provides support for os tests.test.support.os_helper模块为os测试提供支持。

New in version 3.10.版本3.10中新增。

test.support.os_helper.FS_NONASCII

A non-ASCII character encodable by os.fsencode().可由os.fsencode()编码的非ASCII字符。

test.support.os_helper.SAVEDCWD

Set to os.getcwd().设置为os.getcwd()。

test.support.os_helper.TESTFN

Set to a name that is safe to use as the name of a temporary file. 设置为可安全用作临时文件名的名称。Any temporary file that is created should be closed and unlinked (removed).创建的任何临时文件都应关闭并取消链接（删除）。

test.support.os_helper.TESTFN_NONASCII

Set to a filename containing the FS_NONASCII character.设置为包含FS_NONASCII字符的文件名。

test.support.os_helper.TESTFN_UNENCODABLE

Set to a filename (str type) that should not be able to be encoded by file system encoding in strict mode. 设置为文件名（str类型），该文件名不能在严格模式下通过文件系统编码进行编码。It may be None if it’s not possible to generate such a filename.如果无法生成这样的文件名，则可能为None。

test.support.os_helper.TESTFN_UNDECODABLE

Set to a filename (bytes type) that should not be able to be decoded by file system encoding in strict mode. 设置为一个文件名（字节类型），该文件名不能在严格模式下通过文件系统编码进行解码。It may be None if it’s not possible to generate such a filename.如果无法生成这样的文件名，则可能为None。

test.support.os_helper.TESTFN_UNICODE

Set to a non-ASCII name for a temporary file.设置为临时文件的非ASCII名称。

classtest.support.os_helper.EnvironmentVarGuard

Class used to temporarily set or unset environment variables. 类，用于临时设置或取消设置环境变量。Instances can be used as a context manager and have a complete dictionary interface for querying/modifying the underlying os.environ. 实例可以用作上下文管理器，并具有完整的字典接口，用于查询/修改底层os.environ。After exit from the context manager all changes to environment variables done through this instance will be rolled back.退出上下文管理器后，将回滚通过该实例对环境变量所做的所有更改。

Changed in version 3.1:版本3.1中更改： Added dictionary interface.添加字典接口。

classtest.support.os_helper.FakePath(path)

Simple path-like object. It implements the __fspath__() method which just returns the path argument. If path is an exception, it will be raised in __fspath__().如果path是异常，将在__fspath__()中引发。

EnvironmentVarGuard.set(envvar, value)

Temporarily set the environment variable envvar to the value of value.暂时将环境变量envvar设置为value的值。

EnvironmentVarGuard.unset(envvar)

Temporarily unset the environment variable envvar.暂时取消设置环境变量envvar。

Return True if the OS supports symbolic links, False otherwise.如果操作系统支持符号链接，则返回True，否则返回False。

test.support.os_helper.can_xattr()

Return True if the OS supports xattr, False otherwise.如果操作系统支持xattr，则返回True，否则返回False。

test.support.os_helper.change_cwd(path, quiet=False)

A context manager that temporarily changes the current working directory to path and yields the directory.将当前工作目录临时更改为path并生成目录的上下文管理器。

If quiet is False, the context manager raises an exception on error. 如果quiet为False，则上下文管理器在出错时引发异常。Otherwise, it issues only a warning and keeps the current working directory the same.否则，它只发出警告并保持当前工作目录不变。

test.support.os_helper.create_empty_file(filename)

Create an empty file with filename. 创建一个文件名为filename的空文件。If it already exists, truncate it.如果它已经存在，则将其截断。

test.support.os_helper.fd_count()

Count the number of open file descriptors.计算打开的文件描述符的数量。

test.support.os_helper.fs_is_case_insensitive(directory)

Return True if the file system for directory is case-insensitive.如果directory的文件系统不区分大小写，则返回True。

test.support.os_helper.make_bad_fd()

Create an invalid file descriptor by opening and closing a temporary file, and returning its descriptor.通过打开和关闭临时文件并返回其描述符，创建无效的文件描述符。

test.support.os_helper.rmdir(filename)

Call os.rmdir() on filename. 对filename调用os.rmdir()。On Windows platforms, this is wrapped with a wait loop that checks for the existence of the file.在Windows平台上，这是用一个等待循环包装的，用于检查文件的存在。

test.support.os_helper.rmtree(path)

Call shutil.rmtree() on path or call os.lstat() and os.rmdir() to remove a path and its contents. On Windows platforms, this is wrapped with a wait loop that checks for the existence of the files.在Windows平台上，这是用一个等待循环包装的，用于检查文件的存在。

A decorator for running tests that require support for symbolic links.用于运行需要支持符号链接的测试的修饰符。

@test.support.os_helper.skip_unless_xattr

A decorator for running tests that require support for xattr.用于运行需要支持xattr的测试的装饰器。

test.support.os_helper.temp_cwd(name='tempcwd', quiet=False)

A context manager that temporarily creates a new directory and changes the current working directory (CWD).临时创建新目录并更改当前工作目录（CWD）的上下文管理器。

The context manager creates a temporary directory in the current directory with name name before temporarily changing the current working directory. 在临时更改当前工作目录之前，上下文管理器在当前目录中创建一个名为name的临时目录。If name is None, the temporary directory is created using tempfile.mkdtemp().

If quiet is False and it is not possible to create or change the CWD, an error is raised. 如果quiet为False，并且无法创建或更改CWD，则会引发错误。Otherwise, only a warning is raised and the original CWD is used.否则，只会发出警告，并使用原始CWD。

test.support.os_helper.temp_dir(path=None, quiet=False)

A context manager that creates a temporary directory at path and yields the directory.上下文管理器，用于在path处创建临时目录并生成该目录。

If path is None, the temporary directory is created using tempfile.mkdtemp(). If quiet is False, the context manager raises an exception on error. Otherwise, if path is specified and cannot be created, only a warning is issued.

test.support.os_helper.temp_umask(umask)

A context manager that temporarily sets the process umask.临时设置进程umask的上下文管理器。

Call os.unlink() on filename. On Windows platforms, this is wrapped with a wait loop that checks for the existence of the file.在Windows平台上，这是用一个等待循环包装的，用于检查文件的存在。

test.support.import_helper — Utilities for import tests导入测试的实用程序

The test.support.import_helper module provides support for import tests.test.support.import_helper模块提供对导入测试的支持。

New in version 3.10.版本3.10中新增。

test.support.import_helper.forget(module_name)

Remove the module named module_name from sys.modules and delete any byte-compiled files of the module.从sys.modules中删除名为module_name的模块，并删除该模块的所有字节编译文件。

test.support.import_helper.import_fresh_module(name, fresh=(), blocked=(), deprecated=False)

This function imports and returns a fresh copy of the named Python module by removing the named module from sys.modules before doing the import. 此函数通过在导入之前从sys.modules中删除命名模块，导入并返回命名Python模块的新副本。Note that unlike reload(), the original module is not affected by this operation.请注意，与reload()不同，原始模块不受此操作的影响。

fresh is an iterable of additional module names that are also removed from the sys.modules cache before doing the import.fresh是一个可迭代的附加模块名称，这些名称在导入之前也会从sys.modules缓存中删除。

blocked is an iterable of module names that are replaced with None in the module cache during the import to ensure that attempts to import them raise ImportError.blocked是在导入过程中模块缓存中替换为None的模块名称的可迭代项，以确保尝试导入它们会引发ImportError。

The named module and any modules named in the fresh and blocked parameters are saved before starting the import and then reinserted into sys.modules when the fresh import is complete.在开始导入之前，将保存命名的模块以及在fresh和blocked参数中命名的任何模块，然后在新的导入完成后重新插入sys.modules。

Module and package deprecation messages are suppressed during this import if deprecated is True.如果deprecated为True，则在此导入期间将抑制模块和包的建议弃用消息。

This function will raise ImportError if the named module cannot be imported.如果无法导入命名模块，此函数将引发ImportError。

Example use:使用示例：

# Get copies of the warnings module for testing without affecting the
# version being used by the rest of the test suite. One copy uses the
# C implementation, the other is forced to use the pure Python fallback
# implementation
py_warnings = import_fresh_module('warnings', blocked=['_warnings'])
c_warnings = import_fresh_module('warnings', fresh=['_warnings'])

New in version 3.1.版本3.1中新增。

test.support.import_helper.import_module(name, deprecated=False, *, required_on())

This function imports and returns the named module. 此函数导入并返回命名模块。Unlike a normal import, this function raises unittest.SkipTest if the module cannot be imported.与正常导入不同，如果无法导入模块，此函数将引发unittest.SkipTest。

Module and package deprecation messages are suppressed during this import if deprecated is True. If a module is required on a platform but optional for others, set required_on to an iterable of platform prefixes which will be compared against sys.platform.

New in version 3.1.版本3.1中新增。

test.support.import_helper.modules_setup()

Return a copy of sys.modules.

test.support.import_helper.modules_cleanup(oldmodules)

Remove modules except for oldmodules and encodings in order to preserve internal cache.删除除oldmodules和encodings之外的模块，以保留内部缓存。

test.support.import_helper.unload(name)

Delete name from sys.modules.

test.support.import_helper.make_legacy_pyc(source)

Move a PEP 3147/PEP 488 pyc file to its legacy pyc location and return the file system path to the legacy pyc file. 将PEP 3147/PEP 488 pyc文件移动到其旧式pyc位置，并将文件系统路径返回到旧式PY文件。The source value is the file system path to the source file. source值是源文件的文件系统路径。It does not need to exist, however the PEP 3147/488 pyc file must exist.它不需要存在，但是PEP 3147/488 pyc文件必须存在。

classtest.support.import_helper.CleanImport(*module_names)

A context manager to force import to return a new module reference. 用于强制导入以返回新模块引用的上下文管理器。This is useful for testing module-level behaviors, such as the emission of a DeprecationWarning on import. 这对于测试模块级行为非常有用，例如在导入时发出弃用警告。Example usage:示例用法：

with CleanImport('foo'):
    importlib.import_module('foo')  # New reference.
classtest.support.import_helper.DirsOnSysPath(*paths)

A context manager to temporarily add directories to sys.path.用于将目录临时添加到sys.path的上下文管理器。

This makes a copy of sys.path, appends any directories given as positional arguments, then reverts sys.path to the copied settings when the context ends.这将创建sys.path的副本，附加作为位置参数提供的任何目录，然后在上下文结束时将sys.path还原为复制的设置。

Note that all sys.path modifications in the body of the context manager, including replacement of the object, will be reverted at the end of the block.请注意，上下文管理器主体中的所有sys.path修改（包括对象的替换）将在块的末尾恢复。

test.support.warnings_helper — Utilities for warnings tests警告测试实用程序

The test.support.warnings_helper module provides support for warnings tests.test.support.warnings_helper模块提供对警告测试的支持。

New in version 3.10.版本3.10中新增。

test.support.warnings_helper.check_no_resource_warning(testcase)

Context manager to check that no ResourceWarning was raised. 上下文管理器检查是否未引发ResourceWarning。You must remove the object which may emit ResourceWarning before the end of the context manager.必须在上下文管理器结束之前删除可能发出ResourceWarning的对象。

test.support.warnings_helper.check_syntax_warning(testcase, statement, errtext='', *, lineno=1, offset=None)

Test for syntax warning in statement by attempting to compile statement. Test also that the SyntaxWarning is emitted only once, and that it will be converted to a SyntaxError when turned into error. testcase is the unittest instance for the test. errtext is the regular expression which should match the string representation of the emitted SyntaxWarning and raised SyntaxError. If lineno is not None, compares to the line of the warning and exception. 如果lineno不是None，则与警告和异常的行进行比较。If offset is not None, compares to the offset of the exception.如果offset不是None，则与异常的偏移量进行比较。

New in version 3.8.版本3.8中新增。

test.support.warnings_helper.check_warnings(*filters, quiet=True)

A convenience wrapper for warnings.catch_warnings() that makes it easier to test that a warning was correctly raised. It is approximately equivalent to calling warnings.catch_warnings(record=True) with warnings.simplefilter() set to always and with the option to automatically validate the results that are recorded.

check_warnings accepts 2-tuples of the form ("message regexp", WarningCategory) as positional arguments. If one or more filters are provided, or if the optional keyword argument quiet is False, it checks to make sure the warnings are as expected: each specified filter must match at least one of the warnings raised by the enclosed code or the test fails, and if any warnings are raised that do not match any of the specified filters the test fails. To disable the first of these checks, set quiet to True.

If no arguments are specified, it defaults to:如果未指定参数，则默认为：

check_warnings(("", Warning), quiet=True)

In this case all warnings are caught and no errors are raised.在这种情况下，将捕获所有警告，不会引发任何错误。

On entry to the context manager, a WarningRecorder instance is returned. The underlying warnings list from catch_warnings() is available via the recorder object’s warnings attribute. As a convenience, the attributes of the object representing the most recent warning can also be accessed directly through the recorder object (see example below). If no warning has been raised, then any of the attributes that would otherwise be expected on an object representing a warning will return None.如果未引发任何警告，则表示警告的对象上预期的任何属性都将返回None。

The recorder object also has a reset() method, which clears the warnings list.记录器对象还有一个reset()方法，用于清除警告列表。

The context manager is designed to be used like this:上下文管理器的设计用途如下：

with check_warnings(("assertion is always true", SyntaxWarning),
                    ("", UserWarning)):
    exec('assert(False, "Hey!")')
    warnings.warn(UserWarning("Hide me!"))

In this case if either warning was not raised, or some other warning was raised, check_warnings() would raise an error.在这种情况下，如果未引发警告，或者引发了其他警告，则check_warnings()将引发错误。

When a test needs to look more deeply into the warnings, rather than just checking whether or not they occurred, code like this can be used:当测试需要更深入地查看警告，而不仅仅是检查它们是否发生时，可以使用以下代码：

with check_warnings(quiet=True) as w:
    warnings.warn("foo")
    assert str(w.args[0]) == "foo"
    warnings.warn("bar")
    assert str(w.args[0]) == "bar"
    assert str(w.warnings[0].args[0]) == "foo"
    assert str(w.warnings[1].args[0]) == "bar"
    w.reset()
    assert len(w.warnings) == 0

Here all warnings will be caught, and the test code tests the captured warnings directly.这里将捕获所有警告，测试代码直接测试捕获的警告。

Changed in version 3.2:版本3.2中更改： New optional arguments filters and quiet.

classtest.support.warnings_helper.WarningsRecorder

Class used to record warnings for unit tests. See documentation of check_warnings() above for more details.