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

if __name__ != 'test.support':

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

import annotationlib

import contextlib

import functools

import inspect

import logging

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", "get_resource_value", "requires", "requires_resource",

"requires_freebsd_version",

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

"check_syntax_error",

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

"bigmemtest", "nomemtest", "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",

"has_remote_subprocess_debugging", "requires_remote_subprocess_debugging",

"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", "thread_unsafe",

"skip_if_unlimited_stack_size", "skip_if_huge_c_stack",

"run_with_limited_c_stack",

# sys

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

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

"support_remote_exec_only",

# 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", "skip_on_s390x",

"requires_jit_enabled",

"requires_jit_disabled",

"force_not_colorized",

"force_not_colorized_test_class",

"make_clean_env",

"BrokenIter",

"in_systemd_nspawn_sync_suppressed",

"run_no_yield_async_fn", "run_yielding_async_fn", "async_yield",

"reset_code", "on_github_actions",

"requires_root_user", "requires_non_root_user",

"skip_if_double_rounding", "built_with_c_assertions",

]

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

import ctypes.wintypes

UOI_FLAGS = 1

WSF_VISIBLE = 0x0001

@ctypes.util.struct

class USEROBJECTFLAGS:

fInherit: ctypes.wintypes.BOOL

fReserved: ctypes.wintypes.BOOL

dwFlags: ctypes.wintypes.DWORD

user32 = ctypes.windll.user32

@ctypes.util.wrap_dll_function(user32)

def GetProcessWindowStation() -> ctypes.wintypes.HANDLE:

...

h = GetProcessWindowStation()

if not h:

raise ctypes.WinError()

@ctypes.util.wrap_dll_function(user32)

def GetUserObjectInformationW(

hObj: ctypes.wintypes.HANDLE,

nIndex: ctypes.c_int,

pvInfo: ctypes.c_void_p,

nLength: ctypes.wintypes.DWORD,

lpnLengthNeeded: ctypes.POINTER(ctypes.wintypes.DWORD),

) -> ctypes.wintypes.BOOL:

...

uof = USEROBJECTFLAGS()

needed = ctypes.wintypes.DWORD()

res = 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.

import subprocess

try:

rc = subprocess.run(["launchctl", "managername"],

capture_output=True, check=True)

managername = rc.stdout.decode("utf-8").strip()

except subprocess.CalledProcessError:

reason = "unable to detect macOS launchd job manager"

else:

if managername != "Aqua":

reason = f"{managername=} -- can only run in a macOS GUI session"

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

"""

if use_resources is None:

return None

return use_resources.get(resource)

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 thread_unsafe(reason):

"""Mark a test as not thread safe. When the test runner is run with

--parallel-threads=N, the test will be run in a single thread."""

def decorator(test_item):

test_item.__unittest_thread_unsafe__ = True

# the reason is not currently used

test_item.__unittest_thread_unsafe__why__ = reason

return test_item

if isinstance(reason, types.FunctionType):

test_item = reason

reason = ''

return decorator(test_item)

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, OSError) as err:

logging.getLogger(__name__).warning('getpass.getuser() failed %s.', err, exc_info=err)

isbuildbot = False

return unittest.skipIf(isbuildbot, reason)

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

function=True):

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

)

function_sanitizer = (

'-fsanitize=function' in cflags

)

return (

(memory and memory_sanitizer) or

(address and address_sanitizer) or

(ub and ub_sanitizer) or

(thread and thread_sanitizer) or

(function and function_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")

# detect evidence of double-rounding:

x, y = 1e16, 2.9999 # use temporary values to defeat peephole optimizer

HAVE_DOUBLE_ROUNDING = (x + y == 1e16 + 4)

skip_if_double_rounding = unittest.skipIf(HAVE_DOUBLE_ROUNDING,

"accuracy not guaranteed on "

"machines with double rounding")

del x, y, HAVE_DOUBLE_ROUNDING

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 requires_zstd(reason='requires zstd'):

try:

from compression import zstd

except ImportError:

zstd = None

return unittest.skipUnless(zstd, reason)

def has_no_debug_ranges():

try:

import _testcapi

except ImportError:

raise unittest.SkipTest("_testinternalcapi required")

return not _testcapi.config_get('code_debug_ranges')

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

try:

skip = has_no_debug_ranges()

except unittest.SkipTest as e:

skip = True

reason = e.args[0] if e.args else reason

return unittest.skipIf(skip, reason)

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"

def skip_android_selinux(name):

return unittest.skipIf(

sys.platform == "android", f"Android blocks {name} with SELinux"

)

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"

# Use is_wasm32 as a generic check for WebAssembly platforms.

is_wasm32 = is_emscripten or is_wasi

def skip_emscripten_stack_overflow():

return unittest.skipIf(is_emscripten, "Exhausts stack on Emscripten")

def skip_wasi_stack_overflow():

return unittest.skipIf(is_wasi, "Exhausts stack on 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)

@functools.cache

def has_remote_subprocess_debugging():

"""Check if we have permissions to debug subprocesses remotely.

Returns True if we have permissions, False if we don't.

Checks for:

- Platform support (Linux, macOS, Windows only)

- On Linux: process_vm_readv support

- _remote_debugging module availability

- Actual subprocess debugging permissions (e.g., macOS entitlements)

Result is cached.

"""

# Check platform support

if sys.platform not in ("linux", "darwin", "win32"):

return False

try:

import _remote_debugging

except ImportError:

return False

# On Linux, check for process_vm_readv support

if sys.platform == "linux":

if not getattr(_remote_debugging, "PROCESS_VM_READV_SUPPORTED", False):

return False

# First check if we can read our own process

if not _remote_debugging.is_python_process(os.getpid()):

return False

# Check subprocess access - debugging child processes may require

# additional permissions depending on platform security settings

import socket

import subprocess

# Create a socket for child to signal readiness

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

server.bind(("127.0.0.1", 0))

server.listen(1)

port = server.getsockname()[1]

# Child connects to signal it's ready, then waits for parent to close

child_code = f"""

import socket

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.connect(("127.0.0.1", {port}))

s.recv(1) # Wait for parent to signal done

"""

proc = subprocess.Popen(

[sys.executable, "-c", child_code],

stdout=subprocess.DEVNULL,

stderr=subprocess.DEVNULL,

)

try:

server.settimeout(5.0)

conn, _ = server.accept()

# Child is ready, test if we can probe it

result = _remote_debugging.is_python_process(proc.pid)

# Check if subprocess is still alive after probing

if proc.poll() is not None:

return False

conn.close() # Signal child to exit

return result

except (socket.timeout, OSError):

return False

finally:

server.close()

proc.kill()

proc.wait()

def requires_remote_subprocess_debugging():

"""Skip tests that require remote subprocess debugging permissions.

This also implies subprocess support, so no need to use both

@requires_subprocess() and @requires_remote_subprocess_debugging().

"""

if not has_subprocess_support:

return unittest.skip("requires subprocess support")

return unittest.skipUnless(

has_remote_subprocess_debugging(),

"requires remote subprocess debugging permissions"

)

# 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, extra_names: dict[str, object] | None = None) -> dict[str, object]:

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

ns = {}

if extra_names:

ns.update(extra_names)

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).path.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'):