"""Supporting definitions for the Python regression tests."""

if __name__ != 'test.support':

raise ImportError('support must be imported from the test package')

import contextlib

import functools

import _opcode

import os

import re

import stat

import sys

import sysconfig

import textwrap

import time

import types

import unittest

import warnings

__all__ = [

# globals

"PIPE_MAX_SIZE", "verbose", "max_memuse", "use_resources", "failfast",

# exceptions

"Error", "TestFailed", "TestDidNotRun", "ResourceDenied",

# io

"record_original_stdout", "get_original_stdout", "captured_stdout",

"captured_stdin", "captured_stderr", "captured_output",

# unittest

"is_resource_enabled", "requires", "requires_freebsd_version",

"requires_gil_enabled", "requires_linux_version", "requires_mac_ver",

"check_syntax_error",

"requires_gzip", "requires_bz2", "requires_lzma",

"bigmemtest", "bigaddrspacetest", "cpython_only", "get_attribute",

"requires_IEEE_754", "requires_zlib",

"has_fork_support", "requires_fork",

"has_subprocess_support", "requires_subprocess",

"has_socket_support", "requires_working_socket",

"anticipate_failure", "load_package_tests", "detect_api_mismatch",

"check__all__", "skip_if_buggy_ucrt_strfptime",

"check_disallow_instantiation", "check_sanitizer", "skip_if_sanitizer",

"requires_limited_api", "requires_specialization",

# sys

"MS_WINDOWS", "is_jython", "is_android", "is_emscripten", "is_wasi",

"is_apple_mobile", "check_impl_detail", "unix_shell", "setswitchinterval",

# os

"get_pagesize",

# network

"open_urlresource",

# processes

"reap_children",

# miscellaneous

"run_with_locale", "swap_item", "findfile", "infinite_recursion",

"swap_attr", "Matcher", "set_memlimit", "SuppressCrashReport", "sortdict",

"run_with_tz", "PGO", "missing_compiler_executable",

"ALWAYS_EQ", "NEVER_EQ", "LARGEST", "SMALLEST",

"LOOPBACK_TIMEOUT", "INTERNET_TIMEOUT", "SHORT_TIMEOUT", "LONG_TIMEOUT",

"Py_DEBUG", "exceeds_recursion_limit", "get_c_recursion_limit",

"skip_on_s390x",

"without_optimizer",

"force_not_colorized"

]

# Timeout in seconds for tests using a network server listening on the network

# local loopback interface like 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.

LOOPBACK_TIMEOUT = 10.0

# Timeout in seconds for network requests going to the internet. The timeout is

# short enough to prevent a test to wait for too long if the internet request

# is blocked for whatever reason.

#

# Usually, a timeout using INTERNET_TIMEOUT should not mark a test as failed,

# but skip the test instead: see transient_internet().

INTERNET_TIMEOUT = 60.0

# 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.

#

# If a test using SHORT_TIMEOUT starts to fail randomly on slow buildbots, use

# LONG_TIMEOUT instead.

SHORT_TIMEOUT = 30.0

# 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. 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.

LONG_TIMEOUT = 5 * 60.0

# TEST_HOME_DIR refers to the top level directory of the "test" package

# that contains Python's regression test suite

TEST_SUPPORT_DIR = os.path.dirname(os.path.abspath(__file__))

TEST_HOME_DIR = os.path.dirname(TEST_SUPPORT_DIR)

STDLIB_DIR = os.path.dirname(TEST_HOME_DIR)

REPO_ROOT = os.path.dirname(STDLIB_DIR)

class Error(Exception):

"""Base class for regression test exceptions."""

class TestFailed(Error):

"""Test failed."""

def __init__(self, msg, *args, stats=None):

self.msg = msg

self.stats = stats

super().__init__(msg, *args)

def __str__(self):

return self.msg

class TestFailedWithDetails(TestFailed):

"""Test failed."""

def __init__(self, msg, errors, failures, stats):

self.errors = errors

self.failures = failures

super().__init__(msg, errors, failures, stats=stats)

class TestDidNotRun(Error):

"""Test did not run any subtests."""

class ResourceDenied(unittest.SkipTest):

"""Test skipped because it requested a disallowed resource.

This is raised when a test calls requires() for a resource that

has not be enabled. It is used to distinguish between expected

and unexpected skips.

"""

def anticipate_failure(condition):

"""Decorator to mark a test that is known to be broken in some cases

Any use of this decorator should have a comment identifying the

associated tracker issue.

"""

if condition:

return unittest.expectedFailure

return lambda f: f

def load_package_tests(pkg_dir, loader, standard_tests, pattern):

"""Generic load_tests implementation for simple test packages.

Most packages can implement load_tests using this function as follows:

def load_tests(*args):

return load_package_tests(os.path.dirname(__file__), *args)

"""

if pattern is None:

pattern = "test*"

top_dir = STDLIB_DIR

package_tests = loader.discover(start_dir=pkg_dir,

top_level_dir=top_dir,

pattern=pattern)

standard_tests.addTests(package_tests)

return standard_tests

def get_attribute(obj, name):

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

try:

attribute = getattr(obj, name)

except AttributeError:

raise unittest.SkipTest("object %r has no attribute %r" % (obj, name))

else:

return attribute

verbose = 1 # Flag set to 0 by regrtest.py

use_resources = None # Flag set to [] by regrtest.py

max_memuse = 0 # Disable bigmem tests (they will still be run with

# small sizes, to make sure they work.)

real_max_memuse = 0

junit_xml_list = None # list of testsuite XML elements

failfast = False

# _original_stdout is meant to hold stdout at the time regrtest began.

# This may be "the real" stdout, or IDLE's emulation of stdout, or whatever.

# The point is to have some flavor of stdout the user can actually see.

_original_stdout = None

def record_original_stdout(stdout):

global _original_stdout

_original_stdout = stdout

def get_original_stdout():

return _original_stdout or sys.stdout

def _force_run(path, func, *args):

try:

return func(*args)

except FileNotFoundError as err:

# chmod() won't fix a missing file.

if verbose >= 2:

print('%s: %s' % (err.__class__.__name__, err))

raise

except OSError as err:

if verbose >= 2:

print('%s: %s' % (err.__class__.__name__, err))

print('re-run %s%r' % (func.__name__, args))

os.chmod(path, stat.S_IRWXU)

return func(*args)

# Check whether a gui is actually available

def _is_gui_available():

if hasattr(_is_gui_available, 'result'):

return _is_gui_available.result

import platform

reason = None

if sys.platform.startswith('win') and platform.win32_is_iot():

reason = "gui is not available on Windows IoT Core"

elif sys.platform.startswith('win'):

# if Python is running as a service (such as the buildbot service),

# gui interaction may be disallowed

import ctypes

import ctypes.wintypes

UOI_FLAGS = 1

WSF_VISIBLE = 0x0001

class USEROBJECTFLAGS(ctypes.Structure):

_fields_ = [("fInherit", ctypes.wintypes.BOOL),

("fReserved", ctypes.wintypes.BOOL),

("dwFlags", ctypes.wintypes.DWORD)]

dll = ctypes.windll.user32

h = dll.GetProcessWindowStation()

if not h:

raise ctypes.WinError()

uof = USEROBJECTFLAGS()

needed = ctypes.wintypes.DWORD()

res = dll.GetUserObjectInformationW(h,

UOI_FLAGS,

ctypes.byref(uof),

ctypes.sizeof(uof),

ctypes.byref(needed))

if not res:

raise ctypes.WinError()

if not bool(uof.dwFlags & WSF_VISIBLE):

reason = "gui not available (WSF_VISIBLE flag not set)"

elif sys.platform == 'darwin':

# The Aqua Tk implementations on OS X can abort the process if

# being called in an environment where a window server connection

# cannot be made, for instance when invoked by a buildbot or ssh

# process not running under the same user id as the current console

# user. To avoid that, raise an exception if the window manager

# connection is not available.

from ctypes import cdll, c_int, pointer, Structure

from ctypes.util import find_library

app_services = cdll.LoadLibrary(find_library("ApplicationServices"))

if app_services.CGMainDisplayID() == 0:

reason = "gui tests cannot run without OS X window manager"

else:

class ProcessSerialNumber(Structure):

_fields_ = [("highLongOfPSN", c_int),

("lowLongOfPSN", c_int)]

psn = ProcessSerialNumber()

psn_p = pointer(psn)

if ( (app_services.GetCurrentProcess(psn_p) < 0) or

(app_services.SetFrontProcess(psn_p) < 0) ):

reason = "cannot run without OS X gui process"

# check on every platform whether tkinter can actually do anything

if not reason:

try:

from tkinter import Tk

root = Tk()

root.withdraw()

root.update()

root.destroy()

except Exception as e:

err_string = str(e)

if len(err_string) > 50:

err_string = err_string[:50] + ' [...]'

reason = 'Tk unavailable due to {}: {}'.format(type(e).__name__,

err_string)

_is_gui_available.reason = reason

_is_gui_available.result = not reason

return _is_gui_available.result

def is_resource_enabled(resource):

"""Test whether a resource is enabled.

Known resources are set by regrtest.py. If not running under regrtest.py,

all resources are assumed enabled unless use_resources has been set.

"""

return use_resources is None or resource in use_resources

def requires(resource, msg=None):

"""Raise ResourceDenied if the specified resource is not available."""

if not is_resource_enabled(resource):

if msg is None:

msg = "Use of the %r resource not enabled" % resource

raise ResourceDenied(msg)

if resource in {"network", "urlfetch"} and not has_socket_support:

raise ResourceDenied("No socket support")

if resource == 'gui' and not _is_gui_available():

raise ResourceDenied(_is_gui_available.reason)

def _requires_unix_version(sysname, min_version):

"""Decorator raising SkipTest if the OS is `sysname` and the version is less

than `min_version`.

For example, @_requires_unix_version('FreeBSD', (7, 2)) raises SkipTest if

the FreeBSD version is less than 7.2.

"""

import platform

min_version_txt = '.'.join(map(str, min_version))

version_txt = platform.release().split('-', 1)[0]

if platform.system() == sysname:

try:

version = tuple(map(int, version_txt.split('.')))

except ValueError:

skip = False

else:

skip = version < min_version

else:

skip = False

return unittest.skipIf(

skip,

f"{sysname} version {min_version_txt} or higher required, not "

f"{version_txt}"

)

def requires_freebsd_version(*min_version):

"""Decorator raising SkipTest if the OS is FreeBSD and the FreeBSD version is

less than `min_version`.

For example, @requires_freebsd_version(7, 2) raises SkipTest if the FreeBSD

version is less than 7.2.

"""

return _requires_unix_version('FreeBSD', min_version)

def requires_linux_version(*min_version):

"""Decorator raising SkipTest if the OS is Linux and the Linux version is

less than `min_version`.

For example, @requires_linux_version(2, 6, 32) raises SkipTest if the Linux

version is less than 2.6.32.

"""

return _requires_unix_version('Linux', min_version)

def requires_mac_ver(*min_version):

"""Decorator raising SkipTest if the OS is Mac OS X and the OS X

version if less than min_version.

For example, @requires_mac_ver(10, 5) raises SkipTest if the OS X version

is lesser than 10.5.

"""

def decorator(func):

@functools.wraps(func)

def wrapper(*args, **kw):

if sys.platform == 'darwin':

import platform

version_txt = platform.mac_ver()[0]

try:

version = tuple(map(int, version_txt.split('.')))

except ValueError:

pass

else:

if version < min_version:

min_version_txt = '.'.join(map(str, min_version))

raise unittest.SkipTest(

"Mac OS X %s or higher required, not %s"

% (min_version_txt, version_txt))

return func(*args, **kw)

wrapper.min_version = min_version

return wrapper

return decorator

def skip_if_buildbot(reason=None):

"""Decorator raising SkipTest if running on a buildbot."""

import getpass

if not reason:

reason = 'not suitable for buildbots'

try:

isbuildbot = getpass.getuser().lower() == 'buildbot'

except (KeyError, EnvironmentError) as err:

warnings.warn(f'getpass.getuser() failed {err}.', RuntimeWarning)

isbuildbot = False

return unittest.skipIf(isbuildbot, reason)

def check_sanitizer(*, address=False, memory=False, ub=False, thread=False):

"""Returns True if Python is compiled with sanitizer support"""

if not (address or memory or ub or thread):

raise ValueError('At least one of address, memory, ub or thread must be True')

cflags = sysconfig.get_config_var('CFLAGS') or ''

config_args = sysconfig.get_config_var('CONFIG_ARGS') or ''

memory_sanitizer = (

'-fsanitize=memory' in cflags or

'--with-memory-sanitizer' in config_args

)

address_sanitizer = (

'-fsanitize=address' in cflags or

'--with-address-sanitizer' in config_args

)

ub_sanitizer = (

'-fsanitize=undefined' in cflags or

'--with-undefined-behavior-sanitizer' in config_args

)

thread_sanitizer = (

'-fsanitize=thread' in cflags or

'--with-thread-sanitizer' in config_args

)

return (

(memory and memory_sanitizer) or

(address and address_sanitizer) or

(ub and ub_sanitizer) or

(thread and thread_sanitizer)

)

def skip_if_sanitizer(reason=None, *, address=False, memory=False, ub=False, thread=False):

"""Decorator raising SkipTest if running with a sanitizer active."""

if not reason:

reason = 'not working with sanitizers active'

skip = check_sanitizer(address=address, memory=memory, ub=ub, thread=thread)

return unittest.skipIf(skip, reason)

# gh-89363: True if fork() can hang if Python is built with Address Sanitizer

# (ASAN): libasan race condition, dead lock in pthread_create().

HAVE_ASAN_FORK_BUG = check_sanitizer(address=True)

def set_sanitizer_env_var(env, option):

for name in ('ASAN_OPTIONS', 'MSAN_OPTIONS', 'UBSAN_OPTIONS', 'TSAN_OPTIONS'):

if name in env:

env[name] += f':{option}'

else:

env[name] = option

def system_must_validate_cert(f):

"""Skip the test on TLS certificate validation failures."""

@functools.wraps(f)

def dec(*args, **kwargs):

try:

f(*args, **kwargs)

except OSError as e:

if "CERTIFICATE_VERIFY_FAILED" in str(e):

raise unittest.SkipTest("system does not contain "

"necessary certificates")

raise

return dec

# A constant likely larger than the underlying OS pipe buffer size, to

# make writes blocking.

# Windows limit seems to be around 512 B, and many Unix kernels have a

# 64 KiB pipe buffer size or 16 * PAGE_SIZE: take a few megs to be sure.

# (see issue #17835 for a discussion of this number).

PIPE_MAX_SIZE = 4 * 1024 * 1024 + 1

# A constant likely larger than the underlying OS socket buffer size, to make

# writes blocking.

# The socket buffer sizes can usually be tuned system-wide (e.g. through sysctl

# on Linux), or on a per-socket basis (SO_SNDBUF/SO_RCVBUF). See issue #18643

# for a discussion of this number.

SOCK_MAX_SIZE = 16 * 1024 * 1024 + 1

# decorator for skipping tests on non-IEEE 754 platforms

requires_IEEE_754 = unittest.skipUnless(

float.__getformat__("double").startswith("IEEE"),

"test requires IEEE 754 doubles")

def requires_zlib(reason='requires zlib'):

try:

import zlib

except ImportError:

zlib = None

return unittest.skipUnless(zlib, reason)

def requires_gzip(reason='requires gzip'):

try:

import gzip

except ImportError:

gzip = None

return unittest.skipUnless(gzip, reason)

def requires_bz2(reason='requires bz2'):

try:

import bz2

except ImportError:

bz2 = None

return unittest.skipUnless(bz2, reason)

def requires_lzma(reason='requires lzma'):

try:

import lzma

except ImportError:

lzma = None

return unittest.skipUnless(lzma, reason)

def has_no_debug_ranges():

try:

import _testinternalcapi

except ImportError:

raise unittest.SkipTest("_testinternalcapi required")

config = _testinternalcapi.get_config()

return not bool(config['code_debug_ranges'])

def requires_debug_ranges(reason='requires co_positions / debug_ranges'):

return unittest.skipIf(has_no_debug_ranges(), reason)

@contextlib.contextmanager

def suppress_immortalization(suppress=True):

"""Suppress immortalization of deferred objects."""

try:

import _testinternalcapi

except ImportError:

yield

return

if not suppress:

yield

return

_testinternalcapi.suppress_immortalization(True)

try:

yield

finally:

_testinternalcapi.suppress_immortalization(False)

def skip_if_suppress_immortalization():

try:

import _testinternalcapi

except ImportError:

return

return unittest.skipUnless(_testinternalcapi.get_immortalize_deferred(),

"requires immortalization of deferred objects")

MS_WINDOWS = (sys.platform == 'win32')

# Is not actually used in tests, but is kept for compatibility.

is_jython = sys.platform.startswith('java')

is_android = sys.platform == "android"

if sys.platform not in {"win32", "vxworks", "ios", "tvos", "watchos"}:

unix_shell = '/system/bin/sh' if is_android else '/bin/sh'

else:

unix_shell = None

# wasm32-emscripten and -wasi are POSIX-like but do not

# have subprocess or fork support.

is_emscripten = sys.platform == "emscripten"

is_wasi = sys.platform == "wasi"

is_apple_mobile = sys.platform in {"ios", "tvos", "watchos"}

is_apple = is_apple_mobile or sys.platform == "darwin"

has_fork_support = hasattr(os, "fork") and not (

# WASM and Apple mobile platforms do not support subprocesses.

is_emscripten

or is_wasi

or is_apple_mobile

# Although Android supports fork, it's unsafe to call it from Python because

# all Android apps are multi-threaded.

or is_android

)

def requires_fork():

return unittest.skipUnless(has_fork_support, "requires working os.fork()")

has_subprocess_support = not (

# WASM and Apple mobile platforms do not support subprocesses.

is_emscripten

or is_wasi

or is_apple_mobile

# Although Android supports subproceses, they're almost never useful in

# practice (see PEP 738). And most of the tests that use them are calling

# sys.executable, which won't work when Python is embedded in an Android app.

or is_android

)

def requires_subprocess():

"""Used for subprocess, os.spawn calls, fd inheritance"""

return unittest.skipUnless(has_subprocess_support, "requires subprocess support")

# Emscripten's socket emulation and WASI sockets have limitations.

has_socket_support = not (

is_emscripten

or is_wasi

)

def requires_working_socket(*, module=False):

"""Skip tests or modules that require working sockets

Can be used as a function/class decorator or to skip an entire module.

"""

msg = "requires socket support"

if module:

if not has_socket_support:

raise unittest.SkipTest(msg)

else:

return unittest.skipUnless(has_socket_support, msg)

# Does strftime() support glibc extension like '%4Y'?

has_strftime_extensions = False

if sys.platform != "win32":

# bpo-47037: Windows debug builds crash with "Debug Assertion Failed"

try:

has_strftime_extensions = time.strftime("%4Y") != "%4Y"

except ValueError:

pass

# Define the URL of a dedicated HTTP server for the network tests.

# The URL must use clear-text HTTP: no redirection to encrypted HTTPS.

TEST_HTTP_URL = "http://www.pythontest.net"

# Set by libregrtest/main.py so we can skip tests that are not

# useful for PGO

PGO = False

# Set by libregrtest/main.py if we are running the extended (time consuming)

# PGO task. If this is True, PGO is also True.

PGO_EXTENDED = False

# TEST_DATA_DIR is used as a target download location for remote resources

TEST_DATA_DIR = os.path.join(TEST_HOME_DIR, "data")

def darwin_malloc_err_warning(test_name):

"""Assure user that loud errors generated by macOS libc's malloc are

expected."""

if sys.platform != 'darwin':

return

import shutil

msg = ' NOTICE '

detail = (f'{test_name} may generate "malloc can\'t allocate region"\n'

'warnings on macOS systems. This behavior is known. Do not\n'

'report a bug unless tests are also failing.\n'

'See https://github.com/python/cpython/issues/85100')

padding, _ = shutil.get_terminal_size()

print(msg.center(padding, '-'))

print(detail)

print('-' * padding)

def findfile(filename, subdir=None):

"""Try to find a file on sys.path or in the test directory. If it is not

found the argument passed to the function is returned (this does not

necessarily signal failure; could still be the legitimate path).

Setting *subdir* indicates a relative path to use to find the file

rather than looking directly in the path directories.

"""

if os.path.isabs(filename):

return filename

if subdir is not None:

filename = os.path.join(subdir, filename)

path = [TEST_HOME_DIR] + sys.path

for dn in path:

fn = os.path.join(dn, filename)

if os.path.exists(fn): return fn

return filename

def sortdict(dict):

"Like repr(dict), but in sorted order."

items = sorted(dict.items())

reprpairs = ["%r: %r" % pair for pair in items]

withcommas = ", ".join(reprpairs)

return "{%s}" % withcommas

def run_code(code: str) -> dict[str, object]:

"""Run a piece of code after dedenting it, and return its global namespace."""

ns = {}

exec(textwrap.dedent(code), ns)

return ns

def check_syntax_error(testcase, statement, errtext='', *, lineno=None, offset=None):

with testcase.assertRaisesRegex(SyntaxError, errtext) as cm:

compile(statement, '<test string>', 'exec')

err = cm.exception

testcase.assertIsNotNone(err.lineno)

if lineno is not None:

testcase.assertEqual(err.lineno, lineno)

testcase.assertIsNotNone(err.offset)

if offset is not None:

testcase.assertEqual(err.offset, offset)

def open_urlresource(url, *args, **kw):

import urllib.request, urllib.parse

from .os_helper import unlink

try:

import gzip

except ImportError:

gzip = None

check = kw.pop('check', None)

filename = urllib.parse.urlparse(url)[2].split('/')[-1] # '/': it's URL!

fn = os.path.join(TEST_DATA_DIR, filename)

def check_valid_file(fn):

f = open(fn, *args, **kw)

if check is None:

return f

elif check(f):

f.seek(0)

return f

f.close()

if os.path.exists(fn):

f = check_valid_file(fn)

if f is not None:

return f

unlink(fn)

# Verify the requirement before downloading the file

requires('urlfetch')

if verbose:

print('\tfetching %s ...' % url, file=get_original_stdout())

opener = urllib.request.build_opener()

if gzip:

opener.addheaders.append(('Accept-Encoding', 'gzip'))

f = opener.open(url, timeout=INTERNET_TIMEOUT)

if gzip and f.headers.get('Content-Encoding') == 'gzip':

f = gzip.GzipFile(fileobj=f)

try:

with open(fn, "wb") as out:

s = f.read()

while s:

out.write(s)

s = f.read()

finally:

f.close()

f = check_valid_file(fn)

if f is not None:

return f

raise TestFailed('invalid resource %r' % fn)

@contextlib.contextmanager

def captured_output(stream_name):

"""Return a context manager used by captured_stdout/stdin/stderr

that temporarily replaces the sys stream *stream_name* with a StringIO."""

import io

orig_stdout = getattr(sys, stream_name)

setattr(sys, stream_name, io.StringIO())

try:

yield getattr(sys, stream_name)

finally:

setattr(sys, stream_name, orig_stdout)

def captured_stdout():

"""Capture the output of sys.stdout:

with captured_stdout() as stdout:

print("hello")

self.assertEqual(stdout.getvalue(), "hello\\n")

"""

return captured_output("stdout")

def captured_stderr():

"""Capture the output of sys.stderr:

with captured_stderr() as stderr:

print("hello", file=sys.stderr)

self.assertEqual(stderr.getvalue(), "hello\\n")

"""

return captured_output("stderr")

def captured_stdin():

"""Capture the input to sys.stdin:

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")

"""

return captured_output("stdin")

def gc_collect():

"""Force as many objects as possible to be collected.

In non-CPython implementations of Python, this is needed because timely

deallocation is not guaranteed by the garbage collector. (Even in CPython

this can be the case in case of reference cycles.) This means that __del__

methods may be called later than expected and weakrefs may remain alive for

longer than expected. This function tries its best to force all garbage

objects to disappear.

"""

import gc

gc.collect()

gc.collect()

gc.collect()

@contextlib.contextmanager

def disable_gc():

import gc

have_gc = gc.isenabled()

gc.disable()

try:

yield

finally:

if have_gc:

gc.enable()

@contextlib.contextmanager

def gc_threshold(*args):

import gc

old_threshold = gc.get_threshold()

gc.set_threshold(*args)

try:

yield

finally:

gc.set_threshold(*old_threshold)

def python_is_optimized():

"""Find if Python was built with optimizations."""

cflags = sysconfig.get_config_var('PY_CFLAGS') or ''

final_opt = ""

for opt in cflags.split():

if opt.startswith('-O'):

final_opt = opt

return final_opt not in ('', '-O0', '-Og')

def check_cflags_pgo():

# Check if Python was built with ./configure --enable-optimizations:

# with Profile Guided Optimization (PGO).

cflags_nodist = sysconfig.get_config_var('PY_CFLAGS_NODIST') or ''

pgo_options = [

# GCC

'-fprofile-use',

# clang: -fprofile-instr-use=code.profclangd

'-fprofile-instr-use',

# ICC

"-prof-use",

]

PGO_PROF_USE_FLAG = sysconfig.get_config_var('PGO_PROF_USE_FLAG')

if PGO_PROF_USE_FLAG:

pgo_options.append(PGO_PROF_USE_FLAG)

return any(option in cflags_nodist for option in pgo_options)

Py_GIL_DISABLED = bool(sysconfig.get_config_var('Py_GIL_DISABLED'))

def requires_gil_enabled(msg="needs the GIL enabled"):

"""Decorator for skipping tests on the free-threaded build."""

return unittest.skipIf(Py_GIL_DISABLED, msg)

def expected_failure_if_gil_disabled():

"""Expect test failure if the GIL is disabled."""

if Py_GIL_DISABLED:

return unittest.expectedFailure

return lambda test_case: test_case

if Py_GIL_DISABLED:

_header = 'PHBBInP'

else:

_header = 'nP'

_align = '0n'

_vheader = _header + 'n'

def calcobjsize(fmt):

import struct

return struct.calcsize(_header + fmt + _align)

def calcvobjsize(fmt):

import struct

return struct.calcsize(_vheader + fmt + _align)

_TPFLAGS_HAVE_GC = 1<<14

_TPFLAGS_HEAPTYPE = 1<<9

def check_sizeof(test, o, size):

try:

import _testinternalcapi

except ImportError:

raise unittest.SkipTest("_testinternalcapi required")

result = sys.getsizeof(o)

# add GC header size

if ((type(o) == type) and (o.__flags__ & _TPFLAGS_HEAPTYPE) or\

((type(o) != type) and (type(o).__flags__ & _TPFLAGS_HAVE_GC))):

size += _testinternalcapi.SIZEOF_PYGC_HEAD

msg = 'wrong size for %s: got %d, expected %d' \

% (type(o), result, size)

test.assertEqual(result, size, msg)

#=======================================================================

# Decorator for running a function in a different locale, correctly resetting

# it afterwards.

@contextlib.contextmanager

def run_with_locale(catstr, *locales):

try:

import locale

category = getattr(locale, catstr)

orig_locale = locale.setlocale(category)

except AttributeError:

# if the test author gives us an invalid category string

raise

except:

# cannot retrieve original locale, so do nothing

locale = orig_locale = None

else:

for loc in locales:

try:

locale.setlocale(category, loc)

break

except:

pass

try:

yield

finally:

if locale and orig_locale:

locale.setlocale(category, orig_locale)

#=======================================================================

# Decorator for running a function in a specific timezone, correctly

# resetting it afterwards.

def run_with_tz(tz):

def decorator(func):

def inner(*args, **kwds):

try:

tzset = time.tzset

except AttributeError:

raise unittest.SkipTest("tzset required")

if 'TZ' in os.environ:

orig_tz = os.environ['TZ']

else:

orig_tz = None

os.environ['TZ'] = tz

tzset()

# now run the function, resetting the tz on exceptions

try:

return func(*args, **kwds)

finally:

if orig_tz is None:

del os.environ['TZ']

else:

os.environ['TZ'] = orig_tz

time.tzset()

inner.__name__ = func.__name__

inner.__doc__ = func.__doc__

return inner

return decorator

#=======================================================================

# Big-memory-test support. Separate from 'resources' because memory use

# should be configurable.

# Some handy shorthands. Note that these are used for byte-limits as well

# as size-limits, in the various bigmem tests

_1M = 1024*1024

_1G = 1024 * _1M

_2G = 2 * _1G

_4G = 4 * _1G

MAX_Py_ssize_t = sys.maxsize

def _parse_memlimit(limit: str) -> int:

sizes = {

'k': 1024,

'm': _1M,

'g': _1G,

't': 1024*_1G,

}

m = re.match(r'(\d+(?:\.\d+)?) (K|M|G|T)b?$', limit,

re.IGNORECASE | re.VERBOSE)

if m is None:

raise ValueError(f'Invalid memory limit: {limit!r}')

return int(float(m.group(1)) * sizes[m.group(2).lower()])