Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

gh-116417: Move limited C API long.c tests to _testlimitedcapi (#117001) 

* Split long.c tests of _testcapi into two parts: limited C API tests
  in _testlimitedcapi and non-limited C API tests in _testcapi.
* Move testcapi_long.h from Modules/_testcapi/ to
  Modules/_testlimitedcapi/.
* Add MODULE__TESTLIMITEDCAPI_DEPS to Makefile.pre.in.
This commit is contained in:
Victor Stinner 2024-03-19 15:04:23 +01:00 committed by GitHub
parent a114d08a89
commit 3cac2af5ec
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
12 changed files with 962 additions and 916 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
Lib/test/test_capi/test_long.py
View File

@ -4,8 +4,9 @@ import test.support as support
from test.support import import_helper
# Skip this test if the _testcapi module isn't available.
# Skip this test if the _testcapi and _testlimitedcapi modules isn't available.
_testcapi = import_helper.import_module('_testcapi')
_testlimitedcapi = import_helper.import_module('_testlimitedcapi')
NULL = None
@ -56,7 +57,7 @@ class LongTests(unittest.TestCase):
def test_long_check(self):
# Test PyLong_Check()
check = _testcapi.pylong_check
check = _testlimitedcapi.pylong_check
self.assertTrue(check(1))
self.assertTrue(check(123456789012345678901234567890))
self.assertTrue(check(-1))
@ -68,7 +69,7 @@ class LongTests(unittest.TestCase):
def test_long_checkexact(self):
# Test PyLong_CheckExact()
check = _testcapi.pylong_checkexact
check = _testlimitedcapi.pylong_checkexact
self.assertTrue(check(1))
self.assertTrue(check(123456789012345678901234567890))
self.assertTrue(check(-1))
@ -80,7 +81,7 @@ class LongTests(unittest.TestCase):
def test_long_fromdouble(self):
# Test PyLong_FromDouble()
fromdouble = _testcapi.pylong_fromdouble
fromdouble = _testlimitedcapi.pylong_fromdouble
float_max = sys.float_info.max
for value in (5.0, 5.1, 5.9, -5.1, -5.9, 0.0, -0.0, float_max, -float_max):
with self.subTest(value=value):
@ -91,7 +92,7 @@ class LongTests(unittest.TestCase):
def test_long_fromvoidptr(self):
# Test PyLong_FromVoidPtr()
fromvoidptr = _testcapi.pylong_fromvoidptr
fromvoidptr = _testlimitedcapi.pylong_fromvoidptr
obj = object()
x = fromvoidptr(obj)
y = fromvoidptr(NULL)
@ -103,7 +104,7 @@ class LongTests(unittest.TestCase):
def test_long_fromstring(self):
# Test PyLong_FromString()
fromstring = _testcapi.pylong_fromstring
fromstring = _testlimitedcapi.pylong_fromstring
self.assertEqual(fromstring(b'123', 10), (123, 3))
self.assertEqual(fromstring(b'cafe', 16), (0xcafe, 4))
self.assertEqual(fromstring(b'xyz', 36), (44027, 3))
@ -163,7 +164,7 @@ class LongTests(unittest.TestCase):
def test_long_asint(self):
# Test PyLong_AsInt()
PyLong_AsInt = _testcapi.PyLong_AsInt
PyLong_AsInt = _testlimitedcapi.PyLong_AsInt
from _testcapi import INT_MIN, INT_MAX
# round trip (object -> int -> object)
@ -186,7 +187,7 @@ class LongTests(unittest.TestCase):
def test_long_aslong(self):
# Test PyLong_AsLong() and PyLong_FromLong()
aslong = _testcapi.pylong_aslong
aslong = _testlimitedcapi.pylong_aslong
from _testcapi import LONG_MIN, LONG_MAX
# round trip (object -> long -> object)
for value in (LONG_MIN, LONG_MAX, -1, 0, 1, 1234):
@ -206,7 +207,7 @@ class LongTests(unittest.TestCase):
def test_long_aslongandoverflow(self):
# Test PyLong_AsLongAndOverflow()
aslongandoverflow = _testcapi.pylong_aslongandoverflow
aslongandoverflow = _testlimitedcapi.pylong_aslongandoverflow
from _testcapi import LONG_MIN, LONG_MAX
# round trip (object -> long -> object)
for value in (LONG_MIN, LONG_MAX, -1, 0, 1, 1234):
@ -224,7 +225,7 @@ class LongTests(unittest.TestCase):
def test_long_asunsignedlong(self):
# Test PyLong_AsUnsignedLong() and PyLong_FromUnsignedLong()
asunsignedlong = _testcapi.pylong_asunsignedlong
asunsignedlong = _testlimitedcapi.pylong_asunsignedlong
from _testcapi import ULONG_MAX
# round trip (object -> unsigned long -> object)
for value in (ULONG_MAX, 0, 1, 1234):
@ -244,7 +245,7 @@ class LongTests(unittest.TestCase):
def test_long_asunsignedlongmask(self):
# Test PyLong_AsUnsignedLongMask()
asunsignedlongmask = _testcapi.pylong_asunsignedlongmask
asunsignedlongmask = _testlimitedcapi.pylong_asunsignedlongmask
from _testcapi import ULONG_MAX
# round trip (object -> unsigned long -> object)
for value in (ULONG_MAX, 0, 1, 1234):
@ -264,7 +265,7 @@ class LongTests(unittest.TestCase):
def test_long_aslonglong(self):
# Test PyLong_AsLongLong() and PyLong_FromLongLong()
aslonglong = _testcapi.pylong_aslonglong
aslonglong = _testlimitedcapi.pylong_aslonglong
from _testcapi import LLONG_MIN, LLONG_MAX
# round trip (object -> long long -> object)
for value in (LLONG_MIN, LLONG_MAX, -1, 0, 1, 1234):
@ -284,7 +285,7 @@ class LongTests(unittest.TestCase):
def test_long_aslonglongandoverflow(self):
# Test PyLong_AsLongLongAndOverflow()
aslonglongandoverflow = _testcapi.pylong_aslonglongandoverflow
aslonglongandoverflow = _testlimitedcapi.pylong_aslonglongandoverflow
from _testcapi import LLONG_MIN, LLONG_MAX
# round trip (object -> long long -> object)
for value in (LLONG_MIN, LLONG_MAX, -1, 0, 1, 1234):
@ -302,7 +303,7 @@ class LongTests(unittest.TestCase):
def test_long_asunsignedlonglong(self):
# Test PyLong_AsUnsignedLongLong() and PyLong_FromUnsignedLongLong()
asunsignedlonglong = _testcapi.pylong_asunsignedlonglong
asunsignedlonglong = _testlimitedcapi.pylong_asunsignedlonglong
from _testcapi import ULLONG_MAX
# round trip (object -> unsigned long long -> object)
for value in (ULLONG_MAX, 0, 1, 1234):
@ -322,7 +323,7 @@ class LongTests(unittest.TestCase):
def test_long_asunsignedlonglongmask(self):
# Test PyLong_AsUnsignedLongLongMask()
asunsignedlonglongmask = _testcapi.pylong_asunsignedlonglongmask
asunsignedlonglongmask = _testlimitedcapi.pylong_asunsignedlonglongmask
from _testcapi import ULLONG_MAX
# round trip (object -> unsigned long long -> object)
for value in (ULLONG_MAX, 0, 1, 1234):
@ -342,7 +343,7 @@ class LongTests(unittest.TestCase):
def test_long_as_ssize_t(self):
# Test PyLong_AsSsize_t() and PyLong_FromSsize_t()
as_ssize_t = _testcapi.pylong_as_ssize_t
as_ssize_t = _testlimitedcapi.pylong_as_ssize_t
from _testcapi import PY_SSIZE_T_MIN, PY_SSIZE_T_MAX
# round trip (object -> Py_ssize_t -> object)
for value in (PY_SSIZE_T_MIN, PY_SSIZE_T_MAX, -1, 0, 1, 1234):
@ -362,7 +363,7 @@ class LongTests(unittest.TestCase):
def test_long_as_size_t(self):
# Test PyLong_AsSize_t() and PyLong_FromSize_t()
as_size_t = _testcapi.pylong_as_size_t
as_size_t = _testlimitedcapi.pylong_as_size_t
from _testcapi import SIZE_MAX
# round trip (object -> size_t -> object)
for value in (SIZE_MAX, 0, 1, 1234):
@ -382,7 +383,7 @@ class LongTests(unittest.TestCase):
def test_long_asdouble(self):
# Test PyLong_AsDouble()
asdouble = _testcapi.pylong_asdouble
asdouble = _testlimitedcapi.pylong_asdouble
MAX = int(sys.float_info.max)
for value in (-MAX, MAX, -1, 0, 1, 1234):
with self.subTest(value=value):
@ -402,8 +403,8 @@ class LongTests(unittest.TestCase):
def test_long_asvoidptr(self):
# Test PyLong_AsVoidPtr()
fromvoidptr = _testcapi.pylong_fromvoidptr
asvoidptr = _testcapi.pylong_asvoidptr
fromvoidptr = _testlimitedcapi.pylong_fromvoidptr
asvoidptr = _testlimitedcapi.pylong_asvoidptr
obj = object()
x = fromvoidptr(obj)
y = fromvoidptr(NULL)

3
Makefile.pre.in
View File

@ -3051,7 +3051,8 @@ MODULE__SHA2_DEPS=$(srcdir)/Modules/hashlib.h $(LIBHACL_SHA2_HEADERS) $(LIBHACL_
MODULE__SHA3_DEPS=$(srcdir)/Modules/hashlib.h $(LIBHACL_HEADERS) Modules/_hacl/Hacl_Hash_SHA3.h Modules/_hacl/Hacl_Hash_SHA3.c
MODULE__SOCKET_DEPS=$(srcdir)/Modules/socketmodule.h $(srcdir)/Modules/addrinfo.h $(srcdir)/Modules/getaddrinfo.c $(srcdir)/Modules/getnameinfo.c
MODULE__SSL_DEPS=$(srcdir)/Modules/_ssl.h $(srcdir)/Modules/_ssl/cert.c $(srcdir)/Modules/_ssl/debughelpers.c $(srcdir)/Modules/_ssl/misc.c $(srcdir)/Modules/_ssl_data_111.h $(srcdir)/Modules/_ssl_data_300.h $(srcdir)/Modules/socketmodule.h
MODULE__TESTCAPI_DEPS=$(srcdir)/Modules/_testcapi/testcapi_long.h $(srcdir)/Modules/_testcapi/parts.h $(srcdir)/Modules/_testcapi/util.h
MODULE__TESTCAPI_DEPS=$(srcdir)/Modules/_testcapi/parts.h $(srcdir)/Modules/_testcapi/util.h
MODULE__TESTLIMITEDCAPI_DEPS=$(srcdir)/Modules/_testlimitedcapi/testcapi_long.h $(srcdir)/Modules/_testlimitedcapi/parts.h $(srcdir)/Modules/_testlimitedcapi/util.h
MODULE__TESTINTERNALCAPI_DEPS=$(srcdir)/Modules/_testinternalcapi/parts.h
MODULE__SQLITE3_DEPS=$(srcdir)/Modules/_sqlite/connection.h $(srcdir)/Modules/_sqlite/cursor.h $(srcdir)/Modules/_sqlite/microprotocols.h $(srcdir)/Modules/_sqlite/module.h $(srcdir)/Modules/_sqlite/prepare_protocol.h $(srcdir)/Modules/_sqlite/row.h $(srcdir)/Modules/_sqlite/util.h

2
Modules/Setup.stdlib.in
View File

@ -163,7 +163,7 @@
@MODULE__TESTBUFFER_TRUE@_testbuffer _testbuffer.c
@MODULE__TESTINTERNALCAPI_TRUE@_testinternalcapi _testinternalcapi.c _testinternalcapi/test_lock.c _testinternalcapi/pytime.c _testinternalcapi/set.c _testinternalcapi/test_critical_sections.c
@MODULE__TESTCAPI_TRUE@_testcapi _testcapimodule.c _testcapi/vectorcall.c _testcapi/heaptype.c _testcapi/abstract.c _testcapi/unicode.c _testcapi/dict.c _testcapi/set.c _testcapi/list.c _testcapi/tuple.c _testcapi/getargs.c _testcapi/datetime.c _testcapi/docstring.c _testcapi/mem.c _testcapi/watchers.c _testcapi/long.c _testcapi/float.c _testcapi/complex.c _testcapi/numbers.c _testcapi/structmember.c _testcapi/exceptions.c _testcapi/code.c _testcapi/buffer.c _testcapi/pyatomic.c _testcapi/file.c _testcapi/codec.c _testcapi/immortal.c _testcapi/gc.c _testcapi/hash.c _testcapi/time.c
@MODULE__TESTLIMITEDCAPI_TRUE@_testlimitedcapi _testlimitedcapi.c _testlimitedcapi/abstract.c _testlimitedcapi/bytearray.c _testlimitedcapi/bytes.c _testlimitedcapi/float.c _testlimitedcapi/heaptype_relative.c _testlimitedcapi/list.c _testlimitedcapi/pyos.c _testlimitedcapi/set.c _testlimitedcapi/sys.c _testlimitedcapi/unicode.c _testlimitedcapi/vectorcall_limited.c
@MODULE__TESTLIMITEDCAPI_TRUE@_testlimitedcapi _testlimitedcapi.c _testlimitedcapi/abstract.c _testlimitedcapi/bytearray.c _testlimitedcapi/bytes.c _testlimitedcapi/float.c _testlimitedcapi/heaptype_relative.c _testlimitedcapi/list.c _testlimitedcapi/long.c _testlimitedcapi/pyos.c _testlimitedcapi/set.c _testlimitedcapi/sys.c _testlimitedcapi/unicode.c _testlimitedcapi/vectorcall_limited.c
@MODULE__TESTCLINIC_TRUE@_testclinic _testclinic.c
@MODULE__TESTCLINIC_LIMITED_TRUE@_testclinic_limited _testclinic_limited.c

141
Modules/_testcapi/clinic/long.c.h generated
View File

@ -2,137 +2,6 @@
preserve
[clinic start generated code]*/
PyDoc_STRVAR(_testcapi_test_long_api__doc__,
"test_long_api($module, /)\n"
"--\n"
"\n");
#define _TESTCAPI_TEST_LONG_API_METHODDEF \
{"test_long_api", (PyCFunction)_testcapi_test_long_api, METH_NOARGS, _testcapi_test_long_api__doc__},
static PyObject *
_testcapi_test_long_api_impl(PyObject *module);
static PyObject *
_testcapi_test_long_api(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _testcapi_test_long_api_impl(module);
}
PyDoc_STRVAR(_testcapi_test_longlong_api__doc__,
"test_longlong_api($module, /)\n"
"--\n"
"\n");
#define _TESTCAPI_TEST_LONGLONG_API_METHODDEF \
{"test_longlong_api", (PyCFunction)_testcapi_test_longlong_api, METH_NOARGS, _testcapi_test_longlong_api__doc__},
static PyObject *
_testcapi_test_longlong_api_impl(PyObject *module);
static PyObject *
_testcapi_test_longlong_api(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _testcapi_test_longlong_api_impl(module);
}
PyDoc_STRVAR(_testcapi_test_long_and_overflow__doc__,
"test_long_and_overflow($module, /)\n"
"--\n"
"\n"
"Test the PyLong_AsLongAndOverflow API.\n"
"\n"
"General conversion to PY_LONG is tested by test_long_api_inner.\n"
"This test will concentrate on proper handling of overflow.");
#define _TESTCAPI_TEST_LONG_AND_OVERFLOW_METHODDEF \
{"test_long_and_overflow", (PyCFunction)_testcapi_test_long_and_overflow, METH_NOARGS, _testcapi_test_long_and_overflow__doc__},
static PyObject *
_testcapi_test_long_and_overflow_impl(PyObject *module);
static PyObject *
_testcapi_test_long_and_overflow(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _testcapi_test_long_and_overflow_impl(module);
}
PyDoc_STRVAR(_testcapi_test_long_long_and_overflow__doc__,
"test_long_long_and_overflow($module, /)\n"
"--\n"
"\n"
"Test the PyLong_AsLongLongAndOverflow API.\n"
"\n"
"General conversion to long long is tested by test_long_api_inner.\n"
"This test will concentrate on proper handling of overflow.");
#define _TESTCAPI_TEST_LONG_LONG_AND_OVERFLOW_METHODDEF \
{"test_long_long_and_overflow", (PyCFunction)_testcapi_test_long_long_and_overflow, METH_NOARGS, _testcapi_test_long_long_and_overflow__doc__},
static PyObject *
_testcapi_test_long_long_and_overflow_impl(PyObject *module);
static PyObject *
_testcapi_test_long_long_and_overflow(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _testcapi_test_long_long_and_overflow_impl(module);
}
PyDoc_STRVAR(_testcapi_test_long_as_size_t__doc__,
"test_long_as_size_t($module, /)\n"
"--\n"
"\n"
"Test the PyLong_As{Size,Ssize}_t API.\n"
"\n"
"At present this just tests that non-integer arguments are handled correctly.\n"
"It should be extended to test overflow handling.");
#define _TESTCAPI_TEST_LONG_AS_SIZE_T_METHODDEF \
{"test_long_as_size_t", (PyCFunction)_testcapi_test_long_as_size_t, METH_NOARGS, _testcapi_test_long_as_size_t__doc__},
static PyObject *
_testcapi_test_long_as_size_t_impl(PyObject *module);
static PyObject *
_testcapi_test_long_as_size_t(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _testcapi_test_long_as_size_t_impl(module);
}
PyDoc_STRVAR(_testcapi_test_long_as_unsigned_long_long_mask__doc__,
"test_long_as_unsigned_long_long_mask($module, /)\n"
"--\n"
"\n");
#define _TESTCAPI_TEST_LONG_AS_UNSIGNED_LONG_LONG_MASK_METHODDEF \
{"test_long_as_unsigned_long_long_mask", (PyCFunction)_testcapi_test_long_as_unsigned_long_long_mask, METH_NOARGS, _testcapi_test_long_as_unsigned_long_long_mask__doc__},
static PyObject *
_testcapi_test_long_as_unsigned_long_long_mask_impl(PyObject *module);
static PyObject *
_testcapi_test_long_as_unsigned_long_long_mask(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _testcapi_test_long_as_unsigned_long_long_mask_impl(module);
}
PyDoc_STRVAR(_testcapi_test_long_as_double__doc__,
"test_long_as_double($module, /)\n"
"--\n"
"\n");
#define _TESTCAPI_TEST_LONG_AS_DOUBLE_METHODDEF \
{"test_long_as_double", (PyCFunction)_testcapi_test_long_as_double, METH_NOARGS, _testcapi_test_long_as_double__doc__},
static PyObject *
_testcapi_test_long_as_double_impl(PyObject *module);
static PyObject *
_testcapi_test_long_as_double(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _testcapi_test_long_as_double_impl(module);
}
PyDoc_STRVAR(_testcapi_call_long_compact_api__doc__,
"call_long_compact_api($module, arg, /)\n"
"--\n"
@ -140,12 +9,4 @@ PyDoc_STRVAR(_testcapi_call_long_compact_api__doc__,
#define _TESTCAPI_CALL_LONG_COMPACT_API_METHODDEF \
{"call_long_compact_api", (PyCFunction)_testcapi_call_long_compact_api, METH_O, _testcapi_call_long_compact_api__doc__},
PyDoc_STRVAR(_testcapi_PyLong_AsInt__doc__,
"PyLong_AsInt($module, arg, /)\n"
"--\n"
"\n");
#define _TESTCAPI_PYLONG_ASINT_METHODDEF \
{"PyLong_AsInt", (PyCFunction)_testcapi_PyLong_AsInt, METH_O, _testcapi_PyLong_AsInt__doc__},
/*[clinic end generated code: output=de762870526e241d input=a9049054013a1b77]*/
/*[clinic end generated code: output=0ddcbc6ea06e5e21 input=a9049054013a1b77]*/

755
Modules/_testcapi/long.c
View File

@ -12,529 +12,6 @@ module _testcapi
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=6361033e795369fc]*/
static PyObject *
raiseTestError(const char* test_name, const char* msg)
{
PyErr_Format(PyExc_AssertionError, "%s: %s", test_name, msg);
return NULL;
}
/* Tests of PyLong_{As, From}{Unsigned,}Long(), and
PyLong_{As, From}{Unsigned,}LongLong().
Note that the meat of the test is contained in testcapi_long.h.
This is revolting, but delicate code duplication is worse: "almost
exactly the same" code is needed to test long long, but the ubiquitous
dependence on type names makes it impossible to use a parameterized
function. A giant macro would be even worse than this. A C++ template
would be perfect.
The "report an error" functions are deliberately not part of the #include
file: if the test fails, you can set a breakpoint in the appropriate
error function directly, and crawl back from there in the debugger.
*/
#define UNBIND(X) Py_DECREF(X); (X) = NULL
static PyObject *
raise_test_long_error(const char* msg)
{
return raiseTestError("test_long_api", msg);
}
// Test PyLong_FromLong()/PyLong_AsLong()
// and PyLong_FromUnsignedLong()/PyLong_AsUnsignedLong().
#define TESTNAME test_long_api_inner
#define TYPENAME long
#define F_S_TO_PY PyLong_FromLong
#define F_PY_TO_S PyLong_AsLong
#define F_U_TO_PY PyLong_FromUnsignedLong
#define F_PY_TO_U PyLong_AsUnsignedLong
#include "testcapi_long.h"
/*[clinic input]
_testcapi.test_long_api
[clinic start generated code]*/
static PyObject *
_testcapi_test_long_api_impl(PyObject *module)
/*[clinic end generated code: output=4405798ca1e9f444 input=e9b8880d7331c688]*/
{
return TESTNAME(raise_test_long_error);
}
#undef TESTNAME
#undef TYPENAME
#undef F_S_TO_PY
#undef F_PY_TO_S
#undef F_U_TO_PY
#undef F_PY_TO_U
// Test PyLong_FromLongLong()/PyLong_AsLongLong()
// and PyLong_FromUnsignedLongLong()/PyLong_AsUnsignedLongLong().
static PyObject *
raise_test_longlong_error(const char* msg)
{
return raiseTestError("test_longlong_api", msg);
}
#define TESTNAME test_longlong_api_inner
#define TYPENAME long long
#define F_S_TO_PY PyLong_FromLongLong
#define F_PY_TO_S PyLong_AsLongLong
#define F_U_TO_PY PyLong_FromUnsignedLongLong
#define F_PY_TO_U PyLong_AsUnsignedLongLong
#include "testcapi_long.h"
/*[clinic input]
_testcapi.test_longlong_api
[clinic start generated code]*/
static PyObject *
_testcapi_test_longlong_api_impl(PyObject *module)
/*[clinic end generated code: output=2b3414ba8c31dfe6 input=ccbb2a48c2b3c4a5]*/
{
return TESTNAME(raise_test_longlong_error);
}
#undef TESTNAME
#undef TYPENAME
#undef F_S_TO_PY
#undef F_PY_TO_S
#undef F_U_TO_PY
#undef F_PY_TO_U
/*[clinic input]
_testcapi.test_long_and_overflow
Test the PyLong_AsLongAndOverflow API.
General conversion to PY_LONG is tested by test_long_api_inner.
This test will concentrate on proper handling of overflow.
[clinic start generated code]*/
static PyObject *
_testcapi_test_long_and_overflow_impl(PyObject *module)
/*[clinic end generated code: output=f8460ca115e31d8e input=762f6b62da0a3cdc]*/
{
PyObject *num, *one, *temp;
long value;
int overflow;
/* Test that overflow is set properly for a large value. */
/* num is a number larger than LONG_MAX even on 64-bit platforms */
num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
if (num == NULL)
return NULL;
overflow = 1234;
value = PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -1)
return raiseTestError("test_long_and_overflow",
"return value was not set to -1");
if (overflow != 1)
return raiseTestError("test_long_and_overflow",
"overflow was not set to 1");
/* Same again, with num = LONG_MAX + 1 */
num = PyLong_FromLong(LONG_MAX);
if (num == NULL)
return NULL;
one = PyLong_FromLong(1L);
if (one == NULL) {
Py_DECREF(num);
return NULL;
}
temp = PyNumber_Add(num, one);
Py_DECREF(one);
Py_SETREF(num, temp);
if (num == NULL)
return NULL;
overflow = 0;
value = PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -1)
return raiseTestError("test_long_and_overflow",
"return value was not set to -1");
if (overflow != 1)
return raiseTestError("test_long_and_overflow",
"overflow was not set to 1");
/* Test that overflow is set properly for a large negative value. */
/* num is a number smaller than LONG_MIN even on 64-bit platforms */
num = PyLong_FromString("-FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
if (num == NULL)
return NULL;
overflow = 1234;
value = PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -1)
return raiseTestError("test_long_and_overflow",
"return value was not set to -1");
if (overflow != -1)
return raiseTestError("test_long_and_overflow",
"overflow was not set to -1");
/* Same again, with num = LONG_MIN - 1 */
num = PyLong_FromLong(LONG_MIN);
if (num == NULL)
return NULL;
one = PyLong_FromLong(1L);
if (one == NULL) {
Py_DECREF(num);
return NULL;
}
temp = PyNumber_Subtract(num, one);
Py_DECREF(one);
Py_SETREF(num, temp);
if (num == NULL)
return NULL;
overflow = 0;
value = PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -1)
return raiseTestError("test_long_and_overflow",
"return value was not set to -1");
if (overflow != -1)
return raiseTestError("test_long_and_overflow",
"overflow was not set to -1");
/* Test that overflow is cleared properly for small values. */
num = PyLong_FromString("FF", NULL, 16);
if (num == NULL)
return NULL;
overflow = 1234;
value = PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != 0xFF)
return raiseTestError("test_long_and_overflow",
"expected return value 0xFF");
if (overflow != 0)
return raiseTestError("test_long_and_overflow",
"overflow was not cleared");
num = PyLong_FromString("-FF", NULL, 16);
if (num == NULL)
return NULL;
overflow = 0;
value = PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -0xFF)
return raiseTestError("test_long_and_overflow",
"expected return value 0xFF");
if (overflow != 0)
return raiseTestError("test_long_and_overflow",
"overflow was set incorrectly");
num = PyLong_FromLong(LONG_MAX);
if (num == NULL)
return NULL;
overflow = 1234;
value = PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != LONG_MAX)
return raiseTestError("test_long_and_overflow",
"expected return value LONG_MAX");
if (overflow != 0)
return raiseTestError("test_long_and_overflow",
"overflow was not cleared");
num = PyLong_FromLong(LONG_MIN);
if (num == NULL)
return NULL;
overflow = 0;
value = PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != LONG_MIN)
return raiseTestError("test_long_and_overflow",
"expected return value LONG_MIN");
if (overflow != 0)
return raiseTestError("test_long_and_overflow",
"overflow was not cleared");
Py_RETURN_NONE;
}
/*[clinic input]
_testcapi.test_long_long_and_overflow
Test the PyLong_AsLongLongAndOverflow API.
General conversion to long long is tested by test_long_api_inner.
This test will concentrate on proper handling of overflow.
[clinic start generated code]*/
static PyObject *
_testcapi_test_long_long_and_overflow_impl(PyObject *module)
/*[clinic end generated code: output=0b92330786f45483 input=544bb0aefe5e8a9e]*/
{
PyObject *num, *one, *temp;
long long value;
int overflow;
/* Test that overflow is set properly for a large value. */
/* num is a number larger than LLONG_MAX on a typical machine. */
num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
if (num == NULL)
return NULL;
overflow = 1234;
value = PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -1)
return raiseTestError("test_long_long_and_overflow",
"return value was not set to -1");
if (overflow != 1)
return raiseTestError("test_long_long_and_overflow",
"overflow was not set to 1");
/* Same again, with num = LLONG_MAX + 1 */
num = PyLong_FromLongLong(LLONG_MAX);
if (num == NULL)
return NULL;
one = PyLong_FromLong(1L);
if (one == NULL) {
Py_DECREF(num);
return NULL;
}
temp = PyNumber_Add(num, one);
Py_DECREF(one);
Py_SETREF(num, temp);
if (num == NULL)
return NULL;
overflow = 0;
value = PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -1)
return raiseTestError("test_long_long_and_overflow",
"return value was not set to -1");
if (overflow != 1)
return raiseTestError("test_long_long_and_overflow",
"overflow was not set to 1");
/* Test that overflow is set properly for a large negative value. */
/* num is a number smaller than LLONG_MIN on a typical platform */
num = PyLong_FromString("-FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
if (num == NULL)
return NULL;
overflow = 1234;
value = PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -1)
return raiseTestError("test_long_long_and_overflow",
"return value was not set to -1");
if (overflow != -1)
return raiseTestError("test_long_long_and_overflow",
"overflow was not set to -1");
/* Same again, with num = LLONG_MIN - 1 */
num = PyLong_FromLongLong(LLONG_MIN);
if (num == NULL)
return NULL;
one = PyLong_FromLong(1L);
if (one == NULL) {
Py_DECREF(num);
return NULL;
}
temp = PyNumber_Subtract(num, one);
Py_DECREF(one);
Py_SETREF(num, temp);
if (num == NULL)
return NULL;
overflow = 0;
value = PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -1)
return raiseTestError("test_long_long_and_overflow",
"return value was not set to -1");
if (overflow != -1)
return raiseTestError("test_long_long_and_overflow",
"overflow was not set to -1");
/* Test that overflow is cleared properly for small values. */
num = PyLong_FromString("FF", NULL, 16);
if (num == NULL)
return NULL;
overflow = 1234;
value = PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != 0xFF)
return raiseTestError("test_long_long_and_overflow",
"expected return value 0xFF");
if (overflow != 0)
return raiseTestError("test_long_long_and_overflow",
"overflow was not cleared");
num = PyLong_FromString("-FF", NULL, 16);
if (num == NULL)
return NULL;
overflow = 0;
value = PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -0xFF)
return raiseTestError("test_long_long_and_overflow",
"expected return value 0xFF");
if (overflow != 0)
return raiseTestError("test_long_long_and_overflow",
"overflow was set incorrectly");
num = PyLong_FromLongLong(LLONG_MAX);
if (num == NULL)
return NULL;
overflow = 1234;
value = PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != LLONG_MAX)
return raiseTestError("test_long_long_and_overflow",
"expected return value LLONG_MAX");
if (overflow != 0)
return raiseTestError("test_long_long_and_overflow",
"overflow was not cleared");
num = PyLong_FromLongLong(LLONG_MIN);
if (num == NULL)
return NULL;
overflow = 0;
value = PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != LLONG_MIN)
return raiseTestError("test_long_long_and_overflow",
"expected return value LLONG_MIN");
if (overflow != 0)
return raiseTestError("test_long_long_and_overflow",
"overflow was not cleared");
Py_RETURN_NONE;
}
/*[clinic input]
_testcapi.test_long_as_size_t
Test the PyLong_As{Size,Ssize}_t API.
At present this just tests that non-integer arguments are handled correctly.
It should be extended to test overflow handling.
[clinic start generated code]*/
static PyObject *
_testcapi_test_long_as_size_t_impl(PyObject *module)
/*[clinic end generated code: output=f6490ea2b41e6173 input=922990c4a3edfb0d]*/
{
size_t out_u;
Py_ssize_t out_s;
Py_INCREF(Py_None);
out_u = PyLong_AsSize_t(Py_None);
if (out_u != (size_t)-1 || !PyErr_Occurred())
return raiseTestError("test_long_as_size_t",
"PyLong_AsSize_t(None) didn't complain");
if (!PyErr_ExceptionMatches(PyExc_TypeError))
return raiseTestError("test_long_as_size_t",
"PyLong_AsSize_t(None) raised "
"something other than TypeError");
PyErr_Clear();
out_s = PyLong_AsSsize_t(Py_None);
if (out_s != (Py_ssize_t)-1 || !PyErr_Occurred())
return raiseTestError("test_long_as_size_t",
"PyLong_AsSsize_t(None) didn't complain");
if (!PyErr_ExceptionMatches(PyExc_TypeError))
return raiseTestError("test_long_as_size_t",
"PyLong_AsSsize_t(None) raised "
"something other than TypeError");
PyErr_Clear();
/* Py_INCREF(Py_None) omitted - we already have a reference to it. */
return Py_None;
}
/*[clinic input]
_testcapi.test_long_as_unsigned_long_long_mask
[clinic start generated code]*/
static PyObject *
_testcapi_test_long_as_unsigned_long_long_mask_impl(PyObject *module)
/*[clinic end generated code: output=e3e16cd0189440cc input=eb2438493ae7b9af]*/
{
unsigned long long res = PyLong_AsUnsignedLongLongMask(NULL);
if (res != (unsigned long long)-1 || !PyErr_Occurred()) {
return raiseTestError("test_long_as_unsigned_long_long_mask",
"PyLong_AsUnsignedLongLongMask(NULL) didn't "
"complain");
}
if (!PyErr_ExceptionMatches(PyExc_SystemError)) {
return raiseTestError("test_long_as_unsigned_long_long_mask",
"PyLong_AsUnsignedLongLongMask(NULL) raised "
"something other than SystemError");
}
PyErr_Clear();
Py_RETURN_NONE;
}
/*[clinic input]
_testcapi.test_long_as_double
[clinic start generated code]*/
static PyObject *
_testcapi_test_long_as_double_impl(PyObject *module)
/*[clinic end generated code: output=deca0898e15adde5 input=c77bc88ef5a1de76]*/
{
double out;
Py_INCREF(Py_None);
out = PyLong_AsDouble(Py_None);
if (out != -1.0 || !PyErr_Occurred())
return raiseTestError("test_long_as_double",
"PyLong_AsDouble(None) didn't complain");
if (!PyErr_ExceptionMatches(PyExc_TypeError))
return raiseTestError("test_long_as_double",
"PyLong_AsDouble(None) raised "
"something other than TypeError");
PyErr_Clear();
/* Py_INCREF(Py_None) omitted - we already have a reference to it. */
return Py_None;
}
/*[clinic input]
_testcapi.call_long_compact_api
arg: object
@ -555,48 +32,6 @@ _testcapi_call_long_compact_api(PyObject *module, PyObject *arg)
return Py_BuildValue("in", is_compact, value);
}
static PyObject *
pylong_check(PyObject *module, PyObject *obj)
{
NULLABLE(obj);
return PyLong_FromLong(PyLong_Check(obj));
}
static PyObject *
pylong_checkexact(PyObject *module, PyObject *obj)
{
NULLABLE(obj);
return PyLong_FromLong(PyLong_CheckExact(obj));
}
static PyObject *
pylong_fromdouble(PyObject *module, PyObject *arg)
{
double value;
if (!PyArg_Parse(arg, "d", &value)) {
return NULL;
}
return PyLong_FromDouble(value);
}
static PyObject *
pylong_fromstring(PyObject *module, PyObject *args)
{
const char *str;
Py_ssize_t len;
int base;
char *end = UNINITIALIZED_PTR;
if (!PyArg_ParseTuple(args, "z#i", &str, &len, &base)) {
return NULL;
}
PyObject *result = PyLong_FromString(str, &end, base);
if (result == NULL) {
// XXX 'end' is not always set.
return NULL;
}
return Py_BuildValue("Nn", result, (Py_ssize_t)(end - str));
}
static PyObject *
pylong_fromunicodeobject(PyObject *module, PyObject *args)
@ -611,170 +46,6 @@ pylong_fromunicodeobject(PyObject *module, PyObject *args)
return PyLong_FromUnicodeObject(unicode, base);
}
static PyObject *
pylong_fromvoidptr(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
return PyLong_FromVoidPtr((void *)arg);
}
/*[clinic input]
_testcapi.PyLong_AsInt
arg: object
/
[clinic start generated code]*/
static PyObject *
_testcapi_PyLong_AsInt(PyObject *module, PyObject *arg)
/*[clinic end generated code: output=0df9f19de5fa575b input=9561b97105493a67]*/
{
NULLABLE(arg);
assert(!PyErr_Occurred());
int value = PyLong_AsInt(arg);
if (value == -1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromLong(value);
}
static PyObject *
pylong_aslong(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
long value = PyLong_AsLong(arg);
if (value == -1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromLong(value);
}
static PyObject *
pylong_aslongandoverflow(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
int overflow = UNINITIALIZED_INT;
long value = PyLong_AsLongAndOverflow(arg, &overflow);
if (value == -1 && PyErr_Occurred()) {
assert(overflow == -1);
return NULL;
}
return Py_BuildValue("li", value, overflow);
}
static PyObject *
pylong_asunsignedlong(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
unsigned long value = PyLong_AsUnsignedLong(arg);
if (value == (unsigned long)-1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromUnsignedLong(value);
}
static PyObject *
pylong_asunsignedlongmask(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
unsigned long value = PyLong_AsUnsignedLongMask(arg);
if (value == (unsigned long)-1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromUnsignedLong(value);
}
static PyObject *
pylong_aslonglong(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
long long value = PyLong_AsLongLong(arg);
if (value == -1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromLongLong(value);
}
static PyObject *
pylong_aslonglongandoverflow(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
int overflow = UNINITIALIZED_INT;
long long value = PyLong_AsLongLongAndOverflow(arg, &overflow);
if (value == -1 && PyErr_Occurred()) {
assert(overflow == -1);
return NULL;
}
return Py_BuildValue("Li", value, overflow);
}
static PyObject *
pylong_asunsignedlonglong(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
unsigned long long value = PyLong_AsUnsignedLongLong(arg);
if (value == (unsigned long long)-1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromUnsignedLongLong(value);
}
static PyObject *
pylong_asunsignedlonglongmask(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
unsigned long long value = PyLong_AsUnsignedLongLongMask(arg);
if (value == (unsigned long long)-1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromUnsignedLongLong(value);
}
static PyObject *
pylong_as_ssize_t(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
Py_ssize_t value = PyLong_AsSsize_t(arg);
if (value == -1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromSsize_t(value);
}
static PyObject *
pylong_as_size_t(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
size_t value = PyLong_AsSize_t(arg);
if (value == (size_t)-1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromSize_t(value);
}
static PyObject *
pylong_asdouble(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
double value = PyLong_AsDouble(arg);
if (value == -1.0 && PyErr_Occurred()) {
return NULL;
}
return PyFloat_FromDouble(value);
}
static PyObject *
pylong_asvoidptr(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
void *value = PyLong_AsVoidPtr(arg);
if (value == NULL) {
if (PyErr_Occurred()) {
return NULL;
}
Py_RETURN_NONE;
}
return Py_NewRef((PyObject *)value);
}
static PyObject *
pylong_asnativebytes(PyObject *module, PyObject *args)
@ -800,6 +71,7 @@ pylong_asnativebytes(PyObject *module, PyObject *args)
return res >= 0 ? PyLong_FromSsize_t(res) : NULL;
}
static PyObject *
pylong_fromnativebytes(PyObject *module, PyObject *args)
{
@ -822,33 +94,8 @@ pylong_fromnativebytes(PyObject *module, PyObject *args)
static PyMethodDef test_methods[] = {
_TESTCAPI_TEST_LONG_AND_OVERFLOW_METHODDEF
_TESTCAPI_TEST_LONG_API_METHODDEF
_TESTCAPI_TEST_LONG_AS_DOUBLE_METHODDEF
_TESTCAPI_TEST_LONG_AS_SIZE_T_METHODDEF
_TESTCAPI_TEST_LONG_AS_UNSIGNED_LONG_LONG_MASK_METHODDEF
_TESTCAPI_TEST_LONG_LONG_AND_OVERFLOW_METHODDEF
_TESTCAPI_TEST_LONGLONG_API_METHODDEF
_TESTCAPI_CALL_LONG_COMPACT_API_METHODDEF
{"pylong_check", pylong_check, METH_O},
{"pylong_checkexact", pylong_checkexact, METH_O},
{"pylong_fromdouble", pylong_fromdouble, METH_O},
{"pylong_fromstring", pylong_fromstring, METH_VARARGS},
{"pylong_fromunicodeobject", pylong_fromunicodeobject, METH_VARARGS},
{"pylong_fromvoidptr", pylong_fromvoidptr, METH_O},
_TESTCAPI_PYLONG_ASINT_METHODDEF
{"pylong_aslong", pylong_aslong, METH_O},
{"pylong_aslongandoverflow", pylong_aslongandoverflow, METH_O},
{"pylong_asunsignedlong", pylong_asunsignedlong, METH_O},
{"pylong_asunsignedlongmask", pylong_asunsignedlongmask, METH_O},
{"pylong_aslonglong", pylong_aslonglong, METH_O},
{"pylong_aslonglongandoverflow", pylong_aslonglongandoverflow, METH_O},
{"pylong_asunsignedlonglong", pylong_asunsignedlonglong, METH_O},
{"pylong_asunsignedlonglongmask", pylong_asunsignedlonglongmask, METH_O},
{"pylong_as_ssize_t", pylong_as_ssize_t, METH_O},
{"pylong_as_size_t", pylong_as_size_t, METH_O},
{"pylong_asdouble", pylong_asdouble, METH_O},
{"pylong_asvoidptr", pylong_asvoidptr, METH_O},
{"pylong_asnativebytes", pylong_asnativebytes, METH_VARARGS},
{"pylong_fromnativebytes", pylong_fromnativebytes, METH_VARARGS},
{NULL},

3
Modules/_testlimitedcapi.c
View File

@ -44,6 +44,9 @@ PyInit__testlimitedcapi(void)
if (_PyTestLimitedCAPI_Init_List(mod) < 0) {
return NULL;
}
if (_PyTestLimitedCAPI_Init_Long(mod) < 0) {
return NULL;
}
if (_PyTestLimitedCAPI_Init_PyOS(mod) < 0) {
return NULL;
}

143
Modules/_testlimitedcapi/clinic/long.c.h generated Normal file
View File

@ -0,0 +1,143 @@
/*[clinic input]
preserve
[clinic start generated code]*/
PyDoc_STRVAR(_testlimitedcapi_test_long_api__doc__,
"test_long_api($module, /)\n"
"--\n"
"\n");
#define _TESTLIMITEDCAPI_TEST_LONG_API_METHODDEF \
{"test_long_api", (PyCFunction)_testlimitedcapi_test_long_api, METH_NOARGS, _testlimitedcapi_test_long_api__doc__},
static PyObject *
_testlimitedcapi_test_long_api_impl(PyObject *module);
static PyObject *
_testlimitedcapi_test_long_api(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _testlimitedcapi_test_long_api_impl(module);
}
PyDoc_STRVAR(_testlimitedcapi_test_longlong_api__doc__,
"test_longlong_api($module, /)\n"
"--\n"
"\n");
#define _TESTLIMITEDCAPI_TEST_LONGLONG_API_METHODDEF \
{"test_longlong_api", (PyCFunction)_testlimitedcapi_test_longlong_api, METH_NOARGS, _testlimitedcapi_test_longlong_api__doc__},
static PyObject *
_testlimitedcapi_test_longlong_api_impl(PyObject *module);
static PyObject *
_testlimitedcapi_test_longlong_api(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _testlimitedcapi_test_longlong_api_impl(module);
}
PyDoc_STRVAR(_testlimitedcapi_test_long_and_overflow__doc__,
"test_long_and_overflow($module, /)\n"
"--\n"
"\n"
"Test the PyLong_AsLongAndOverflow API.\n"
"\n"
"General conversion to PY_LONG is tested by test_long_api_inner.\n"
"This test will concentrate on proper handling of overflow.");
#define _TESTLIMITEDCAPI_TEST_LONG_AND_OVERFLOW_METHODDEF \
{"test_long_and_overflow", (PyCFunction)_testlimitedcapi_test_long_and_overflow, METH_NOARGS, _testlimitedcapi_test_long_and_overflow__doc__},
static PyObject *
_testlimitedcapi_test_long_and_overflow_impl(PyObject *module);
static PyObject *
_testlimitedcapi_test_long_and_overflow(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _testlimitedcapi_test_long_and_overflow_impl(module);
}
PyDoc_STRVAR(_testlimitedcapi_test_long_long_and_overflow__doc__,
"test_long_long_and_overflow($module, /)\n"
"--\n"
"\n"
"Test the PyLong_AsLongLongAndOverflow API.\n"
"\n"
"General conversion to long long is tested by test_long_api_inner.\n"
"This test will concentrate on proper handling of overflow.");
#define _TESTLIMITEDCAPI_TEST_LONG_LONG_AND_OVERFLOW_METHODDEF \
{"test_long_long_and_overflow", (PyCFunction)_testlimitedcapi_test_long_long_and_overflow, METH_NOARGS, _testlimitedcapi_test_long_long_and_overflow__doc__},
static PyObject *
_testlimitedcapi_test_long_long_and_overflow_impl(PyObject *module);
static PyObject *
_testlimitedcapi_test_long_long_and_overflow(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _testlimitedcapi_test_long_long_and_overflow_impl(module);
}
PyDoc_STRVAR(_testlimitedcapi_test_long_as_size_t__doc__,
"test_long_as_size_t($module, /)\n"
"--\n"
"\n"
"Test the PyLong_As{Size,Ssize}_t API.\n"
"\n"
"At present this just tests that non-integer arguments are handled correctly.\n"
"It should be extended to test overflow handling.");
#define _TESTLIMITEDCAPI_TEST_LONG_AS_SIZE_T_METHODDEF \
{"test_long_as_size_t", (PyCFunction)_testlimitedcapi_test_long_as_size_t, METH_NOARGS, _testlimitedcapi_test_long_as_size_t__doc__},
static PyObject *
_testlimitedcapi_test_long_as_size_t_impl(PyObject *module);
static PyObject *
_testlimitedcapi_test_long_as_size_t(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _testlimitedcapi_test_long_as_size_t_impl(module);
}
PyDoc_STRVAR(_testlimitedcapi_test_long_as_unsigned_long_long_mask__doc__,
"test_long_as_unsigned_long_long_mask($module, /)\n"
"--\n"
"\n");
#define _TESTLIMITEDCAPI_TEST_LONG_AS_UNSIGNED_LONG_LONG_MASK_METHODDEF \
{"test_long_as_unsigned_long_long_mask", (PyCFunction)_testlimitedcapi_test_long_as_unsigned_long_long_mask, METH_NOARGS, _testlimitedcapi_test_long_as_unsigned_long_long_mask__doc__},
static PyObject *
_testlimitedcapi_test_long_as_unsigned_long_long_mask_impl(PyObject *module);
static PyObject *
_testlimitedcapi_test_long_as_unsigned_long_long_mask(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _testlimitedcapi_test_long_as_unsigned_long_long_mask_impl(module);
}
PyDoc_STRVAR(_testlimitedcapi_test_long_as_double__doc__,
"test_long_as_double($module, /)\n"
"--\n"
"\n");
#define _TESTLIMITEDCAPI_TEST_LONG_AS_DOUBLE_METHODDEF \
{"test_long_as_double", (PyCFunction)_testlimitedcapi_test_long_as_double, METH_NOARGS, _testlimitedcapi_test_long_as_double__doc__},
static PyObject *
_testlimitedcapi_test_long_as_double_impl(PyObject *module);
static PyObject *
_testlimitedcapi_test_long_as_double(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _testlimitedcapi_test_long_as_double_impl(module);
}
PyDoc_STRVAR(_testlimitedcapi_PyLong_AsInt__doc__,
"PyLong_AsInt($module, arg, /)\n"
"--\n"
"\n");
#define _TESTLIMITEDCAPI_PYLONG_ASINT_METHODDEF \
{"PyLong_AsInt", (PyCFunction)_testlimitedcapi_PyLong_AsInt, METH_O, _testlimitedcapi_PyLong_AsInt__doc__},
/*[clinic end generated code: output=bc52b73c599f96c2 input=a9049054013a1b77]*/

786
Modules/_testlimitedcapi/long.c Normal file
View File

@ -0,0 +1,786 @@
#include "pyconfig.h" // Py_GIL_DISABLED
#ifndef Py_GIL_DISABLED
// Need limited C API 3.13 to test PyLong_AsInt()
# define Py_LIMITED_API 0x030d0000
#endif
#include "parts.h"
#include "util.h"
#include "clinic/long.c.h"
/*[clinic input]
module _testlimitedcapi
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=2700057f9c1135ba]*/
static PyObject *
raiseTestError(const char* test_name, const char* msg)
{
PyErr_Format(PyExc_AssertionError, "%s: %s", test_name, msg);
return NULL;
}
/* Tests of PyLong_{As, From}{Unsigned,}Long(), and
PyLong_{As, From}{Unsigned,}LongLong().
Note that the meat of the test is contained in testcapi_long.h.
This is revolting, but delicate code duplication is worse: "almost
exactly the same" code is needed to test long long, but the ubiquitous
dependence on type names makes it impossible to use a parameterized
function. A giant macro would be even worse than this. A C++ template
would be perfect.
The "report an error" functions are deliberately not part of the #include
file: if the test fails, you can set a breakpoint in the appropriate
error function directly, and crawl back from there in the debugger.
*/
#define UNBIND(X) Py_DECREF(X); (X) = NULL
static PyObject *
raise_test_long_error(const char* msg)
{
return raiseTestError("test_long_api", msg);
}
// Test PyLong_FromLong()/PyLong_AsLong()
// and PyLong_FromUnsignedLong()/PyLong_AsUnsignedLong().
#define TESTNAME test_long_api_inner
#define TYPENAME long
#define F_S_TO_PY PyLong_FromLong
#define F_PY_TO_S PyLong_AsLong
#define F_U_TO_PY PyLong_FromUnsignedLong
#define F_PY_TO_U PyLong_AsUnsignedLong
#include "testcapi_long.h"
/*[clinic input]
_testlimitedcapi.test_long_api
[clinic start generated code]*/
static PyObject *
_testlimitedcapi_test_long_api_impl(PyObject *module)
/*[clinic end generated code: output=06a2c02366d1853a input=9012b3d6a483df63]*/
{
return TESTNAME(raise_test_long_error);
}
#undef TESTNAME
#undef TYPENAME
#undef F_S_TO_PY
#undef F_PY_TO_S
#undef F_U_TO_PY
#undef F_PY_TO_U
// Test PyLong_FromLongLong()/PyLong_AsLongLong()
// and PyLong_FromUnsignedLongLong()/PyLong_AsUnsignedLongLong().
static PyObject *
raise_test_longlong_error(const char* msg)
{
return raiseTestError("test_longlong_api", msg);
}
#define TESTNAME test_longlong_api_inner
#define TYPENAME long long
#define F_S_TO_PY PyLong_FromLongLong
#define F_PY_TO_S PyLong_AsLongLong
#define F_U_TO_PY PyLong_FromUnsignedLongLong
#define F_PY_TO_U PyLong_AsUnsignedLongLong
#include "testcapi_long.h"
/*[clinic input]
_testlimitedcapi.test_longlong_api
[clinic start generated code]*/
static PyObject *
_testlimitedcapi_test_longlong_api_impl(PyObject *module)
/*[clinic end generated code: output=8faa10e1c35214bf input=2b582a9d25bd68e7]*/
{
return TESTNAME(raise_test_longlong_error);
}
#undef TESTNAME
#undef TYPENAME
#undef F_S_TO_PY
#undef F_PY_TO_S
#undef F_U_TO_PY
#undef F_PY_TO_U
/*[clinic input]
_testlimitedcapi.test_long_and_overflow
Test the PyLong_AsLongAndOverflow API.
General conversion to PY_LONG is tested by test_long_api_inner.
This test will concentrate on proper handling of overflow.
[clinic start generated code]*/
static PyObject *
_testlimitedcapi_test_long_and_overflow_impl(PyObject *module)
/*[clinic end generated code: output=fdfd3c1eeabb6d14 input=e3a18791de6519fe]*/
{
PyObject *num, *one, *temp;
long value;
int overflow;
/* Test that overflow is set properly for a large value. */
/* num is a number larger than LONG_MAX even on 64-bit platforms */
num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
if (num == NULL)
return NULL;
overflow = 1234;
value = PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -1)
return raiseTestError("test_long_and_overflow",
"return value was not set to -1");
if (overflow != 1)
return raiseTestError("test_long_and_overflow",
"overflow was not set to 1");
/* Same again, with num = LONG_MAX + 1 */
num = PyLong_FromLong(LONG_MAX);
if (num == NULL)
return NULL;
one = PyLong_FromLong(1L);
if (one == NULL) {
Py_DECREF(num);
return NULL;
}
temp = PyNumber_Add(num, one);
Py_DECREF(one);
Py_DECREF(num);
num = temp;
if (num == NULL)
return NULL;
overflow = 0;
value = PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -1)
return raiseTestError("test_long_and_overflow",
"return value was not set to -1");
if (overflow != 1)
return raiseTestError("test_long_and_overflow",
"overflow was not set to 1");
/* Test that overflow is set properly for a large negative value. */
/* num is a number smaller than LONG_MIN even on 64-bit platforms */
num = PyLong_FromString("-FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
if (num == NULL)
return NULL;
overflow = 1234;
value = PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -1)
return raiseTestError("test_long_and_overflow",
"return value was not set to -1");
if (overflow != -1)
return raiseTestError("test_long_and_overflow",
"overflow was not set to -1");
/* Same again, with num = LONG_MIN - 1 */
num = PyLong_FromLong(LONG_MIN);
if (num == NULL)
return NULL;
one = PyLong_FromLong(1L);
if (one == NULL) {
Py_DECREF(num);
return NULL;
}
temp = PyNumber_Subtract(num, one);
Py_DECREF(one);
Py_DECREF(num); num = temp;
if (num == NULL)
return NULL;
overflow = 0;
value = PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -1)
return raiseTestError("test_long_and_overflow",
"return value was not set to -1");
if (overflow != -1)
return raiseTestError("test_long_and_overflow",
"overflow was not set to -1");
/* Test that overflow is cleared properly for small values. */
num = PyLong_FromString("FF", NULL, 16);
if (num == NULL)
return NULL;
overflow = 1234;
value = PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != 0xFF)
return raiseTestError("test_long_and_overflow",
"expected return value 0xFF");
if (overflow != 0)
return raiseTestError("test_long_and_overflow",
"overflow was not cleared");
num = PyLong_FromString("-FF", NULL, 16);
if (num == NULL)
return NULL;
overflow = 0;
value = PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -0xFF)
return raiseTestError("test_long_and_overflow",
"expected return value 0xFF");
if (overflow != 0)
return raiseTestError("test_long_and_overflow",
"overflow was set incorrectly");
num = PyLong_FromLong(LONG_MAX);
if (num == NULL)
return NULL;
overflow = 1234;
value = PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != LONG_MAX)
return raiseTestError("test_long_and_overflow",
"expected return value LONG_MAX");
if (overflow != 0)
return raiseTestError("test_long_and_overflow",
"overflow was not cleared");
num = PyLong_FromLong(LONG_MIN);
if (num == NULL)
return NULL;
overflow = 0;
value = PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != LONG_MIN)
return raiseTestError("test_long_and_overflow",
"expected return value LONG_MIN");
if (overflow != 0)
return raiseTestError("test_long_and_overflow",
"overflow was not cleared");
Py_RETURN_NONE;
}
/*[clinic input]
_testlimitedcapi.test_long_long_and_overflow
Test the PyLong_AsLongLongAndOverflow API.
General conversion to long long is tested by test_long_api_inner.
This test will concentrate on proper handling of overflow.
[clinic start generated code]*/
static PyObject *
_testlimitedcapi_test_long_long_and_overflow_impl(PyObject *module)
/*[clinic end generated code: output=3d2721a49c09a307 input=741c593b606cc6b3]*/
{
PyObject *num, *one, *temp;
long long value;
int overflow;
/* Test that overflow is set properly for a large value. */
/* num is a number larger than LLONG_MAX on a typical machine. */
num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
if (num == NULL)
return NULL;
overflow = 1234;
value = PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -1)
return raiseTestError("test_long_long_and_overflow",
"return value was not set to -1");
if (overflow != 1)
return raiseTestError("test_long_long_and_overflow",
"overflow was not set to 1");
/* Same again, with num = LLONG_MAX + 1 */
num = PyLong_FromLongLong(LLONG_MAX);
if (num == NULL)
return NULL;
one = PyLong_FromLong(1L);
if (one == NULL) {
Py_DECREF(num);
return NULL;
}
temp = PyNumber_Add(num, one);
Py_DECREF(one);
Py_DECREF(num); num = temp;
if (num == NULL)
return NULL;
overflow = 0;
value = PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -1)
return raiseTestError("test_long_long_and_overflow",
"return value was not set to -1");
if (overflow != 1)
return raiseTestError("test_long_long_and_overflow",
"overflow was not set to 1");
/* Test that overflow is set properly for a large negative value. */
/* num is a number smaller than LLONG_MIN on a typical platform */
num = PyLong_FromString("-FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
if (num == NULL)
return NULL;
overflow = 1234;
value = PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -1)
return raiseTestError("test_long_long_and_overflow",
"return value was not set to -1");
if (overflow != -1)
return raiseTestError("test_long_long_and_overflow",
"overflow was not set to -1");
/* Same again, with num = LLONG_MIN - 1 */
num = PyLong_FromLongLong(LLONG_MIN);
if (num == NULL)
return NULL;
one = PyLong_FromLong(1L);
if (one == NULL) {
Py_DECREF(num);
return NULL;
}
temp = PyNumber_Subtract(num, one);
Py_DECREF(one);
Py_DECREF(num); num = temp;
if (num == NULL)
return NULL;
overflow = 0;
value = PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -1)
return raiseTestError("test_long_long_and_overflow",
"return value was not set to -1");
if (overflow != -1)
return raiseTestError("test_long_long_and_overflow",
"overflow was not set to -1");
/* Test that overflow is cleared properly for small values. */
num = PyLong_FromString("FF", NULL, 16);
if (num == NULL)
return NULL;
overflow = 1234;
value = PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != 0xFF)
return raiseTestError("test_long_long_and_overflow",
"expected return value 0xFF");
if (overflow != 0)
return raiseTestError("test_long_long_and_overflow",
"overflow was not cleared");
num = PyLong_FromString("-FF", NULL, 16);
if (num == NULL)
return NULL;
overflow = 0;
value = PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != -0xFF)
return raiseTestError("test_long_long_and_overflow",
"expected return value 0xFF");
if (overflow != 0)
return raiseTestError("test_long_long_and_overflow",
"overflow was set incorrectly");
num = PyLong_FromLongLong(LLONG_MAX);
if (num == NULL)
return NULL;
overflow = 1234;
value = PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != LLONG_MAX)
return raiseTestError("test_long_long_and_overflow",
"expected return value LLONG_MAX");
if (overflow != 0)
return raiseTestError("test_long_long_and_overflow",
"overflow was not cleared");
num = PyLong_FromLongLong(LLONG_MIN);
if (num == NULL)
return NULL;
overflow = 0;
value = PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value == -1 && PyErr_Occurred())
return NULL;
if (value != LLONG_MIN)
return raiseTestError("test_long_long_and_overflow",
"expected return value LLONG_MIN");
if (overflow != 0)
return raiseTestError("test_long_long_and_overflow",
"overflow was not cleared");
Py_RETURN_NONE;
}
/*[clinic input]
_testlimitedcapi.test_long_as_size_t
Test the PyLong_As{Size,Ssize}_t API.
At present this just tests that non-integer arguments are handled correctly.
It should be extended to test overflow handling.
[clinic start generated code]*/
static PyObject *
_testlimitedcapi_test_long_as_size_t_impl(PyObject *module)
/*[clinic end generated code: output=297a9f14a42f55af input=8923d8f2038c46f4]*/
{
size_t out_u;
Py_ssize_t out_s;
Py_INCREF(Py_None);
out_u = PyLong_AsSize_t(Py_None);
if (out_u != (size_t)-1 || !PyErr_Occurred())
return raiseTestError("test_long_as_size_t",
"PyLong_AsSize_t(None) didn't complain");
if (!PyErr_ExceptionMatches(PyExc_TypeError))
return raiseTestError("test_long_as_size_t",
"PyLong_AsSize_t(None) raised "
"something other than TypeError");
PyErr_Clear();
out_s = PyLong_AsSsize_t(Py_None);
if (out_s != (Py_ssize_t)-1 || !PyErr_Occurred())
return raiseTestError("test_long_as_size_t",
"PyLong_AsSsize_t(None) didn't complain");
if (!PyErr_ExceptionMatches(PyExc_TypeError))
return raiseTestError("test_long_as_size_t",
"PyLong_AsSsize_t(None) raised "
"something other than TypeError");
PyErr_Clear();
/* Py_INCREF(Py_None) omitted - we already have a reference to it. */
return Py_None;
}
/*[clinic input]
_testlimitedcapi.test_long_as_unsigned_long_long_mask
[clinic start generated code]*/
static PyObject *
_testlimitedcapi_test_long_as_unsigned_long_long_mask_impl(PyObject *module)
/*[clinic end generated code: output=90be09ffeec8ecab input=17c660bd58becad5]*/
{
unsigned long long res = PyLong_AsUnsignedLongLongMask(NULL);
if (res != (unsigned long long)-1 || !PyErr_Occurred()) {
return raiseTestError("test_long_as_unsigned_long_long_mask",
"PyLong_AsUnsignedLongLongMask(NULL) didn't "
"complain");
}
if (!PyErr_ExceptionMatches(PyExc_SystemError)) {
return raiseTestError("test_long_as_unsigned_long_long_mask",
"PyLong_AsUnsignedLongLongMask(NULL) raised "
"something other than SystemError");
}
PyErr_Clear();
Py_RETURN_NONE;
}
/*[clinic input]
_testlimitedcapi.test_long_as_double
[clinic start generated code]*/
static PyObject *
_testlimitedcapi_test_long_as_double_impl(PyObject *module)
/*[clinic end generated code: output=0e688c2acf224f88 input=e7b5712385064a48]*/
{
double out;
Py_INCREF(Py_None);
out = PyLong_AsDouble(Py_None);
if (out != -1.0 || !PyErr_Occurred())
return raiseTestError("test_long_as_double",
"PyLong_AsDouble(None) didn't complain");
if (!PyErr_ExceptionMatches(PyExc_TypeError))
return raiseTestError("test_long_as_double",
"PyLong_AsDouble(None) raised "
"something other than TypeError");
PyErr_Clear();
/* Py_INCREF(Py_None) omitted - we already have a reference to it. */
return Py_None;
}
static PyObject *
pylong_check(PyObject *module, PyObject *obj)
{
NULLABLE(obj);
return PyLong_FromLong(PyLong_Check(obj));
}
static PyObject *
pylong_checkexact(PyObject *module, PyObject *obj)
{
NULLABLE(obj);
return PyLong_FromLong(PyLong_CheckExact(obj));
}
static PyObject *
pylong_fromdouble(PyObject *module, PyObject *arg)
{
double value;
if (!PyArg_Parse(arg, "d", &value)) {
return NULL;
}
return PyLong_FromDouble(value);
}
static PyObject *
pylong_fromstring(PyObject *module, PyObject *args)
{
const char *str;
Py_ssize_t len;
int base;
char *end = UNINITIALIZED_PTR;
if (!PyArg_ParseTuple(args, "z#i", &str, &len, &base)) {
return NULL;
}
PyObject *result = PyLong_FromString(str, &end, base);
if (result == NULL) {
// XXX 'end' is not always set.
return NULL;
}
return Py_BuildValue("Nn", result, (Py_ssize_t)(end - str));
}
static PyObject *
pylong_fromvoidptr(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
return PyLong_FromVoidPtr((void *)arg);
}
/*[clinic input]
_testlimitedcapi.PyLong_AsInt
arg: object
/
[clinic start generated code]*/
static PyObject *
_testlimitedcapi_PyLong_AsInt(PyObject *module, PyObject *arg)
/*[clinic end generated code: output=d91db4c1287f85fa input=32c66be86f3265a1]*/
{
NULLABLE(arg);
assert(!PyErr_Occurred());
int value = PyLong_AsInt(arg);
if (value == -1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromLong(value);
}
static PyObject *
pylong_aslong(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
long value = PyLong_AsLong(arg);
if (value == -1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromLong(value);
}
static PyObject *
pylong_aslongandoverflow(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
int overflow = UNINITIALIZED_INT;
long value = PyLong_AsLongAndOverflow(arg, &overflow);
if (value == -1 && PyErr_Occurred()) {
assert(overflow == -1);
return NULL;
}
return Py_BuildValue("li", value, overflow);
}
static PyObject *
pylong_asunsignedlong(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
unsigned long value = PyLong_AsUnsignedLong(arg);
if (value == (unsigned long)-1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromUnsignedLong(value);
}
static PyObject *
pylong_asunsignedlongmask(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
unsigned long value = PyLong_AsUnsignedLongMask(arg);
if (value == (unsigned long)-1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromUnsignedLong(value);
}
static PyObject *
pylong_aslonglong(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
long long value = PyLong_AsLongLong(arg);
if (value == -1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromLongLong(value);
}
static PyObject *
pylong_aslonglongandoverflow(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
int overflow = UNINITIALIZED_INT;
long long value = PyLong_AsLongLongAndOverflow(arg, &overflow);
if (value == -1 && PyErr_Occurred()) {
assert(overflow == -1);
return NULL;
}
return Py_BuildValue("Li", value, overflow);
}
static PyObject *
pylong_asunsignedlonglong(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
unsigned long long value = PyLong_AsUnsignedLongLong(arg);
if (value == (unsigned long long)-1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromUnsignedLongLong(value);
}
static PyObject *
pylong_asunsignedlonglongmask(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
unsigned long long value = PyLong_AsUnsignedLongLongMask(arg);
if (value == (unsigned long long)-1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromUnsignedLongLong(value);
}
static PyObject *
pylong_as_ssize_t(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
Py_ssize_t value = PyLong_AsSsize_t(arg);
if (value == -1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromSsize_t(value);
}
static PyObject *
pylong_as_size_t(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
size_t value = PyLong_AsSize_t(arg);
if (value == (size_t)-1 && PyErr_Occurred()) {
return NULL;
}
return PyLong_FromSize_t(value);
}
static PyObject *
pylong_asdouble(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
double value = PyLong_AsDouble(arg);
if (value == -1.0 && PyErr_Occurred()) {
return NULL;
}
return PyFloat_FromDouble(value);
}
static PyObject *
pylong_asvoidptr(PyObject *module, PyObject *arg)
{
NULLABLE(arg);
void *value = PyLong_AsVoidPtr(arg);
if (value == NULL) {
if (PyErr_Occurred()) {
return NULL;
}
Py_RETURN_NONE;
}
return Py_NewRef((PyObject *)value);
}
static PyMethodDef test_methods[] = {
_TESTLIMITEDCAPI_TEST_LONG_AND_OVERFLOW_METHODDEF
_TESTLIMITEDCAPI_TEST_LONG_API_METHODDEF
_TESTLIMITEDCAPI_TEST_LONG_AS_DOUBLE_METHODDEF
_TESTLIMITEDCAPI_TEST_LONG_AS_SIZE_T_METHODDEF
_TESTLIMITEDCAPI_TEST_LONG_AS_UNSIGNED_LONG_LONG_MASK_METHODDEF
_TESTLIMITEDCAPI_TEST_LONG_LONG_AND_OVERFLOW_METHODDEF
_TESTLIMITEDCAPI_TEST_LONGLONG_API_METHODDEF
{"pylong_check", pylong_check, METH_O},
{"pylong_checkexact", pylong_checkexact, METH_O},
{"pylong_fromdouble", pylong_fromdouble, METH_O},
{"pylong_fromstring", pylong_fromstring, METH_VARARGS},
{"pylong_fromvoidptr", pylong_fromvoidptr, METH_O},
_TESTLIMITEDCAPI_PYLONG_ASINT_METHODDEF
{"pylong_aslong", pylong_aslong, METH_O},
{"pylong_aslongandoverflow", pylong_aslongandoverflow, METH_O},
{"pylong_asunsignedlong", pylong_asunsignedlong, METH_O},
{"pylong_asunsignedlongmask", pylong_asunsignedlongmask, METH_O},
{"pylong_aslonglong", pylong_aslonglong, METH_O},
{"pylong_aslonglongandoverflow", pylong_aslonglongandoverflow, METH_O},
{"pylong_asunsignedlonglong", pylong_asunsignedlonglong, METH_O},
{"pylong_asunsignedlonglongmask", pylong_asunsignedlonglongmask, METH_O},
{"pylong_as_ssize_t", pylong_as_ssize_t, METH_O},
{"pylong_as_size_t", pylong_as_size_t, METH_O},
{"pylong_asdouble", pylong_asdouble, METH_O},
{"pylong_asvoidptr", pylong_asvoidptr, METH_O},
{NULL},
};
int
_PyTestLimitedCAPI_Init_Long(PyObject *mod)
{
if (PyModule_AddFunctions(mod, test_methods) < 0) {
return -1;
}
return 0;
}

1
Modules/_testlimitedcapi/parts.h
View File

@ -28,6 +28,7 @@ int _PyTestLimitedCAPI_Init_Bytes(PyObject *module);
int _PyTestLimitedCAPI_Init_Float(PyObject *module);
int _PyTestLimitedCAPI_Init_HeaptypeRelative(PyObject *module);
int _PyTestLimitedCAPI_Init_List(PyObject *module);
int _PyTestLimitedCAPI_Init_Long(PyObject *module);
int _PyTestLimitedCAPI_Init_PyOS(PyObject *module);
int _PyTestLimitedCAPI_Init_Set(PyObject *module);
int _PyTestLimitedCAPI_Init_Sys(PyObject *module);

0
Modules/_testcapi/testcapi_long.h → Modules/_testlimitedcapi/testcapi_long.h
View File

1
PCbuild/_testlimitedcapi.vcxproj
View File

@ -100,6 +100,7 @@
<ClCompile Include="..\Modules\_testlimitedcapi\float.c" />
<ClCompile Include="..\Modules\_testlimitedcapi\heaptype_relative.c" />
<ClCompile Include="..\Modules\_testlimitedcapi\list.c" />
<ClCompile Include="..\Modules\_testlimitedcapi\long.c" />
<ClCompile Include="..\Modules\_testlimitedcapi\pyos.c" />
<ClCompile Include="..\Modules\_testlimitedcapi\set.c" />
<ClCompile Include="..\Modules\_testlimitedcapi\sys.c" />

2
PCbuild/_testlimitedcapi.vcxproj.filters
View File

@ -15,9 +15,11 @@
<ClCompile Include="..\Modules\_testlimitedcapi\float.c" />
<ClCompile Include="..\Modules\_testlimitedcapi\heaptype_relative.c" />
<ClCompile Include="..\Modules\_testlimitedcapi\list.c" />
<ClCompile Include="..\Modules\_testlimitedcapi\long.c" />
<ClCompile Include="..\Modules\_testlimitedcapi\pyos.c" />
<ClCompile Include="..\Modules\_testlimitedcapi\set.c" />
<ClCompile Include="..\Modules\_testlimitedcapi\sys.c" />
<ClCompile Include="..\Modules\_testlimitedcapi\testcapi_long.h" />
<ClCompile Include="..\Modules\_testlimitedcapi\unicode.c" />
<ClCompile Include="..\Modules\_testlimitedcapi\vectorcall_limited.c" />
<ClCompile Include="..\Modules\_testlimitedcapi.c" />