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

# unittest

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

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

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

"skip_on_s390x",

"without_optimizer",

"""Test failed."""

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

self.msg = msg

self.stats = stats

super().__init__(msg, *args)

def __str__(self):

"""Test failed."""

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

self.errors = errors

self.failures = failures

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

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

if condition:

return unittest.expectedFailure

"""Generic load_tests implementation for simple test packages.

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)

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

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)

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

"""Test whether a resource is enabled.

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

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

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

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

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

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

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

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

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

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

if not (address or memory or ub):

raise ValueError('At least one of address, memory, or ub 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

)

return (

(memory and memory_sanitizer) or

(address and address_sanitizer) or

(ub and ub_sanitizer)

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

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

if name in env:

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

else:

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

try:

import zlib

except ImportError:

zlib = None

try:

import gzip

except ImportError:

gzip = None

try:

import bz2

except ImportError:

bz2 = None

try:

import lzma

except ImportError:

lzma = None

try:

import _testinternalcapi

except ImportError:

raise unittest.SkipTest("_testinternalcapi required")

config = _testinternalcapi.get_config()

"""Skip tests or modules that require working sockets

msg = "requires socket support"

if module:

if not has_socket_support:

raise unittest.SkipTest(msg)

else:

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

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)

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

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

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

items = sorted(dict.items())

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

withcommas = ", ".join(reprpairs)

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

ns = {}

exec(textwrap.dedent(code), ns)

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:

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

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

import io

orig_stdout = getattr(sys, stream_name)

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

try:

yield getattr(sys, stream_name)

finally:

"""Capture the output of sys.stdout:

"""Capture the output of sys.stderr:

"""Capture the input to sys.stdin:

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

import gc

gc.collect()

gc.collect()

import gc

have_gc = gc.isenabled()

gc.disable()

try:

yield

finally:

if have_gc:

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

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

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)

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:

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

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}')

global max_memuse

global real_max_memuse

memlimit = _parse_memlimit(limit)

if memlimit < _2G - 1:

raise ValueError('Memory limit {limit!r} too low to be useful')

real_max_memuse = memlimit

memlimit = min(memlimit, MAX_Py_ssize_t)

"""An object which periodically watches the process' memory consumption

def __init__(self):

self.procfile = '/proc/{pid}/statm'.format(pid=os.getpid())

self.started = False

def start(self):

import warnings

try:

f = open(self.procfile, 'r')

except OSError as e:

warnings.warn('/proc not available for stats: {}'.format(e),

RuntimeWarning)

sys.stderr.flush()

return

import subprocess

with f:

watchdog_script = findfile("memory_watchdog.py")

self.mem_watchdog = subprocess.Popen([sys.executable, watchdog_script],

stdin=f,

stderr=subprocess.DEVNULL)

self.started = True

def stop(self):

if self.started:

self.mem_watchdog.terminate()

"""Decorator for bigmem tests.

def decorator(f):

def wrapper(self):

size = wrapper.size

memuse = wrapper.memuse

if not real_max_memuse:

maxsize = 5147

else:

maxsize = size

if ((real_max_memuse or not dry_run)

and real_max_memuse < maxsize * memuse):

raise unittest.SkipTest(

"not enough memory: %.1fG minimum needed"

% (size * memuse / (1024 ** 3)))

if real_max_memuse and verbose:

print()

print(" ... expected peak memory use: {peak:.1f}G"

.format(peak=size * memuse / (1024 ** 3)))

watchdog = _MemoryWatchdog()

watchdog.start()

else:

watchdog = None

try: