from datetime import date, datetime
import time as _time
-import _testcapi
+try:
+ import _testcapi
+except ImportError:
+ _testcapi = None
# Needed by test_datetime
import _strptime
zonename = 'Asia/Tehran'
+@unittest.skipIf(_testcapi is None, 'need _testcapi module')
class CapiTest(unittest.TestCase):
def setUp(self):
# Since the C API is not present in the _Pure tests, skip all tests
import unittest, string, sys, struct
from test import support
+from test.support import import_helper
from collections import UserList
import random
@support.cpython_only
def test_formatting_c_limits(self):
- from _testcapi import PY_SSIZE_T_MAX, INT_MAX, UINT_MAX
- SIZE_MAX = (1 << (PY_SSIZE_T_MAX.bit_length() + 1)) - 1
+ _testcapi = import_helper.import_module('_testcapi')
+ SIZE_MAX = (1 << (_testcapi.PY_SSIZE_T_MAX.bit_length() + 1)) - 1
self.checkraises(OverflowError, '%*s', '__mod__',
- (PY_SSIZE_T_MAX + 1, ''))
+ (_testcapi.PY_SSIZE_T_MAX + 1, ''))
self.checkraises(OverflowError, '%.*f', '__mod__',
- (INT_MAX + 1, 1. / 7))
+ (_testcapi.INT_MAX + 1, 1. / 7))
# Issue 15989
self.checkraises(OverflowError, '%*s', '__mod__',
(SIZE_MAX + 1, ''))
self.checkraises(OverflowError, '%.*f', '__mod__',
- (UINT_MAX + 1, 1. / 7))
+ (_testcapi.UINT_MAX + 1, 1. / 7))
def test_floatformatting(self):
# float formatting
return unittest.skipUnless(lzma, reason)
def has_no_debug_ranges():
- import _testinternalcapi
+ try:
+ import _testinternalcapi
+ except ImportError:
+ raise unittest.SkipTest("_testinternalcapi required")
config = _testinternalcapi.get_config()
return bool(config['no_debug_ranges'])
_TPFLAGS_HEAPTYPE = 1<<9
def check_sizeof(test, o, size):
- import _testinternalcapi
+ 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\
import collections.abc
import unittest
from test import support
+from test.support import import_helper
from test.support import os_helper
from test.support import _2G
import weakref
@support.cpython_only
def test_obsolete_write_lock(self):
- from _testcapi import getbuffer_with_null_view
+ _testcapi = import_helper.import_module('_testcapi')
a = array.array('B', b"")
- self.assertRaises(BufferError, getbuffer_with_null_view, a)
+ self.assertRaises(BufferError, _testcapi.getbuffer_with_null_view, a)
def test_free_after_iterating(self):
support.check_free_after_iterating(self, iter, array.array,
@test.support.cpython_only
def test_obsolete_write_lock(self):
- from _testcapi import getbuffer_with_null_view
- self.assertRaises(BufferError, getbuffer_with_null_view, bytearray())
+ _testcapi = import_helper.import_module('_testcapi')
+ self.assertRaises(BufferError, _testcapi.getbuffer_with_null_view, bytearray())
def test_iterator_pickling2(self):
orig = bytearray(b'abc')
-from test.support import requires_IEEE_754, cpython_only
+from test.support import requires_IEEE_754, cpython_only, import_helper
from test.test_math import parse_testfile, test_file
import test.test_math as test_math
import unittest
@cpython_only
def test_polar_errno(self):
# Issue #24489: check a previously set C errno doesn't disturb polar()
- from _testcapi import set_errno
+ _testcapi = import_helper.import_module('_testcapi')
def polar_with_errno_set(z):
- set_errno(11)
+ _testcapi.set_errno(11)
try:
return polar(z)
finally:
- set_errno(0)
+ _testcapi.set_errno(0)
self.check_polar(polar_with_errno_set)
def test_phase(self):
"encoding=%r" % encoding)
@support.cpython_only
+ @unittest.skipIf(_testcapi is None, 'need _testcapi module')
def test_basics_capi(self):
s = "abc123" # all codecs should be able to encode these
for encoding in all_unicode_encodings:
import unittest
import weakref
from test import support
+from test.support import import_helper
class DictTest(unittest.TestCase):
# Test _PyDict_GetItem_KnownHash()
@support.cpython_only
def test_getitem_knownhash(self):
- from _testcapi import dict_getitem_knownhash
+ _testcapi = import_helper.import_module('_testcapi')
+ dict_getitem_knownhash = _testcapi.dict_getitem_knownhash
d = {'x': 1, 'y': 2, 'z': 3}
self.assertEqual(dict_getitem_knownhash(d, 'x', hash('x')), 1)
class SetConfigTests(unittest.TestCase):
def test_set_config(self):
# bpo-42260: Test _PyInterpreterState_SetConfig()
+ import_helper.import_module('_testcapi')
cmd = [sys.executable, '-I', '-m', 'test._test_embed_set_config']
proc = subprocess.run(cmd,
stdout=subprocess.PIPE,
import unittest
from test import support
+from test.support import import_helper
from test.test_grammar import (VALID_UNDERSCORE_LITERALS,
INVALID_UNDERSCORE_LITERALS)
from math import isinf, isnan, copysign, ldexp
@support.requires_IEEE_754
def test_serialized_float_rounding(self):
- from _testcapi import FLT_MAX
+ FLT_MAX = import_helper.import_module('_testcapi').FLT_MAX
self.assertEqual(struct.pack("<f", 3.40282356e38), struct.pack("<f", FLT_MAX))
self.assertEqual(struct.pack("<f", -3.40282356e38), struct.pack("<f", -FLT_MAX))
import sys
from test import support
+from test.support import import_helper
from test.support.script_helper import assert_python_ok
ISBIGENDIAN = sys.byteorder == "big"
@support.cpython_only
def test_issue45034_unsigned(self):
- from _testcapi import USHRT_MAX
- error_msg = f'ushort format requires 0 <= number <= {USHRT_MAX}'
+ _testcapi = import_helper.import_module('_testcapi')
+ error_msg = f'ushort format requires 0 <= number <= {_testcapi.USHRT_MAX}'
with self.assertRaisesRegex(struct.error, error_msg):
struct.pack('H', 70000) # too large
with self.assertRaisesRegex(struct.error, error_msg):
@support.cpython_only
def test_issue45034_signed(self):
- from _testcapi import SHRT_MIN, SHRT_MAX
- error_msg = f'short format requires {SHRT_MIN} <= number <= {SHRT_MAX}'
+ _testcapi = import_helper.import_module('_testcapi')
+ error_msg = f'short format requires {_testcapi.SHRT_MIN} <= number <= {_testcapi.SHRT_MAX}'
with self.assertRaisesRegex(struct.error, error_msg):
struct.pack('h', 70000) # too large
with self.assertRaisesRegex(struct.error, error_msg):
from test import support, string_tests
from test.support.script_helper import assert_python_failure
+try:
+ import _testcapi
+except ImportError:
+ _testcapi = None
+
# Error handling (bad decoder return)
def search_function(encoding):
def decode1(input, errors="strict"):
@support.cpython_only
@support.requires_legacy_unicode_capi
+ @unittest.skipIf(_testcapi is None, 'need _testcapi module')
def test_isidentifier_legacy(self):
- import _testcapi
u = '𝖀𝖓𝖎𝖈𝖔𝖉𝖊'
self.assertTrue(u.isidentifier())
with warnings_helper.check_warnings():
"Success, self.__rmod__('lhs %% %r') was called")
@support.cpython_only
+ @unittest.skipIf(_testcapi is None, 'need _testcapi module')
def test_formatting_huge_precision_c_limits(self):
- from _testcapi import INT_MAX
- format_string = "%.{}f".format(INT_MAX + 1)
+ format_string = "%.{}f".format(_testcapi.INT_MAX + 1)
with self.assertRaises(ValueError):
result = format_string % 2.34
@support.cpython_only
@support.requires_legacy_unicode_capi
+ @unittest.skipIf(_testcapi is None, 'need _testcapi module')
def test_resize(self):
- from _testcapi import getargs_u
for length in range(1, 100, 7):
# generate a fresh string (refcount=1)
text = 'a' * length + 'b'
# fill wstr internal field
with self.assertWarns(DeprecationWarning):
- abc = getargs_u(text)
+ abc = _testcapi.getargs_u(text)
self.assertEqual(abc, text)
# resize text: wstr field must be cleared and then recomputed
text += 'c'
with self.assertWarns(DeprecationWarning):
- abcdef = getargs_u(text)
+ abcdef = _testcapi.getargs_u(text)
self.assertNotEqual(abc, abcdef)
self.assertEqual(abcdef, text)
# Test PyUnicode_AsWideChar()
@support.cpython_only
+ @unittest.skipIf(_testcapi is None, 'need _testcapi module')
def test_aswidechar(self):
from _testcapi import unicode_aswidechar
import_helper.import_module('ctypes')
# Test PyUnicode_AsWideCharString()
@support.cpython_only
+ @unittest.skipIf(_testcapi is None, 'need _testcapi module')
def test_aswidecharstring(self):
from _testcapi import unicode_aswidecharstring
import_helper.import_module('ctypes')
# Test PyUnicode_AsUCS4()
@support.cpython_only
+ @unittest.skipIf(_testcapi is None, 'need _testcapi module')
def test_asucs4(self):
from _testcapi import unicode_asucs4
for s in ['abc', '\xa1\xa2', '\u4f60\u597d', 'a\U0001f600',
# Test PyUnicode_AsUTF8()
@support.cpython_only
+ @unittest.skipIf(_testcapi is None, 'need _testcapi module')
def test_asutf8(self):
from _testcapi import unicode_asutf8
# Test PyUnicode_AsUTF8AndSize()
@support.cpython_only
+ @unittest.skipIf(_testcapi is None, 'need _testcapi module')
def test_asutf8andsize(self):
from _testcapi import unicode_asutf8andsize
# Test PyUnicode_FindChar()
@support.cpython_only
+ @unittest.skipIf(_testcapi is None, 'need _testcapi module')
def test_findchar(self):
from _testcapi import unicode_findchar
# Test PyUnicode_CopyCharacters()
@support.cpython_only
+ @unittest.skipIf(_testcapi is None, 'need _testcapi module')
def test_copycharacters(self):
from _testcapi import unicode_copycharacters
self.assertRaises(SystemError, unicode_copycharacters, s, 0, b'', 0, 0)
@support.cpython_only
+ @unittest.skipIf(_testcapi is None, 'need _testcapi module')
def test_pep393_utf8_caching_bug(self):
# Issue #25709: Problem with string concatenation and utf-8 cache
from _testcapi import getargs_s_hash
--- /dev/null
+PGO tests now pass when Python is built without test extension modules.
projects / thirdparty / Python / cpython.git / commitdiff
