languages/cpython
languages/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython synced 2024-07-20 09:45:46 +00:00
Code Issues Actions 8 Packages Projects Releases Wiki Activity

gh-93649: Split float/long tests from _testcapimodule.c (GH-99549)

Browse source 
Automerge-Triggered-By: GH:erlend-aasland
This commit is contained in:
Erlend E. Aasland 2022-11-17 09:56:56 +01:00 committed by GitHub
parent 5fdd49dc65
commit 12b5a3c5f5
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
9 changed files with 677 additions and 625 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Makefile.pre.in
View file

@ -2595,7 +2595,7 @@ MODULE__SHA3_DEPS=$(srcdir)/Modules/_sha3/sha3.c $(srcdir)/Modules/_sha3/sha3.h
MODULE__SHA512_DEPS=$(srcdir)/Modules/hashlib.h
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.h $(srcdir)/Modules/_ssl_data_111.h $(srcdir)/Modules/_ssl_data_300.h $(srcdir)/Modules/socketmodule.h
MODULE__TESTCAPI_DEPS=$(srcdir)/Modules/testcapi_long.h $(srcdir)/Modules/_testcapi/parts.h
MODULE__TESTCAPI_DEPS=$(srcdir)/Modules/_testcapi/testcapi_long.h $(srcdir)/Modules/_testcapi/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
# IF YOU PUT ANYTHING HERE IT WILL GO AWAY

2
Modules/Setup.stdlib.in
View file

@ -169,7 +169,7 @@
@MODULE__XXTESTFUZZ_TRUE@_xxtestfuzz _xxtestfuzz/_xxtestfuzz.c _xxtestfuzz/fuzzer.c
@MODULE__TESTBUFFER_TRUE@_testbuffer _testbuffer.c
@MODULE__TESTINTERNALCAPI_TRUE@_testinternalcapi _testinternalcapi.c
@MODULE__TESTCAPI_TRUE@_testcapi _testcapimodule.c _testcapi/vectorcall.c _testcapi/vectorcall_limited.c _testcapi/heaptype.c _testcapi/unicode.c _testcapi/getargs.c _testcapi/pytime.c _testcapi/datetime.c _testcapi/docstring.c _testcapi/mem.c _testcapi/watchers.c
@MODULE__TESTCAPI_TRUE@_testcapi _testcapimodule.c _testcapi/vectorcall.c _testcapi/vectorcall_limited.c _testcapi/heaptype.c _testcapi/unicode.c _testcapi/getargs.c _testcapi/pytime.c _testcapi/datetime.c _testcapi/docstring.c _testcapi/mem.c _testcapi/watchers.c _testcapi/long.c _testcapi/float.c
# Some testing modules MUST be built as shared libraries.
*shared*

98
Modules/_testcapi/float.c Normal file
View file

@ -0,0 +1,98 @@
#define PY_SSIZE_T_CLEAN
#include "parts.h"
// Test PyFloat_Pack2(), PyFloat_Pack4() and PyFloat_Pack8()
static PyObject *
test_float_pack(PyObject *self, PyObject *args)
{
int size;
double d;
int le;
if (!PyArg_ParseTuple(args, "idi", &size, &d, &le)) {
return NULL;
}
switch (size)
{
case 2:
{
char data[2];
if (PyFloat_Pack2(d, data, le) < 0) {
return NULL;
}
return PyBytes_FromStringAndSize(data, Py_ARRAY_LENGTH(data));
}
case 4:
{
char data[4];
if (PyFloat_Pack4(d, data, le) < 0) {
return NULL;
}
return PyBytes_FromStringAndSize(data, Py_ARRAY_LENGTH(data));
}
case 8:
{
char data[8];
if (PyFloat_Pack8(d, data, le) < 0) {
return NULL;
}
return PyBytes_FromStringAndSize(data, Py_ARRAY_LENGTH(data));
}
default: break;
}
PyErr_SetString(PyExc_ValueError, "size must 2, 4 or 8");
return NULL;
}
// Test PyFloat_Unpack2(), PyFloat_Unpack4() and PyFloat_Unpack8()
static PyObject *
test_float_unpack(PyObject *self, PyObject *args)
{
assert(!PyErr_Occurred());
const char *data;
Py_ssize_t size;
int le;
if (!PyArg_ParseTuple(args, "y#i", &data, &size, &le)) {
return NULL;
}
double d;
switch (size)
{
case 2:
d = PyFloat_Unpack2(data, le);
break;
case 4:
d = PyFloat_Unpack4(data, le);
break;
case 8:
d = PyFloat_Unpack8(data, le);
break;
default:
PyErr_SetString(PyExc_ValueError, "data length must 2, 4 or 8 bytes");
return NULL;
}
if (d == -1.0 && PyErr_Occurred()) {
return NULL;
}
return PyFloat_FromDouble(d);
}
static PyMethodDef test_methods[] = {
{"float_pack", test_float_pack, METH_VARARGS, NULL},
{"float_unpack", test_float_unpack, METH_VARARGS, NULL},
{NULL},
};
int
_PyTestCapi_Init_Float(PyObject *mod)
{
if (PyModule_AddFunctions(mod, test_methods) < 0) {
return -1;
}
return 0;
}

561
Modules/_testcapi/long.c Normal file
View file

@ -0,0 +1,561 @@
#include "parts.h"
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);
}
#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"
static PyObject *
test_long_api(PyObject* self, PyObject *Py_UNUSED(ignored))
{
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
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"
static PyObject *
test_longlong_api(PyObject* self, PyObject *args)
{
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
/* 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.
*/
static PyObject *
test_long_and_overflow(PyObject *self, PyObject *Py_UNUSED(ignored))
{
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;
}
/* 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.
*/
static PyObject *
test_long_long_and_overflow(PyObject *self, PyObject *Py_UNUSED(ignored))
{
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;
}
/* 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.
*/
static PyObject *
test_long_as_size_t(PyObject *self, PyObject *Py_UNUSED(ignored))
{
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;
}
static PyObject *
test_long_as_unsigned_long_long_mask(PyObject *self,
PyObject *Py_UNUSED(ignored))
{
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;
}
/* Test the PyLong_AsDouble API. At present this just tests that
non-integer arguments are handled correctly.
*/
static PyObject *
test_long_as_double(PyObject *self, PyObject *Py_UNUSED(ignored))
{
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;
}
/* Simple test of _PyLong_NumBits and _PyLong_Sign. */
static PyObject *
test_long_numbits(PyObject *self, PyObject *Py_UNUSED(ignored))
{
struct triple {
long input;
size_t nbits;
int sign;
} testcases[] = {{0, 0, 0},
{1L, 1, 1},
{-1L, 1, -1},
{2L, 2, 1},
{-2L, 2, -1},
{3L, 2, 1},
{-3L, 2, -1},
{4L, 3, 1},
{-4L, 3, -1},
{0x7fffL, 15, 1}, /* one Python int digit */
{-0x7fffL, 15, -1},
{0xffffL, 16, 1},
{-0xffffL, 16, -1},
{0xfffffffL, 28, 1},
{-0xfffffffL, 28, -1}};
size_t i;
for (i = 0; i < Py_ARRAY_LENGTH(testcases); ++i) {
size_t nbits;
int sign;
PyObject *plong;
plong = PyLong_FromLong(testcases[i].input);
if (plong == NULL)
return NULL;
nbits = _PyLong_NumBits(plong);
sign = _PyLong_Sign(plong);
Py_DECREF(plong);
if (nbits != testcases[i].nbits)
return raiseTestError("test_long_numbits",
"wrong result for _PyLong_NumBits");
if (sign != testcases[i].sign)
return raiseTestError("test_long_numbits",
"wrong result for _PyLong_Sign");
}
Py_RETURN_NONE;
}
static PyMethodDef test_methods[] = {
{"test_long_and_overflow", test_long_and_overflow, METH_NOARGS},
{"test_long_api", test_long_api, METH_NOARGS},
{"test_long_as_double", test_long_as_double, METH_NOARGS},
{"test_long_as_size_t", test_long_as_size_t, METH_NOARGS},
{"test_long_as_unsigned_long_long_mask", test_long_as_unsigned_long_long_mask, METH_NOARGS},
{"test_long_long_and_overflow",test_long_long_and_overflow, METH_NOARGS},
{"test_long_numbits", test_long_numbits, METH_NOARGS},
{"test_longlong_api", test_longlong_api, METH_NOARGS},
{NULL},
};
int
_PyTestCapi_Init_Long(PyObject *mod)
{
if (PyModule_AddFunctions(mod, test_methods) < 0) {
return -1;
}
return 0;
}

2
Modules/_testcapi/parts.h
View file

@ -33,6 +33,8 @@ int _PyTestCapi_Init_DateTime(PyObject *module);
int _PyTestCapi_Init_Docstring(PyObject *module);
int _PyTestCapi_Init_Mem(PyObject *module);
int _PyTestCapi_Init_Watchers(PyObject *module);
int _PyTestCapi_Init_Long(PyObject *module);
int _PyTestCapi_Init_Float(PyObject *module);
#ifdef LIMITED_API_AVAILABLE
int _PyTestCapi_Init_VectorcallLimited(PyObject *module);

0
Modules/testcapi_long.h → Modules/_testcapi/testcapi_long.h
View file

629
Modules/_testcapimodule.c
View file

@ -460,491 +460,6 @@ test_lazy_hash_inheritance(PyObject* self, PyObject *Py_UNUSED(ignored))
Py_RETURN_NONE;
}
/* 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);
}
#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"
static PyObject *
test_long_api(PyObject* self, PyObject *Py_UNUSED(ignored))
{
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
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"
static PyObject *
test_longlong_api(PyObject* self, PyObject *args)
{
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
/* 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.
*/
static PyObject *
test_long_and_overflow(PyObject *self, PyObject *Py_UNUSED(ignored))
{
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;
}
/* 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.
*/
static PyObject *
test_long_long_and_overflow(PyObject *self, PyObject *Py_UNUSED(ignored))
{
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;
}
/* 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.
*/
static PyObject *
test_long_as_size_t(PyObject *self, PyObject *Py_UNUSED(ignored))
{
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;
}
static PyObject *
test_long_as_unsigned_long_long_mask(PyObject *self,
PyObject *Py_UNUSED(ignored))
{
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;
}
/* Test the PyLong_AsDouble API. At present this just tests that
non-integer arguments are handled correctly.
*/
static PyObject *
test_long_as_double(PyObject *self, PyObject *Py_UNUSED(ignored))
{
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 *
return_none(void *unused)
{
@ -1183,53 +698,6 @@ test_get_type_qualname(PyObject *self, PyObject *Py_UNUSED(ignored))
Py_RETURN_NONE;
}
/* Simple test of _PyLong_NumBits and _PyLong_Sign. */
static PyObject *
test_long_numbits(PyObject *self, PyObject *Py_UNUSED(ignored))
{
struct triple {
long input;
size_t nbits;
int sign;
} testcases[] = {{0, 0, 0},
{1L, 1, 1},
{-1L, 1, -1},
{2L, 2, 1},
{-2L, 2, -1},
{3L, 2, 1},
{-3L, 2, -1},
{4L, 3, 1},
{-4L, 3, -1},
{0x7fffL, 15, 1}, /* one Python int digit */
{-0x7fffL, 15, -1},
{0xffffL, 16, 1},
{-0xffffL, 16, -1},
{0xfffffffL, 28, 1},
{-0xfffffffL, 28, -1}};
size_t i;
for (i = 0; i < Py_ARRAY_LENGTH(testcases); ++i) {
size_t nbits;
int sign;
PyObject *plong;
plong = PyLong_FromLong(testcases[i].input);
if (plong == NULL)
return NULL;
nbits = _PyLong_NumBits(plong);
sign = _PyLong_Sign(plong);
Py_DECREF(plong);
if (nbits != testcases[i].nbits)
return raiseTestError("test_long_numbits",
"wrong result for _PyLong_NumBits");
if (sign != testcases[i].sign)
return raiseTestError("test_long_numbits",
"wrong result for _PyLong_Sign");
}
Py_RETURN_NONE;
}
static PyObject *
pyobject_repr_from_null(PyObject *self, PyObject *Py_UNUSED(ignored))
{
@ -3087,7 +2555,6 @@ meth_fastcall_keywords(PyObject* self, PyObject* const* args,
return Py_BuildValue("NNN", _null_to_none(self), pyargs, pykwargs);
}
static PyObject*
pynumber_tobase(PyObject *module, PyObject *args)
{
@ -3100,7 +2567,6 @@ pynumber_tobase(PyObject *module, PyObject *args)
return PyNumber_ToBase(obj, base);
}
static PyObject*
test_set_type_size(PyObject *self, PyObject *Py_UNUSED(ignored))
{
@ -3390,84 +2856,6 @@ test_tstate_capi(PyObject *self, PyObject *Py_UNUSED(args))
Py_RETURN_NONE;
}
// Test PyFloat_Pack2(), PyFloat_Pack4() and PyFloat_Pack8()
static PyObject *
test_float_pack(PyObject *self, PyObject *args)
{
int size;
double d;
int le;
if (!PyArg_ParseTuple(args, "idi", &size, &d, &le)) {
return NULL;
}
switch (size)
{
case 2:
{
char data[2];
if (PyFloat_Pack2(d, data, le) < 0) {
return NULL;
}
return PyBytes_FromStringAndSize(data, Py_ARRAY_LENGTH(data));
}
case 4:
{
char data[4];
if (PyFloat_Pack4(d, data, le) < 0) {
return NULL;
}
return PyBytes_FromStringAndSize(data, Py_ARRAY_LENGTH(data));
}
case 8:
{
char data[8];
if (PyFloat_Pack8(d, data, le) < 0) {
return NULL;
}
return PyBytes_FromStringAndSize(data, Py_ARRAY_LENGTH(data));
}
default: break;
}
PyErr_SetString(PyExc_ValueError, "size must 2, 4 or 8");
return NULL;
}
// Test PyFloat_Unpack2(), PyFloat_Unpack4() and PyFloat_Unpack8()
static PyObject *
test_float_unpack(PyObject *self, PyObject *args)
{
assert(!PyErr_Occurred());
const char *data;
Py_ssize_t size;
int le;
if (!PyArg_ParseTuple(args, "y#i", &data, &size, &le)) {
return NULL;
}
double d;
switch (size)
{
case 2:
d = PyFloat_Unpack2(data, le);
break;
case 4:
d = PyFloat_Unpack4(data, le);
break;
case 8:
d = PyFloat_Unpack8(data, le);
break;
default:
PyErr_SetString(PyExc_ValueError, "data length must 2, 4 or 8 bytes");
return NULL;
}
if (d == -1.0 && PyErr_Occurred()) {
return NULL;
}
return PyFloat_FromDouble(d);
}
static PyObject *
frame_getlocals(PyObject *self, PyObject *frame)
{
@ -3848,7 +3236,6 @@ static PyMethodDef TestMethods[] = {
{"test_dict_iteration", test_dict_iteration, METH_NOARGS},
{"dict_getitem_knownhash", dict_getitem_knownhash, METH_VARARGS},
{"test_lazy_hash_inheritance", test_lazy_hash_inheritance,METH_NOARGS},
{"test_long_api", test_long_api, METH_NOARGS},
{"test_xincref_doesnt_leak",test_xincref_doesnt_leak, METH_NOARGS},
{"test_incref_doesnt_leak", test_incref_doesnt_leak, METH_NOARGS},
{"test_xdecref_doesnt_leak",test_xdecref_doesnt_leak, METH_NOARGS},
@ -3858,12 +3245,6 @@ static PyMethodDef TestMethods[] = {
{"test_structseq_newtype_null_descr_doc",
test_structseq_newtype_null_descr_doc, METH_NOARGS},
{"test_incref_decref_API", test_incref_decref_API, METH_NOARGS},
{"test_long_and_overflow", test_long_and_overflow, METH_NOARGS},
{"test_long_as_double", test_long_as_double, METH_NOARGS},
{"test_long_as_size_t", test_long_as_size_t, METH_NOARGS},
{"test_long_as_unsigned_long_long_mask",
test_long_as_unsigned_long_long_mask, METH_NOARGS},
{"test_long_numbits", test_long_numbits, METH_NOARGS},
{"pyobject_repr_from_null", pyobject_repr_from_null, METH_NOARGS},
{"pyobject_str_from_null", pyobject_str_from_null, METH_NOARGS},
{"pyobject_bytes_from_null", pyobject_bytes_from_null, METH_NOARGS},
@ -3880,8 +3261,6 @@ static PyMethodDef TestMethods[] = {
{"test_get_statictype_slots", test_get_statictype_slots, METH_NOARGS},
{"test_get_type_name", test_get_type_name, METH_NOARGS},
{"test_get_type_qualname", test_get_type_qualname, METH_NOARGS},
{"test_longlong_api", test_longlong_api, METH_NOARGS},
{"test_long_long_and_overflow",test_long_long_and_overflow, METH_NOARGS},
{"_test_thread_state", test_thread_state, METH_VARARGS},
{"_pending_threadfunc", pending_threadfunc, METH_VARARGS},
#ifdef HAVE_GETTIMEOFDAY
@ -3968,8 +3347,6 @@ static PyMethodDef TestMethods[] = {
PyDoc_STR("fatal_error(message, release_gil=False): call Py_FatalError(message)")},
{"type_get_version", type_get_version, METH_O, PyDoc_STR("type->tp_version_tag")},
{"test_tstate_capi", test_tstate_capi, METH_NOARGS, NULL},
{"float_pack", test_float_pack, METH_VARARGS, NULL},
{"float_unpack", test_float_unpack, METH_VARARGS, NULL},
{"frame_getlocals", frame_getlocals, METH_O, NULL},
{"frame_getglobals", frame_getglobals, METH_O, NULL},
{"frame_getgenerator", frame_getgenerator, METH_O, NULL},
@ -4814,6 +4191,12 @@ PyInit__testcapi(void)
if (_PyTestCapi_Init_Watchers(m) < 0) {
return NULL;
}
if (_PyTestCapi_Init_Long(m) < 0) {
return NULL;
}
if (_PyTestCapi_Init_Float(m) < 0) {
return NULL;
}
#ifndef LIMITED_API_AVAILABLE
PyModule_AddObjectRef(m, "LIMITED_API_AVAILABLE", Py_False);

2
PCbuild/_testcapi.vcxproj
View file

@ -104,6 +104,8 @@
<ClCompile Include="..\Modules\_testcapi\docstring.c" />
<ClCompile Include="..\Modules\_testcapi\mem.c" />
<ClCompile Include="..\Modules\_testcapi\watchers.c" />
<ClCompile Include="..\Modules\_testcapi\float.c" />
<ClCompile Include="..\Modules\_testcapi\long.c" />
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="..\PC\python_nt.rc" />

6
PCbuild/_testcapi.vcxproj.filters
View file

@ -42,6 +42,12 @@
<ClCompile Include="..\Modules\_testcapi\watchers.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\Modules\_testcapi\float.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\Modules\_testcapi\long.c">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="..\PC\python_nt.rc">