_testcapimodule.c

/*
 * 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.
 */

#include"Python.h"
#include<float.h>
#include"structmember.h"
#include"datetime.h"
#include"marshal.h"
#include<signal.h>
#ifdefMS_WINDOWS
# include<crtdbg.h>
#endif

#ifdefHAVE_SYS_WAIT_H
#include<sys/wait.h>/* For W_STOPCODE */
#endif

#ifdefWITH_THREAD
#include"pythread.h"
#endif/* WITH_THREAD */
staticPyObject*TestError; /* set to exception object in init */

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

staticPyObject*
raiseTestError(constchar*test_name, constchar*msg)
{
charbuf[2048];

if (strlen(test_name) +strlen(msg) >sizeof(buf) -50)
PyErr_SetString(TestError, "internal error msg too large");
else {
PyOS_snprintf(buf, sizeof(buf), "%s: %s", test_name, msg);
PyErr_SetString(TestError, buf);
 }
returnNULL;
}

/* 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.
*/
staticPyObject*
sizeof_error(constchar*fatname, constchar*typname,
intexpected, intgot)
{
charbuf[1024];
PyOS_snprintf(buf, sizeof(buf),
"%.200s #define == %d but sizeof(%.200s) == %d",
fatname, expected, typname, got);
PyErr_SetString(TestError, buf);
return (PyObject*)NULL;
}

staticPyObject*
test_config(PyObject*self)
{
#defineCHECK_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);
#ifdefHAVE_LONG_LONG
CHECK_SIZEOF(SIZEOF_LONG_LONG, PY_LONG_LONG);
#endif

#undef CHECK_SIZEOF

Py_INCREF(Py_None);
returnPy_None;
}

staticPyObject*
test_list_api(PyObject*self)
{
PyObject*list;
inti;

/* SF bug 132008: PyList_Reverse segfaults */
#defineNLIST 30
list=PyList_New(NLIST);
if (list== (PyObject*)NULL)
return (PyObject*)NULL;
/* list = range(NLIST) */
for (i=0; i<NLIST; ++i) {
PyObject*anint=PyInt_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 (PyInt_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_INCREF(Py_None);
returnPy_None;
}

staticint
test_dict_inner(intcount)
{
Py_ssize_tpos=0, iterations=0;
inti;
PyObject*dict=PyDict_New();
PyObject*v, *k;

if (dict==NULL)
return-1;

for (i=0; i<count; i++) {
v=PyInt_FromLong(i);
PyDict_SetItem(dict, v, v);
Py_DECREF(v);
 }

while (PyDict_Next(dict, &pos, &k, &v)) {
PyObject*o;
iterations++;

i=PyInt_AS_LONG(v) +1;
o=PyInt_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 {
return0;
 }
}

staticPyObject*
test_dict_iteration(PyObject*self)
{
inti;

for (i=0; i<200; i++) {
if (test_dict_inner(i) <0) {
returnNULL;
 }
 }

Py_INCREF(Py_None);
returnPy_None;
}


/* Issue #4701: Check that PyObject_Hash implicitly calls
 * PyType_Ready if it hasn't already been called
 */
staticPyTypeObject_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_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
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 */
};

staticPyObject*
test_lazy_hash_inheritance(PyObject*self)
{
PyTypeObject*type;
PyObject*obj;
longhash;

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");
returnNULL;
 }

if (type->tp_dict!=NULL) {
PyErr_SetString(
TestError,
"test_lazy_hash_inheritance: type initialised too soon");
Py_DECREF(obj);
returnNULL;
 }

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);
returnNULL;
 }

if (type->tp_dict==NULL) {
PyErr_SetString(
TestError,
"test_lazy_hash_inheritance: type not initialised by hash()");
Py_DECREF(obj);
returnNULL;
 }

if (type->tp_hash!=PyType_Type.tp_hash) {
PyErr_SetString(
TestError,
"test_lazy_hash_inheritance: unexpected hash function");
Py_DECREF(obj);
returnNULL;
 }

Py_DECREF(obj);

Py_RETURN_NONE;
}


/* Issue #7385: Check that memoryview() does not crash
 * when bf_getbuffer returns an error
 */

staticint
broken_buffer_getbuffer(PyObject*self, Py_buffer*view, intflags)
{
PyErr_SetString(
TestError,
"test_broken_memoryview: expected error in bf_getbuffer");
return-1;
}

staticPyBufferProcsmemoryviewtester_as_buffer= {
0, /* bf_getreadbuffer */
0, /* bf_getwritebuffer */
0, /* bf_getsegcount */
0, /* bf_getcharbuffer */
 (getbufferproc)broken_buffer_getbuffer, /* bf_getbuffer */
0, /* bf_releasebuffer */
};

staticPyTypeObject_MemoryViewTester_Type= {
PyVarObject_HEAD_INIT(NULL, 0)
"memoryviewtester", /* Name of this type */
sizeof(PyObject), /* Basic object size */
0, /* Item size for varobject */
 (destructor)PyObject_Del, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
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 */
&memoryviewtester_as_buffer, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_NEWBUFFER, /* 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 */
};

staticPyObject*
test_broken_memoryview(PyObject*self)
{
PyObject*obj=PyObject_New(PyObject, &_MemoryViewTester_Type);
PyObject*res;

if (obj==NULL) {
PyErr_Clear();
PyErr_SetString(
TestError,
"test_broken_memoryview: failed to create object");
returnNULL;
 }

res=PyMemoryView_FromObject(obj);
if (res|| !PyErr_Occurred()){
PyErr_SetString(
TestError,
"test_broken_memoryview: memoryview() didn't raise an Exception");
Py_XDECREF(res);
Py_DECREF(obj);
returnNULL;
 }

PyErr_Clear();
Py_DECREF(obj);
Py_RETURN_NONE;
}

staticPyObject*
test_to_contiguous(PyObject*self, PyObject*noargs)
{
intdata[9] = {0, -1, 1, -1, 2, -1, 3, -1, 4};
intresult[5];
Py_ssize_titemsize=sizeof(int);
Py_ssize_tshape=5;
Py_ssize_tstrides=2*itemsize;
Py_bufferview= {
data,
NULL,
5*itemsize,
itemsize,
1,
1,
NULL,
&shape,
&strides,
NULL,
 {0, 0},
NULL
 };
inti;

PyBuffer_ToContiguous(result, &view, view.len, 'C');
for (i=0; i<5; i++) {
if (result[i] !=i) {
PyErr_SetString(TestError,
"test_to_contiguous: incorrect result");
returnNULL;
 }
 }

view.buf=&data[8];
view.strides[0] =-2*itemsize;

PyBuffer_ToContiguous(result, &view, view.len, 'C');
for (i=0; i<5; i++) {
if (result[i] !=4-i) {
PyErr_SetString(TestError,
"test_to_contiguous: incorrect result");
returnNULL;
 }
 }

Py_RETURN_NONE;
}

staticPyObject*
test_from_contiguous(PyObject*self, PyObject*noargs)
{
intdata[9] = {-1,-1,-1,-1,-1,-1,-1,-1,-1};
intinit[5] = {0, 1, 2, 3, 4};
Py_ssize_titemsize=sizeof(int);
Py_ssize_tshape=5;
Py_ssize_tstrides=2*itemsize;
Py_bufferview= {
data,
NULL,
5*itemsize,
itemsize,
1,
1,
NULL,
&shape,
&strides,
NULL,
 {0, 0},
NULL
 };
int*ptr;
inti;

PyBuffer_FromContiguous(&view, init, view.len, 'C');
ptr=view.buf;
for (i=0; i<5; i++) {
if (ptr[2*i] !=i) {
PyErr_SetString(TestError,
"test_from_contiguous: incorrect result");
returnNULL;
 }
 }

view.buf=&data[8];
view.strides[0] =-2*itemsize;

PyBuffer_FromContiguous(&view, init, view.len, 'C');
ptr=view.buf;
for (i=0; i<5; i++) {
if (*(ptr-2*i) !=i) {
PyErr_SetString(TestError,
"test_from_contiguous: incorrect result");
returnNULL;
 }
 }

Py_RETURN_NONE;
}


/* Tests of PyLong_{As, From}{Unsigned,}Long(), and (#ifdef HAVE_LONG_LONG)
 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 PY_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.
*/

#defineUNBIND(X) Py_DECREF(X); (X) = NULL

staticPyObject*
raise_test_long_error(constchar*msg)
{
returnraiseTestError("test_long_api", msg);
}

#defineTESTNAME test_long_api_inner
#defineTYPENAME long
#defineF_S_TO_PY PyLong_FromLong
#defineF_PY_TO_S PyLong_AsLong
#defineF_U_TO_PY PyLong_FromUnsignedLong
#defineF_PY_TO_U PyLong_AsUnsignedLong

#include"testcapi_long.h"

staticPyObject*
test_long_api(PyObject*self)
{
returnTESTNAME(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

#ifdefHAVE_LONG_LONG

staticPyObject*
raise_test_longlong_error(constchar*msg)
{
returnraiseTestError("test_longlong_api", msg);
}

#defineTESTNAME test_longlong_api_inner
#defineTYPENAME PY_LONG_LONG
#defineF_S_TO_PY PyLong_FromLongLong
#defineF_PY_TO_S PyLong_AsLongLong
#defineF_U_TO_PY PyLong_FromUnsignedLongLong
#defineF_PY_TO_U PyLong_AsUnsignedLongLong

#include"testcapi_long.h"

staticPyObject*
test_longlong_api(PyObject*self, PyObject*args)
{
returnTESTNAME(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.
*/

staticPyObject*
test_long_and_overflow(PyObject*self)
{
PyObject*num, *one, *temp;
longvalue;
intoverflow;

/* 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)
returnNULL;
overflow=1234;
value=PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value==-1&&PyErr_Occurred())
returnNULL;
if (value!=-1)
returnraiseTestError("test_long_and_overflow",
"return value was not set to -1");
if (overflow!=1)
returnraiseTestError("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)
returnNULL;
one=PyLong_FromLong(1L);
if (one==NULL) {
Py_DECREF(num);
returnNULL;
 }
temp=PyNumber_Add(num, one);
Py_DECREF(one);
Py_DECREF(num);
num=temp;
if (num==NULL)
returnNULL;
overflow=0;
value=PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value==-1&&PyErr_Occurred())
returnNULL;
if (value!=-1)
returnraiseTestError("test_long_and_overflow",
"return value was not set to -1");
if (overflow!=1)
returnraiseTestError("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)
returnNULL;
overflow=1234;
value=PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value==-1&&PyErr_Occurred())
returnNULL;
if (value!=-1)
returnraiseTestError("test_long_and_overflow",
"return value was not set to -1");
if (overflow!=-1)
returnraiseTestError("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)
returnNULL;
one=PyLong_FromLong(1L);
if (one==NULL) {
Py_DECREF(num);
returnNULL;
 }
temp=PyNumber_Subtract(num, one);
Py_DECREF(one);
Py_DECREF(num);
num=temp;
if (num==NULL)
returnNULL;
overflow=0;
value=PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value==-1&&PyErr_Occurred())
returnNULL;
if (value!=-1)
returnraiseTestError("test_long_and_overflow",
"return value was not set to -1");
if (overflow!=-1)
returnraiseTestError("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)
returnNULL;
overflow=1234;
value=PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value==-1&&PyErr_Occurred())
returnNULL;
if (value!=0xFF)
returnraiseTestError("test_long_and_overflow",
"expected return value 0xFF");
if (overflow!=0)
returnraiseTestError("test_long_and_overflow",
"overflow was not cleared");

num=PyLong_FromString("-FF", NULL, 16);
if (num==NULL)
returnNULL;
overflow=0;
value=PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value==-1&&PyErr_Occurred())
returnNULL;
if (value!=-0xFF)
returnraiseTestError("test_long_and_overflow",
"expected return value 0xFF");
if (overflow!=0)
returnraiseTestError("test_long_and_overflow",
"overflow was set incorrectly");

num=PyLong_FromLong(LONG_MAX);
if (num==NULL)
returnNULL;
overflow=1234;
value=PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value==-1&&PyErr_Occurred())
returnNULL;
if (value!=LONG_MAX)
returnraiseTestError("test_long_and_overflow",
"expected return value LONG_MAX");
if (overflow!=0)
returnraiseTestError("test_long_and_overflow",
"overflow was not cleared");

num=PyLong_FromLong(LONG_MIN);
if (num==NULL)
returnNULL;
overflow=0;
value=PyLong_AsLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value==-1&&PyErr_Occurred())
returnNULL;
if (value!=LONG_MIN)
returnraiseTestError("test_long_and_overflow",
"expected return value LONG_MIN");
if (overflow!=0)
returnraiseTestError("test_long_and_overflow",
"overflow was not cleared");

Py_INCREF(Py_None);
returnPy_None;
}

/* Test the PyLong_AsLongLongAndOverflow API. General conversion to
 PY_LONG_LONG is tested by test_long_api_inner. This test will
 concentrate on proper handling of overflow.
*/

staticPyObject*
test_long_long_and_overflow(PyObject*self)
{
PyObject*num, *one, *temp;
PY_LONG_LONGvalue;
intoverflow;

/* Test that overflow is set properly for a large value. */
/* num is a number larger than PY_LLONG_MAX on a typical machine. */
num=PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
if (num==NULL)
returnNULL;
overflow=1234;
value=PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value==-1&&PyErr_Occurred())
returnNULL;
if (value!=-1)
returnraiseTestError("test_long_long_and_overflow",
"return value was not set to -1");
if (overflow!=1)
returnraiseTestError("test_long_long_and_overflow",
"overflow was not set to 1");

/* Same again, with num = PY_LLONG_MAX + 1 */
num=PyLong_FromLongLong(PY_LLONG_MAX);
if (num==NULL)
returnNULL;
one=PyLong_FromLong(1L);
if (one==NULL) {
Py_DECREF(num);
returnNULL;
 }
temp=PyNumber_Add(num, one);
Py_DECREF(one);
Py_DECREF(num);
num=temp;
if (num==NULL)
returnNULL;
overflow=0;
value=PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value==-1&&PyErr_Occurred())
returnNULL;
if (value!=-1)
returnraiseTestError("test_long_long_and_overflow",
"return value was not set to -1");
if (overflow!=1)
returnraiseTestError("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 PY_LLONG_MIN on a typical platform */
num=PyLong_FromString("-FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
if (num==NULL)
returnNULL;
overflow=1234;
value=PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value==-1&&PyErr_Occurred())
returnNULL;
if (value!=-1)
returnraiseTestError("test_long_long_and_overflow",
"return value was not set to -1");
if (overflow!=-1)
returnraiseTestError("test_long_long_and_overflow",
"overflow was not set to -1");

/* Same again, with num = PY_LLONG_MIN - 1 */
num=PyLong_FromLongLong(PY_LLONG_MIN);
if (num==NULL)
returnNULL;
one=PyLong_FromLong(1L);
if (one==NULL) {
Py_DECREF(num);
returnNULL;
 }
temp=PyNumber_Subtract(num, one);
Py_DECREF(one);
Py_DECREF(num);
num=temp;
if (num==NULL)
returnNULL;
overflow=0;
value=PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value==-1&&PyErr_Occurred())
returnNULL;
if (value!=-1)
returnraiseTestError("test_long_long_and_overflow",
"return value was not set to -1");
if (overflow!=-1)
returnraiseTestError("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)
returnNULL;
overflow=1234;
value=PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value==-1&&PyErr_Occurred())
returnNULL;
if (value!=0xFF)
returnraiseTestError("test_long_long_and_overflow",
"expected return value 0xFF");
if (overflow!=0)
returnraiseTestError("test_long_long_and_overflow",
"overflow was not cleared");

num=PyLong_FromString("-FF", NULL, 16);
if (num==NULL)
returnNULL;
overflow=0;
value=PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value==-1&&PyErr_Occurred())
returnNULL;
if (value!=-0xFF)
returnraiseTestError("test_long_long_and_overflow",
"expected return value 0xFF");
if (overflow!=0)
returnraiseTestError("test_long_long_and_overflow",
"overflow was set incorrectly");

num=PyLong_FromLongLong(PY_LLONG_MAX);
if (num==NULL)
returnNULL;
overflow=1234;
value=PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value==-1&&PyErr_Occurred())
returnNULL;
if (value!=PY_LLONG_MAX)
returnraiseTestError("test_long_long_and_overflow",
"expected return value PY_LLONG_MAX");
if (overflow!=0)
returnraiseTestError("test_long_long_and_overflow",
"overflow was not cleared");

num=PyLong_FromLongLong(PY_LLONG_MIN);
if (num==NULL)
returnNULL;
overflow=0;
value=PyLong_AsLongLongAndOverflow(num, &overflow);
Py_DECREF(num);
if (value==-1&&PyErr_Occurred())
returnNULL;
if (value!=PY_LLONG_MIN)
returnraiseTestError("test_long_long_and_overflow",
"expected return value PY_LLONG_MIN");
if (overflow!=0)
returnraiseTestError("test_long_long_and_overflow",
"overflow was not cleared");

Py_INCREF(Py_None);
returnPy_None;
}

staticPyObject*
test_long_as_unsigned_long_long_mask(PyObject*self)
{
unsigned PY_LONG_LONGres=PyLong_AsUnsignedLongLongMask(NULL);

if (res!= (unsigned PY_LONG_LONG)-1|| !PyErr_Occurred()) {
returnraiseTestError("test_long_as_unsigned_long_long_mask",
"PyLong_AsUnsignedLongLongMask(NULL) didn't "
"complain");
 }
if (!PyErr_ExceptionMatches(PyExc_SystemError)) {
returnraiseTestError("test_long_as_unsigned_long_long_mask",
"PyLong_AsUnsignedLongLongMask(NULL) raised "
"something other than SystemError");
 }
PyErr_Clear();
Py_INCREF(Py_None);
returnPy_None;
}

/* Test the L code for PyArg_ParseTuple. This should deliver a PY_LONG_LONG
 for both long and int arguments. The test may leak a little memory if
 it fails.
*/
staticPyObject*
test_L_code(PyObject*self)
{
PyObject*tuple, *num;
PY_LONG_LONGvalue;

tuple=PyTuple_New(1);
if (tuple==NULL)
returnNULL;

num=PyLong_FromLong(42);
if (num==NULL)
returnNULL;

PyTuple_SET_ITEM(tuple, 0, num);

value=-1;
if (!PyArg_ParseTuple(tuple, "L:test_L_code", &value)) {
returnNULL;
 }
if (value!=42)
returnraiseTestError("test_L_code",
"L code returned wrong value for long 42");

Py_DECREF(num);
num=PyInt_FromLong(42);
if (num==NULL)
returnNULL;

PyTuple_SET_ITEM(tuple, 0, num);

value=-1;
if (!PyArg_ParseTuple(tuple, "L:test_L_code", &value)) {
returnNULL;
 }
if (value!=42)
returnraiseTestError("test_L_code",
"L code returned wrong value for int 42");

Py_DECREF(tuple);
Py_INCREF(Py_None);
returnPy_None;
}

#endif/* ifdef HAVE_LONG_LONG */

staticPyObject*
return_none(void*unused)
{
Py_RETURN_NONE;
}

staticPyObject*
raise_error(void*unused)
{
PyErr_SetNone(PyExc_ValueError);
returnNULL;
}

staticint
test_buildvalue_N_error(constchar*fmt)
{
PyObject*arg, *res;

arg=PyList_New(0);
if (arg==NULL) {
return-1;
 }

Py_INCREF(arg);
res=Py_BuildValue(fmt, return_none, NULL, arg);
if (res==NULL) {
return-1;
 }
Py_DECREF(res);
if (Py_REFCNT(arg) !=1) {
PyErr_Format(TestError, "test_buildvalue_N: "
"arg was not decrefed in successful "
"Py_BuildValue(\"%s\")", fmt);
return-1;
 }

Py_INCREF(arg);
res=Py_BuildValue(fmt, raise_error, NULL, arg);
if (res!=NULL|| !PyErr_Occurred()) {
PyErr_Format(TestError, "test_buildvalue_N: "