msvcrt = None
+if support.check_sanitizer(address=True):
+ # bpo-45200: Skip multiprocessing tests if Python is built with ASAN to
+ # work around a libasan race condition: dead lock in pthread_create().
+ raise unittest.SkipTest("libasan has a pthread_create() dead lock")
+
+
def latin(s):
return s.encode('latin')
"requires_IEEE_754", "skip_unless_xattr", "requires_zlib",
"anticipate_failure", "load_package_tests", "detect_api_mismatch",
"check__all__", "skip_if_buggy_ucrt_strfptime",
- "ignore_warnings",
+ "ignore_warnings", "check_sanitizer", "skip_if_sanitizer",
# sys
"is_jython", "is_android", "check_impl_detail", "unix_shell",
"setswitchinterval",
return decorator
+def check_sanitizer(*, address=False, memory=False, ub=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-memory-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)
+ )
+
+
+def skip_if_sanitizer(reason=None, *, address=False, memory=False, ub=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)
+ return unittest.skipIf(skip, reason)
+
+
def system_must_validate_cert(f):
"""Skip the test on TLS certificate validation failures."""
@functools.wraps(f)
import sys
+if support.check_sanitizer(address=True, memory=True):
+ # bpo-46633: test___all__ is skipped because importing some modules
+ # directly can trigger known problems with ASAN (like tk or crypt).
+ raise unittest.SkipTest("workaround ASAN build issues on loading tests "
+ "like tk or crypt")
+
+
class NoAll(RuntimeError):
pass
import multiprocessing.util
+if support.check_sanitizer(address=True, memory=True):
+ # bpo-46633: Skip the test because it is too slow when Python is built
+ # with ASAN/MSAN: between 5 and 20 minutes on GitHub Actions.
+ raise unittest.SkipTest("test too slow on ASAN/MSAN build")
+
+
def create_future(state=PENDING, exception=None, result=None):
f = Future()
f._state = state
import sys
import unittest
+from test.support import check_sanitizer
try:
+ if check_sanitizer(address=True, memory=True):
+ raise unittest.SkipTest("The crypt module SEGFAULTs on ASAN/MSAN builds")
import crypt
IMPORT_ERROR = None
except ImportError as ex:
import numbers
import locale
from test.support import (run_unittest, run_doctest, is_resource_enabled,
- requires_IEEE_754, requires_docstrings)
-from test.support import (import_fresh_module, TestFailed,
+ requires_IEEE_754, requires_docstrings,
+ import_fresh_module, TestFailed,
run_with_locale, cpython_only,
- darwin_malloc_err_warning)
+ darwin_malloc_err_warning,
+ check_sanitizer)
import random
import inspect
import threading
-import sysconfig
-_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
-)
if sys.platform == 'darwin':
# Issue 41540:
@unittest.skipIf(sys.platform.startswith("aix"),
"AIX: default ulimit: test is flaky because of extreme over-allocation")
- @unittest.skipIf(MEMORY_SANITIZER or ADDRESS_SANITIZER, "sanitizer defaults to crashing "
+ @unittest.skipIf(check_sanitizer(address=True, memory=True),
+ "ASAN/MSAN sanitizer defaults to crashing "
"instead of returning NULL for malloc failure.")
def test_maxcontext_exact_arith(self):
import signal
import subprocess
import sys
-import sysconfig
from test import support
from test.support import script_helper, is_android
+from test.support import skip_if_sanitizer
import tempfile
import unittest
from textwrap import dedent
TIMEOUT = 0.5
MS_WINDOWS = (os.name == 'nt')
-_cflags = sysconfig.get_config_var('CFLAGS') or ''
-_config_args = sysconfig.get_config_var('CONFIG_ARGS') or ''
-UB_SANITIZER = (
- '-fsanitize=undefined' in _cflags or
- '--with-undefined-behavior-sanitizer' in _config_args
-)
-MEMORY_SANITIZER = (
- '-fsanitize=memory' in _cflags or
- '--with-memory-sanitizer' in _config_args
-)
def expected_traceback(lineno1, lineno2, header, min_count=1):
3,
'Segmentation fault')
- @unittest.skipIf(UB_SANITIZER or MEMORY_SANITIZER,
- "sanitizer builds change crashing process output.")
+ @skip_if_sanitizer(memory=True, ub=True, reason="sanitizer "
+ "builds change crashing process output.")
@skip_segfault_on_android
def test_enable_file(self):
with temporary_filename() as filename:
@unittest.skipIf(sys.platform == "win32",
"subprocess doesn't support pass_fds on Windows")
- @unittest.skipIf(UB_SANITIZER or MEMORY_SANITIZER,
- "sanitizer builds change crashing process output.")
+ @skip_if_sanitizer(memory=True, ub=True, reason="sanitizer "
+ "builds change crashing process output.")
@skip_segfault_on_android
def test_enable_fd(self):
with tempfile.TemporaryFile('wb+') as fp:
import unittest
from test.support import import_module
+from test.support import check_sanitizer
+
+if check_sanitizer(address=True, memory=True):
+ raise unittest.SkipTest("Tests involvin libX11 can SEGFAULT on ASAN/MSAN builds")
# Skip test_idle if _tkinter wasn't built, if tkinter is missing,
# if tcl/tk is not the 8.5+ needed for ttk widgets,
import random
import signal
import sys
-import sysconfig
import textwrap
import threading
import time
from test import support
from test.support.script_helper import (
assert_python_ok, assert_python_failure, run_python_until_end)
-from test.support import FakePath
+from test.support import FakePath, skip_if_sanitizer
import codecs
import io # C implementation of io
class EmptyStruct(ctypes.Structure):
pass
-_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
-)
-
# Does io.IOBase finalizer log the exception if the close() method fails?
# The exception is ignored silently by default in release build.
IOBASE_EMITS_UNRAISABLE = (hasattr(sys, "gettotalrefcount") or sys.flags.dev_mode)
class CBufferedReaderTest(BufferedReaderTest, SizeofTest):
tp = io.BufferedReader
- @unittest.skipIf(MEMORY_SANITIZER or ADDRESS_SANITIZER, "sanitizer defaults to crashing "
- "instead of returning NULL for malloc failure.")
+ @skip_if_sanitizer(memory=True, address=True, reason= "sanitizer defaults to crashing "
+ "instead of returning NULL for malloc failure.")
def test_constructor(self):
BufferedReaderTest.test_constructor(self)
# The allocation can succeed on 32-bit builds, e.g. with more
class CBufferedWriterTest(BufferedWriterTest, SizeofTest):
tp = io.BufferedWriter
- @unittest.skipIf(MEMORY_SANITIZER or ADDRESS_SANITIZER, "sanitizer defaults to crashing "
- "instead of returning NULL for malloc failure.")
+ @skip_if_sanitizer(memory=True, address=True, reason= "sanitizer defaults to crashing "
+ "instead of returning NULL for malloc failure.")
def test_constructor(self):
BufferedWriterTest.test_constructor(self)
# The allocation can succeed on 32-bit builds, e.g. with more
class CBufferedRandomTest(BufferedRandomTest, SizeofTest):
tp = io.BufferedRandom
- @unittest.skipIf(MEMORY_SANITIZER or ADDRESS_SANITIZER, "sanitizer defaults to crashing "
- "instead of returning NULL for malloc failure.")
+ @skip_if_sanitizer(memory=True, address=True, reason= "sanitizer defaults to crashing "
+ "instead of returning NULL for malloc failure.")
def test_constructor(self):
BufferedRandomTest.test_constructor(self)
# The allocation can succeed on 32-bit builds, e.g. with more
-import os
-
+import os.path
+import unittest
+from test import support
from test.support import load_package_tests
+
+if support.check_sanitizer(address=True, memory=True):
+ # bpo-46633: Skip the test because it is too slow when Python is built
+ # with ASAN/MSAN: between 5 and 20 minutes on GitHub Actions.
+ raise unittest.SkipTest("test too slow on ASAN/MSAN build")
+
+
# Load all tests in package
def load_tests(*args):
return load_package_tests(os.path.dirname(__file__), *args)
import unittest
from test import support
+from test.support import check_sanitizer
import sys
+if check_sanitizer(address=True, memory=True):
+ raise unittest.SkipTest("Tests involvin libX11 can SEGFAULT on ASAN/MSAN builds")
+
+
# Skip this test if the _tkinter module wasn't built.
_tkinter = support.import_module('_tkinter')
+import unittest
from test import support
+from test.support import check_sanitizer
+
+if check_sanitizer(address=True, memory=True):
+ raise unittest.SkipTest("Tests involvin libX11 can SEGFAULT on ASAN/MSAN builds")
+
# Skip test if _tkinter wasn't built.
support.import_module('_tkinter')
import unittest
from test import support
+
+if support.check_sanitizer(address=True, memory=True):
+ # bpo-46633: Skip the test because it is too slow when Python is built
+ # with ASAN/MSAN: between 5 and 20 minutes on GitHub Actions.
+ raise unittest.SkipTest("test too slow on ASAN/MSAN build")
+
+
basepath = os.path.normpath(
os.path.dirname( # <src/install dir>
os.path.dirname( # Lib
import unittest
from test import support
+from test.support import check_sanitizer
+
+if check_sanitizer(address=True, memory=True):
+ raise unittest.SkipTest("Tests involvin libX11 can SEGFAULT on ASAN/MSAN builds")
# Skip this test if _tkinter wasn't built.
support.import_module('_tkinter')
projects / thirdparty / Python / cpython.git / commitdiff
