/*

* C Extension module to test Python interpreter C APIs.

*

* The 'test_*' functions exported by this module are run as part of the

* standard Python regression test, via Lib/test/test_capi.py.

*/

/* This module tests the public (Include/ and Include/cpython/) C API.

The internal C API must not be used here: use _testinternalcapi for that.

The Visual Studio projects builds _testcapi with Py_BUILD_CORE_MODULE

macro defined, but only the public C API must be tested here. */

#undef Py_BUILD_CORE_MODULE

#undef Py_BUILD_CORE_BUILTIN

#define NEEDS_PY_IDENTIFIER

/* Always enable assertions */

#undef NDEBUG

#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "datetime.h" // PyDateTimeAPI

#include "marshal.h" // PyMarshal_WriteLongToFile

#include "structmember.h" // PyMemberDef

#include <float.h> // FLT_MAX

#include <signal.h>

#ifdef MS_WINDOWS

# include <winsock2.h> // struct timeval

#endif

#ifdef HAVE_SYS_WAIT_H

#include <sys/wait.h> // W_STOPCODE

#endif

#ifdef Py_BUILD_CORE

# error "_testcapi must test the public Python C API, not CPython internal C API"

#endif

#ifdef bool

# error "The public headers should not include <stdbool.h>, see bpo-46748"

#endif

// Several parts of this module are broken out into files in _testcapi/.

// Include definitions from there.

#include "_testcapi/parts.h"

// Forward declarations

static struct PyModuleDef _testcapimodule;

static PyObject *TestError; /* set to exception object in init */

/* Raise TestError with test_name + ": " + msg, and return NULL. */

static PyObject *

raiseTestError(const char* test_name, const char* msg)

{

PyErr_Format(TestError, "%s: %s", test_name, msg);

return NULL;

}

/* Test #defines from pyconfig.h (particularly the SIZEOF_* defines).

The ones derived from autoconf on the UNIX-like OSes can be relied

upon (in the absence of sloppy cross-compiling), but the Windows

platforms have these hardcoded. Better safe than sorry.

*/

static PyObject*

sizeof_error(const char* fatname, const char* typname,

int expected, int got)

{

PyErr_Format(TestError,

"%s #define == %d but sizeof(%s) == %d",

fatname, expected, typname, got);

return (PyObject*)NULL;

}

static PyObject*

test_config(PyObject *self, PyObject *Py_UNUSED(ignored))

{

#define CHECK_SIZEOF(FATNAME, TYPE) \

if (FATNAME != sizeof(TYPE)) \

return sizeof_error(#FATNAME, #TYPE, FATNAME, sizeof(TYPE))

CHECK_SIZEOF(SIZEOF_SHORT, short);

CHECK_SIZEOF(SIZEOF_INT, int);

CHECK_SIZEOF(SIZEOF_LONG, long);

CHECK_SIZEOF(SIZEOF_VOID_P, void*);

CHECK_SIZEOF(SIZEOF_TIME_T, time_t);

CHECK_SIZEOF(SIZEOF_LONG_LONG, long long);

#undef CHECK_SIZEOF

Py_RETURN_NONE;

}

static PyObject*

test_sizeof_c_types(PyObject *self, PyObject *Py_UNUSED(ignored))

{

#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wtype-limits"

#endif

#define CHECK_SIZEOF(TYPE, EXPECTED) \

if (EXPECTED != sizeof(TYPE)) { \

PyErr_Format(TestError, \

"sizeof(%s) = %u instead of %u", \

#TYPE, sizeof(TYPE), EXPECTED); \

return (PyObject*)NULL; \

}

#define IS_SIGNED(TYPE) (((TYPE)-1) < (TYPE)0)

#define CHECK_SIGNNESS(TYPE, SIGNED) \

if (IS_SIGNED(TYPE) != SIGNED) { \

PyErr_Format(TestError, \

"%s signness is, instead of %i", \

#TYPE, IS_SIGNED(TYPE), SIGNED); \

return (PyObject*)NULL; \

}

/* integer types */

CHECK_SIZEOF(Py_UCS1, 1);

CHECK_SIZEOF(Py_UCS2, 2);

CHECK_SIZEOF(Py_UCS4, 4);

CHECK_SIGNNESS(Py_UCS1, 0);

CHECK_SIGNNESS(Py_UCS2, 0);

CHECK_SIGNNESS(Py_UCS4, 0);

CHECK_SIZEOF(int32_t, 4);

CHECK_SIGNNESS(int32_t, 1);

CHECK_SIZEOF(uint32_t, 4);

CHECK_SIGNNESS(uint32_t, 0);

CHECK_SIZEOF(int64_t, 8);

CHECK_SIGNNESS(int64_t, 1);

CHECK_SIZEOF(uint64_t, 8);

CHECK_SIGNNESS(uint64_t, 0);

/* pointer/size types */

CHECK_SIZEOF(size_t, sizeof(void *));

CHECK_SIGNNESS(size_t, 0);

CHECK_SIZEOF(Py_ssize_t, sizeof(void *));

CHECK_SIGNNESS(Py_ssize_t, 1);

CHECK_SIZEOF(uintptr_t, sizeof(void *));

CHECK_SIGNNESS(uintptr_t, 0);

CHECK_SIZEOF(intptr_t, sizeof(void *));

CHECK_SIGNNESS(intptr_t, 1);

Py_RETURN_NONE;

#undef IS_SIGNED

#undef CHECK_SIGNESS

#undef CHECK_SIZEOF

#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))

#pragma GCC diagnostic pop

#endif

}

static PyObject*

test_gc_control(PyObject *self, PyObject *Py_UNUSED(ignored))

{

int orig_enabled = PyGC_IsEnabled();

const char* msg = "ok";

int old_state;

old_state = PyGC_Enable();

msg = "Enable(1)";

if (old_state != orig_enabled) {

goto failed;

}

msg = "IsEnabled(1)";

if (!PyGC_IsEnabled()) {

goto failed;

}

old_state = PyGC_Disable();

msg = "disable(2)";

if (!old_state) {

goto failed;

}

msg = "IsEnabled(2)";

if (PyGC_IsEnabled()) {

goto failed;

}

old_state = PyGC_Enable();

msg = "enable(3)";

if (old_state) {

goto failed;

}

msg = "IsEnabled(3)";

if (!PyGC_IsEnabled()) {

goto failed;

}

if (!orig_enabled) {

old_state = PyGC_Disable();

msg = "disable(4)";

if (old_state) {

goto failed;

}

msg = "IsEnabled(4)";

if (PyGC_IsEnabled()) {

goto failed;

}

}

Py_RETURN_NONE;

failed:

/* Try to clean up if we can. */

if (orig_enabled) {

PyGC_Enable();

} else {

PyGC_Disable();

}

PyErr_Format(TestError, "GC control failed in %s", msg);

return NULL;

}

static PyObject*

test_list_api(PyObject *self, PyObject *Py_UNUSED(ignored))

{

PyObject* list;

int i;

/* SF bug 132008: PyList_Reverse segfaults */

#define NLIST 30

list = PyList_New(NLIST);

if (list == (PyObject*)NULL)

return (PyObject*)NULL;

/* list = range(NLIST) */

for (i = 0; i < NLIST; ++i) {

PyObject* anint = PyLong_FromLong(i);

if (anint == (PyObject*)NULL) {

Py_DECREF(list);

return (PyObject*)NULL;

}

PyList_SET_ITEM(list, i, anint);

}

/* list.reverse(), via PyList_Reverse() */

i = PyList_Reverse(list); /* should not blow up! */

if (i != 0) {

Py_DECREF(list);

return (PyObject*)NULL;

}

/* Check that list == range(29, -1, -1) now */

for (i = 0; i < NLIST; ++i) {

PyObject* anint = PyList_GET_ITEM(list, i);

if (PyLong_AS_LONG(anint) != NLIST-1-i) {

PyErr_SetString(TestError,

"test_list_api: reverse screwed up");

Py_DECREF(list);

return (PyObject*)NULL;

}

}

Py_DECREF(list);

#undef NLIST

Py_RETURN_NONE;

}

static int

test_dict_inner(int count)

{

Py_ssize_t pos = 0, iterations = 0;

int i;

PyObject *dict = PyDict_New();

PyObject *v, *k;

if (dict == NULL)

return -1;

for (i = 0; i < count; i++) {

v = PyLong_FromLong(i);

if (v == NULL) {

return -1;

}

if (PyDict_SetItem(dict, v, v) < 0) {

Py_DECREF(v);

return -1;

}

Py_DECREF(v);

}

while (PyDict_Next(dict, &pos, &k, &v)) {

PyObject *o;

iterations++;

i = PyLong_AS_LONG(v) + 1;

o = PyLong_FromLong(i);

if (o == NULL)

return -1;

if (PyDict_SetItem(dict, k, o) < 0) {

Py_DECREF(o);

return -1;

}

Py_DECREF(o);

}

Py_DECREF(dict);

if (iterations != count) {

PyErr_SetString(

TestError,

"test_dict_iteration: dict iteration went wrong ");

return -1;

} else {

return 0;

}

}

static PyObject*

test_dict_iteration(PyObject* self, PyObject *Py_UNUSED(ignored))

{

int i;

for (i = 0; i < 200; i++) {

if (test_dict_inner(i) < 0) {

return NULL;

}

}

Py_RETURN_NONE;

}

static PyObject*

dict_getitem_knownhash(PyObject *self, PyObject *args)

{

PyObject *mp, *key, *result;

Py_ssize_t hash;

if (!PyArg_ParseTuple(args, "OOn:dict_getitem_knownhash",

&mp, &key, &hash)) {

return NULL;

}

result = _PyDict_GetItem_KnownHash(mp, key, (Py_hash_t)hash);

if (result == NULL && !PyErr_Occurred()) {

_PyErr_SetKeyError(key);

return NULL;

}

Py_XINCREF(result);

return result;

}

/* Issue #4701: Check that PyObject_Hash implicitly calls

* PyType_Ready if it hasn't already been called

*/

static PyTypeObject _HashInheritanceTester_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

"hashinheritancetester", /* Name of this type */

sizeof(PyObject), /* Basic object size */

0, /* Item size for varobject */

(destructor)PyObject_Del, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT, /* tp_flags */

0, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

0, /* tp_methods */

0, /* tp_members */

0, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

PyType_GenericNew, /* tp_new */

};

static PyObject*

pycompilestring(PyObject* self, PyObject *obj) {

if (PyBytes_CheckExact(obj) == 0) {

PyErr_SetString(PyExc_ValueError, "Argument must be a bytes object");

return NULL;

}

const char *the_string = PyBytes_AsString(obj);

if (the_string == NULL) {

return NULL;

}

return Py_CompileString(the_string, "<string>", Py_file_input);

}

static PyObject*

test_lazy_hash_inheritance(PyObject* self, PyObject *Py_UNUSED(ignored))

{

PyTypeObject *type;

PyObject *obj;

Py_hash_t hash;

type = &_HashInheritanceTester_Type;

if (type->tp_dict != NULL)

/* The type has already been initialized. This probably means

-R is being used. */

Py_RETURN_NONE;

obj = PyObject_New(PyObject, type);

if (obj == NULL) {

PyErr_Clear();

PyErr_SetString(

TestError,

"test_lazy_hash_inheritance: failed to create object");

return NULL;

}

if (type->tp_dict != NULL) {

PyErr_SetString(

TestError,

"test_lazy_hash_inheritance: type initialised too soon");

Py_DECREF(obj);

return NULL;

}

hash = PyObject_Hash(obj);

if ((hash == -1) && PyErr_Occurred()) {

PyErr_Clear();

PyErr_SetString(

TestError,

"test_lazy_hash_inheritance: could not hash object");

Py_DECREF(obj);

return NULL;

}

if (type->tp_dict == NULL) {

PyErr_SetString(

TestError,

"test_lazy_hash_inheritance: type not initialised by hash()");

Py_DECREF(obj);

return NULL;

}

if (type->tp_hash != PyType_Type.tp_hash) {

PyErr_SetString(

TestError,

"test_lazy_hash_inheritance: unexpected hash function");

Py_DECREF(obj);

return NULL;

}

Py_DECREF(obj);

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;

}

/* Test the L code for PyArg_ParseTuple. This should deliver a long long

for both long and int arguments. The test may leak a little memory if

it fails.

*/

static PyObject *

test_L_code(PyObject *self, PyObject *Py_UNUSED(ignored))

{

PyObject *tuple, *num;

long long value;

tuple = PyTuple_New(1);

if (tuple == NULL)

return NULL;

num = PyLong_FromLong(42);

if (num == NULL)

return NULL;

PyTuple_SET_ITEM(tuple, 0, num);

value = -1;

if (!PyArg_ParseTuple(tuple, "L:test_L_code", &value)) {

return NULL;

}

if (value != 42)

return raiseTestError("test_L_code",

"L code returned wrong value for long 42");

Py_DECREF(num);

num = PyLong_FromLong(42);

if (num == NULL)

return NULL;

PyTuple_SET_ITEM(tuple, 0, num);

value = -1;

if (!PyArg_ParseTuple(tuple, "L:test_L_code", &value)) {

return NULL;

}

if (value != 42)

return raiseTestError("test_L_code",

"L code returned wrong value for int 42");

Py_DECREF(tuple);

Py_RETURN_NONE;

}