/lib_pypy/_testcapimodule.c
C | 1898 lines | 1563 code | 211 blank | 124 comment | 345 complexity | 698e4985c119ca8654fac0a3780aa942 MD5 | raw file
- /* Verbatim copy of Modules/_testcapimodule.c from CPython 2.7 */
- /*
- * 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"
- #ifdef WITH_THREAD
- #include "pythread.h"
- #endif /* WITH_THREAD */
- 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)
- {
- char buf[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);
- }
- 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)
- {
- char buf[1024];
- PyOS_snprintf(buf, sizeof(buf),
- "%.200s #define == %d but sizeof(%.200s) == %d",
- fatname, expected, typname, got);
- PyErr_SetString(TestError, buf);
- return (PyObject*)NULL;
- }
- static PyObject*
- test_config(PyObject *self)
- {
- #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);
- #ifdef HAVE_LONG_LONG
- CHECK_SIZEOF(SIZEOF_LONG_LONG, PY_LONG_LONG);
- #endif
- #undef CHECK_SIZEOF
- Py_INCREF(Py_None);
- return Py_None;
- }
- static PyObject*
- test_list_api(PyObject *self)
- {
- 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 = 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);
- return Py_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 = 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 {
- return 0;
- }
- }
- static PyObject*
- test_dict_iteration(PyObject* self)
- {
- int i;
- for (i = 0; i < 200; i++) {
- if (test_dict_inner(i) < 0) {
- return NULL;
- }
- }
- Py_INCREF(Py_None);
- return Py_None;
- }
- /* Issue #4701: Check that PyObject_Hash implicitly calls
- * PyType_Ready if it hasn't already been called
- */
- static PyTypeObject _HashInheritanceTester_Type = {
- PyObject_HEAD_INIT(NULL)
- 0, /* Number of items for varobject */
- "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 */
- };
- static PyObject*
- test_lazy_hash_inheritance(PyObject* self)
- {
- PyTypeObject *type;
- PyObject *obj;
- long 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;
- }
- /* Issue #7385: Check that memoryview() does not crash
- * when bf_getbuffer returns an error
- */
- static int
- broken_buffer_getbuffer(PyObject *self, Py_buffer *view, int flags)
- {
- PyErr_SetString(
- TestError,
- "test_broken_memoryview: expected error in bf_getbuffer");
- return -1;
- }
- static PyBufferProcs memoryviewtester_as_buffer = {
- 0, /* bf_getreadbuffer */
- 0, /* bf_getwritebuffer */
- 0, /* bf_getsegcount */
- 0, /* bf_getcharbuffer */
- (getbufferproc)broken_buffer_getbuffer, /* bf_getbuffer */
- 0, /* bf_releasebuffer */
- };
- static PyTypeObject _MemoryViewTester_Type = {
- PyObject_HEAD_INIT(NULL)
- 0, /* Number of items for varobject */
- "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 */
- };
- static PyObject*
- 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");
- return NULL;
- }
- 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);
- return NULL;
- }
- PyErr_Clear();
- Py_DECREF(obj);
- 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.
- */
- #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)
- {
- 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
- #ifdef HAVE_LONG_LONG
- static PyObject *
- raise_test_longlong_error(const char* msg)
- {
- return raiseTestError("test_longlong_api", msg);
- }
- #define TESTNAME test_longlong_api_inner
- #define TYPENAME PY_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 *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_INCREF(Py_None);
- return Py_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.
- */
- static PyObject *
- test_long_long_and_overflow(PyObject *self)
- {
- PyObject *num, *one, *temp;
- PY_LONG_LONG value;
- int overflow;
- /* 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)
- 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 = PY_LLONG_MAX + 1 */
- num = PyLong_FromLongLong(PY_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 PY_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 = PY_LLONG_MIN - 1 */
- num = PyLong_FromLongLong(PY_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(PY_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 != PY_LLONG_MAX)
- return raiseTestError("test_long_long_and_overflow",
- "expected return value PY_LLONG_MAX");
- if (overflow != 0)
- return raiseTestError("test_long_long_and_overflow",
- "overflow was not cleared");
- num = PyLong_FromLongLong(PY_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 != PY_LLONG_MIN)
- return raiseTestError("test_long_long_and_overflow",
- "expected return value PY_LLONG_MIN");
- if (overflow != 0)
- return raiseTestError("test_long_long_and_overflow",
- "overflow was not cleared");
- Py_INCREF(Py_None);
- return Py_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.
- */
- static PyObject *
- test_L_code(PyObject *self)
- {
- PyObject *tuple, *num;
- PY_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) < 0)
- return NULL;
- if (value != 42)
- return raiseTestError("test_L_code",
- "L code returned wrong value for long 42");
- Py_DECREF(num);
- num = PyInt_FromLong(42);
- if (num == NULL)
- return NULL;
- PyTuple_SET_ITEM(tuple, 0, num);
- value = -1;
- if (PyArg_ParseTuple(tuple, "L:test_L_code", &value) < 0)
- return NULL;
- if (value != 42)
- return raiseTestError("test_L_code",
- "L code returned wrong value for int 42");
- Py_DECREF(tuple);
- Py_INCREF(Py_None);
- return Py_None;
- }
- #endif /* ifdef HAVE_LONG_LONG */
- /* Test tuple argument processing */
- static PyObject *
- getargs_tuple(PyObject *self, PyObject *args)
- {
- int a, b, c;
- if (!PyArg_ParseTuple(args, "i(ii)", &a, &b, &c))
- return NULL;
- return Py_BuildValue("iii", a, b, c);
- }
- /* test PyArg_ParseTupleAndKeywords */
- static PyObject *getargs_keywords(PyObject *self, PyObject *args, PyObject *kwargs)
- {
- static char *keywords[] = {"arg1","arg2","arg3","arg4","arg5", NULL};
- static char *fmt="(ii)i|(i(ii))(iii)i";
- int int_args[10]={-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
- if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,
- &int_args[0], &int_args[1], &int_args[2], &int_args[3], &int_args[4],
- &int_args[5], &int_args[6], &int_args[7], &int_args[8], &int_args[9]))
- return NULL;
- return Py_BuildValue("iiiiiiiiii",
- int_args[0], int_args[1], int_args[2], int_args[3], int_args[4],
- int_args[5], int_args[6], int_args[7], int_args[8], int_args[9]);
- }
- /* Functions to call PyArg_ParseTuple with integer format codes,
- and return the result.
- */
- static PyObject *
- getargs_b(PyObject *self, PyObject *args)
- {
- unsigned char value;
- if (!PyArg_ParseTuple(args, "b", &value))
- return NULL;
- return PyLong_FromUnsignedLong((unsigned long)value);
- }
- static PyObject *
- getargs_B(PyObject *self, PyObject *args)
- {
- unsigned char value;
- if (!PyArg_ParseTuple(args, "B", &value))
- return NULL;
- return PyLong_FromUnsignedLong((unsigned long)value);
- }
- static PyObject *
- getargs_h(PyObject *self, PyObject *args)
- {
- short value;
- if (!PyArg_ParseTuple(args, "h", &value))
- return NULL;
- return PyLong_FromLong((long)value);
- }
- static PyObject *
- getargs_H(PyObject *self, PyObject *args)
- {
- unsigned short value;
- if (!PyArg_ParseTuple(args, "H", &value))
- return NULL;
- return PyLong_FromUnsignedLong((unsigned long)value);
- }
- static PyObject *
- getargs_I(PyObject *self, PyObject *args)
- {
- unsigned int value;
- if (!PyArg_ParseTuple(args, "I", &value))
- return NULL;
- return PyLong_FromUnsignedLong((unsigned long)value);
- }
- static PyObject *
- getargs_k(PyObject *self, PyObject *args)
- {
- unsigned long value;
- if (!PyArg_ParseTuple(args, "k", &value))
- return NULL;
- return PyLong_FromUnsignedLong(value);
- }
- static PyObject *
- getargs_i(PyObject *self, PyObject *args)
- {
- int value;
- if (!PyArg_ParseTuple(args, "i", &value))
- return NULL;
- return PyLong_FromLong((long)value);
- }
- static PyObject *
- getargs_l(PyObject *self, PyObject *args)
- {
- long value;
- if (!PyArg_ParseTuple(args, "l", &value))
- return NULL;
- return PyLong_FromLong(value);
- }
- static PyObject *
- getargs_n(PyObject *self, PyObject *args)
- {
- Py_ssize_t value;
- if (!PyArg_ParseTuple(args, "n", &value))
- return NULL;
- return PyInt_FromSsize_t(value);
- }
- #ifdef HAVE_LONG_LONG
- static PyObject *
- getargs_L(PyObject *self, PyObject *args)
- {
- PY_LONG_LONG value;
- if (!PyArg_ParseTuple(args, "L", &value))
- return NULL;
- return PyLong_FromLongLong(value);
- }
- static PyObject *
- getargs_K(PyObject *self, PyObject *args)
- {
- unsigned PY_LONG_LONG value;
- if (!PyArg_ParseTuple(args, "K", &value))
- return NULL;
- return PyLong_FromUnsignedLongLong(value);
- }
- #endif
- /* This function not only tests the 'k' getargs code, but also the
- PyInt_AsUnsignedLongMask() and PyInt_AsUnsignedLongMask() functions. */
- static PyObject *
- test_k_code(PyObject *self)
- {
- PyObject *tuple, *num;
- unsigned long value;
- tuple = PyTuple_New(1);
- if (tuple == NULL)
- return NULL;
- /* a number larger than ULONG_MAX even on 64-bit platforms */
- num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
- if (num == NULL)
- return NULL;
- value = PyInt_AsUnsignedLongMask(num);
- if (value != ULONG_MAX)
- return raiseTestError("test_k_code",
- "PyInt_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
- PyTuple_SET_ITEM(tuple, 0, num);
- value = 0;
- if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)
- return NULL;
- if (value != ULONG_MAX)
- return raiseTestError("test_k_code",
- "k code returned wrong value for long 0xFFF...FFF");
- Py_DECREF(num);
- num = PyLong_FromString("-FFFFFFFF000000000000000042", NULL, 16);
- if (num == NULL)
- return NULL;
- value = PyInt_AsUnsignedLongMask(num);
- if (value != (unsigned long)-0x42)
- return raiseTestError("test_k_code",
- "PyInt_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
- PyTuple_SET_ITEM(tuple, 0, num);
- value = 0;
- if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)
- return NULL;
- if (value != (unsigned long)-0x42)
- return raiseTestError("test_k_code",
- "k code returned wrong value for long -0xFFF..000042");
- Py_DECREF(tuple);
- Py_INCREF(Py_None);
- return Py_None;
- }
- #ifdef Py_USING_UNICODE
- static volatile int x;
- /* Test the u and u# codes for PyArg_ParseTuple. May leak memory in case
- of an error.
- */
- static PyObject *
- test_u_code(PyObject *self)
- {
- PyObject *tuple, *obj;
- Py_UNICODE *value;
- int len;
- /* issue4122: Undefined reference to _Py_ascii_whitespace on Windows */
- /* Just use the macro and check that it compiles */
- x = Py_UNICODE_ISSPACE(25);
- tuple = PyTuple_New(1);
- if (tuple == NULL)
- return NULL;
- obj = PyUnicode_Decode("test", strlen("test"),
- "ascii", NULL);
- if (obj == NULL)
- return NULL;
- PyTuple_SET_ITEM(tuple, 0, obj);
- value = 0;
- if (PyArg_ParseTuple(tuple, "u:test_u_code", &value) < 0)
- return NULL;
- if (value != PyUnicode_AS_UNICODE(obj))
- return raiseTestError("test_u_code",
- "u code returned wrong value for u'test'");
- value = 0;
- if (PyArg_ParseTuple(tuple, "u#:test_u_code", &value, &len) < 0)
- return NULL;
- if (value != PyUnicode_AS_UNICODE(obj) ||
- len != PyUnicode_GET_SIZE(obj))
- return raiseTestError("test_u_code",
- "u# code returned wrong values for u'test'");
- Py_DECREF(tuple);
- Py_INCREF(Py_None);
- return Py_None;
- }
- static PyObject *
- test_widechar(PyObject *self)
- {
- #if defined(SIZEOF_WCHAR_T) && (SIZEOF_WCHAR_T == 4)
- const wchar_t wtext[2] = {(wchar_t)0x10ABCDu};
- size_t wtextlen = 1;
- #else
- const wchar_t wtext[3] = {(wchar_t)0xDBEAu, (wchar_t)0xDFCDu};
- size_t wtextlen = 2;
- #endif
- PyObject *wide, *utf8;
- wide = PyUnicode_FromWideChar(wtext, wtextlen);
- if (wide == NULL)
- return NULL;
- utf8 = PyUnicode_FromString("\xf4\x8a\xaf\x8d");
- if (utf8 == NULL) {
- Py_DECREF(wide);
- return NULL;
- }
- if (PyUnicode_GET_SIZE(wide) != PyUnicode_GET_SIZE(utf8)) {
- Py_DECREF(wide);
- Py_DECREF(utf8);
- return raiseTestError("test_widechar",
- "wide string and utf8 string have different length");
- }
- if (PyUnicode_Compare(wide, utf8)) {
- Py_DECREF(wide);
- Py_DECREF(utf8);
- if (PyErr_Occurred())
- return NULL;
- return raiseTestError("test_widechar",
- "wide string and utf8 string are differents");
- }
- Py_DECREF(wide);
- Py_DECREF(utf8);
- Py_RETURN_NONE;
- }
- static PyObject *
- test_empty_argparse(PyObject *self)
- {
- /* Test that formats can begin with '|'. See issue #4720. */
- PyObject *tuple, *dict = NULL;
- static char *kwlist[] = {NULL};
- int result;
- tuple = PyTuple_New(0);
- if (!tuple)
- return NULL;
- if ((result = PyArg_ParseTuple(tuple, "|:test_empty_argparse")) < 0)
- goto done;
- dict = PyDict_New();
- if (!dict)
- goto done;
- result = PyArg_ParseTupleAndKeywords(tuple, dict, "|:test_empty_argparse", kwlist);
- done:
- Py_DECREF(tuple);
- Py_XDECREF(dict);
- if (result < 0)
- return NULL;
- else {
- Py_RETURN_NONE;
- }
- }
- static PyObject *
- codec_incrementalencoder(PyObject *self, PyObject *args)
- {
- const char *encoding, *errors = NULL;
- if (!PyArg_ParseTuple(args, "s|s:test_incrementalencoder",
- &encoding, &errors))
- return NULL;
- return PyCodec_IncrementalEncoder(encoding, errors);
- }
- static PyObject *
- codec_incrementaldecoder(PyObject *self, PyObject *args)
- {
- const char *encoding, *errors = NULL;
- if (!PyArg_ParseTuple(args, "s|s:test_incrementaldecoder",
- &encoding, &errors))
- return NULL;
- return PyCodec_IncrementalDecoder(encoding, errors);
- }
- #endif
- /* Simple test of _PyLong_NumBits and _PyLong_Sign. */
- static PyObject *
- test_long_numbits(PyObject *self)
- {
- 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 long digit */
- {-0x7fffL, 15, -1},
- {0xffffL, 16, 1},
- {-0xffffL, 16, -1},
- {0xfffffffL, 28, 1},
- {-0xfffffffL, 28, -1}};
- int i;
- for (i = 0; i < sizeof(testcases) / sizeof(struct triple); ++i) {
- PyObject *plong = PyLong_FromLong(testcases[i].input);
- size_t nbits = _PyLong_NumBits(plong);
- int 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_INCREF(Py_None);
- return Py_None;
- }
- /* Example passing NULLs to PyObject_Str(NULL) and PyObject_Unicode(NULL). */
- static PyObject *
- test_null_strings(PyObject *self)
- {
- PyObject *o1 = PyObject_Str(NULL), *o2 = PyObject_Unicode(NULL);
- PyObject *tuple = PyTuple_Pack(2, o1, o2);
- Py_XDECREF(o1);
- Py_XDECREF(o2);
- return tuple;
- }
- static PyObject *
- raise_exception(PyObject *self, PyObject *args)
- {
- PyObject *exc;
- PyObject *exc_args, *v;
- int num_args, i;
- if (!PyArg_ParseTuple(args, "Oi:raise_exception",
- &exc, &num_args))
- return NULL;
- if (!PyExceptionClass_Check(exc)) {
- PyErr_Format(PyExc_TypeError, "an exception class is required");
- return NULL;
- }
- exc_args = PyTuple_New(num_args);
- if (exc_args == NULL)
- return NULL;
- for (i = 0; i < num_args; ++i) {
- v = PyInt_FromLong(i);
- if (v == NULL) {
- Py_DECREF(exc_args);
- return NULL;
- }
- PyTuple_SET_ITEM(exc_args, i, v);
- }
- PyErr_SetObject(exc, exc_args);
- Py_DECREF(exc_args);
- return NULL;
- }
- static int test_run_counter = 0;
- static PyObject *
- test_datetime_capi(PyObject *self, PyObject *args) {
- if (PyDateTimeAPI) {
- if (test_run_counter) {
- /* Probably regrtest.py -R */
- Py_RETURN_NONE;
- }
- else {
- PyErr_SetString(PyExc_AssertionError,
- "PyDateTime_CAPI somehow initialized");
- return NULL;
- }
- }
- test_run_counter++;
- PyDateTime_IMPORT;
- if (PyDateTimeAPI)
- Py_RETURN_NONE;
- else
- return NULL;
- }
- #ifdef WITH_THREAD
- /* test_thread_state spawns a thread of its own, and that thread releases
- * `thread_done` when it's finished. The driver code has to know when the
- * thread finishes, because the thread uses a PyObject (the callable) that
- * may go away when the driver finishes. The former lack of this explicit
- * synchronization caused rare segfaults, so rare that they were seen only
- * on a Mac buildbot (although they were possible on any box).
- */
- static PyThread_type_lock thread_done = NULL;
- static int
- _make_call(void *callable)
- {
- PyObject *rc;
- int success;
- PyGILState_STATE s = PyGILState_Ensure();
- rc = PyObject_CallFunction((PyObject *)callable, "");
- success = (rc != NULL);
- Py_XDECREF(rc);
- PyGILState_Release(s);
- return success;
- }
- /* Same thing, but releases `thread_done` when it returns. This variant
- * should be called only from threads spawned by test_thread_state().
- */
- static void
- _make_call_from_thread(void *callable)
- {
- _make_call(callable);
- PyThread_release_lock(thread_done);
- }
- static PyObject *
- test_thread_state(PyObject *self, PyObject *args)
- {
- PyObject *fn;
- int success = 1;
- if (!PyArg_ParseTuple(args, "O:test_thread_state", &fn))
- return NULL;
- if (!PyCallable_Check(fn)) {
- PyErr_Format(PyExc_TypeError, "'%s' object is not callable",
- fn->ob_type->tp_name);
- return NULL;
- }
- /* Ensure Python is set up for threading */
- PyEval_InitThreads();
- thread_done = PyThread_allocate_lock();
- if (thread_done == NULL)
- return PyErr_NoMemory();
- PyThread_acquire_lock(thread_done, 1);
- /* Start a new thread with our callback. */
- PyThread_start_new_thread(_make_call_from_thread, fn);
- /* Make the callback with the thread lock held by this thread */
- success &= _make_call(fn);
- /* Do it all again, but this time with the thread-lock released */
- Py_BEGIN_ALLOW_THREADS
- success &= _make_call(fn);
- PyThread_acquire_lock(thread_done, 1); /* wait for thread to finish */
- Py_END_ALLOW_THREADS
- /* And once more with and without a thread
- XXX - should use a lock and work out exactly what we are trying
- to test <wink>
- */
- Py_BEGIN_ALLOW_THREADS
- PyThread_start_new_thread(_make_call_from_thread, fn);
- success &= _make_call(fn);
- PyThread_acquire_lock(thread_done, 1); /* wait for thread to finish */
- Py_END_ALLOW_THREADS
- /* Release lock we acquired above. This is required on HP-UX. */
- PyThread_release_lock(thread_done);
- PyThread_free_lock(thread_done);
- if (!success)
- return NULL;
- Py_RETURN_NONE;
- }
- /* test Py_AddPendingCalls using threads */
- static int _pending_callback(void *arg)
- {
- /* we assume the argument is callable object to which we own a reference */
- PyObject *callable = (PyObject *)arg;
- PyObject *r = PyObject_CallObject(callable, NULL);
- Py_DECREF(callable);
- Py_XDECREF(r);
- return r != NULL ? 0 : -1;
- }
- /* The following requests n callbacks to _pending_callback. It can be
- * run from any python thread.
- */
- PyObject *pending_threadfunc(PyObject *self, PyObject *arg)
- {
- PyObject *callable;
- int r;
- if (PyArg_ParseTuple(arg, "O", &callable) == 0)
- return NULL;
- /* create the reference for the callbackwhile we hold the lock */
- Py_INCREF(callable);
- Py_BEGIN_ALLOW_THREADS
- r = Py_AddPendingCall(&_pending_callback, callable);
- Py_END_ALLOW_THREADS
- if (r<0) {
- Py_DECREF(callable); /* unsuccessful add, destroy the extra reference */
- Py_INCREF(Py_False);
- return Py_False;
- }
- Py_INCREF(Py_True);
- return Py_True;
- }
- #endif
- /* Some tests of PyString_FromFormat(). This needs more tests. */
- static PyObject *
- test_string_from_format(PyObject *self, PyObject *args)
- {
- PyObject *result;
- char *msg;
- #define CHECK_1_FORMAT(FORMAT, TYPE) \
- result = PyString_FromFormat(FORMAT, (TYPE)1); \
- if (result == NULL) \
- return NULL; \
- if (strcmp(PyString_AsString(result), "1")) { \
- msg = FORMAT " failed at 1"; \
- goto Fail; \
- } \
- Py_DECREF(result)
- CHECK_1_FORMAT("%d", int);
- CHECK_1_FORMAT("%ld", long);
- /* The z width modifier was added in Python 2.5. */
- CHECK_1_FORMAT("%zd", Py_ssize_t);
- /* The u type code was added in Python 2.5. */
- CHECK_1_FORMAT("%u", unsigned int);
- CHECK_1_FORMAT("%lu", unsigned long);
- CHECK_1_FORMAT("%zu", size_t);
- /* "%lld" and "%llu" support added in Python 2.7. */
- #ifdef HAVE_LONG_LONG
- CHECK_1_FORMAT("%llu", unsigned PY_LONG_LONG);
- CHECK_1_FORMAT("%lld", PY_LONG_LONG);
- #endif
- Py_RETURN_NONE;
- Fail:
- Py_XDECREF(result);
- return raiseTestError("test_string_from_format", msg);
- #undef CHECK_1_FORMAT
- }
- /* Coverage testing of capsule objects. */
- static const char *capsule_name = "capsule name";
- static char *capsule_pointer = "capsule pointer";
- static char *capsule_context = "capsule context";
- static const char *capsule_error = NULL;
- static int
- capsule_destructor_call_count = 0;
- static void
- capsule_destructor(PyObject *o) {
- capsule_destructor_call_count++;
- if (PyCapsule_GetContext(o) != capsule_context) {
- capsule_error = "context did not match in destructor!";
- } else if (PyCapsule_GetDestructor(o) != capsule_destructor) {
- capsule_error = "destructor did not match in destructor! (woah!)";
- } else if (PyCapsule_GetName(o) != capsule_name) {
- capsule_error = "name did not match in destructor!";
- } else if (PyCapsule_GetPointer(o, capsule_name) != capsule_pointer) {
- capsule_error = "pointer did not match in destructor!";
- }
- }
- typedef struct {
- char *name;
- char *module;
- char *attribute;
- } known_capsule;
- static PyObject *
- test_capsule(PyObject *self, PyObject *args)
- {
- PyObject *object;
- const char *error = NULL;
- void *pointer;
- void *pointer2;
- known_capsule known_capsules[] = {
- #define KNOWN_CAPSULE(module, name) { module "." name, module, name }
- KNOWN_CAPSULE("_socket", "CAPI"),
- KNOWN_CAPSULE("_curses", "_C_API"),
- KNOWN_CAPSULE("datetime", "datetime_CAPI"),
- { NULL, NULL },
- };
- known_capsule *known = &known_capsules[0];
- #define FAIL(x) { error = (x); goto exit; }
- #define CHECK_DESTRUCTOR \
- if (capsule_error) { \
- FAIL(capsule_error); \
- } \
- else if (!capsule_destructor_call_count) { \
- FAIL("destructor not called!"); \
- } \
- capsule_destructor_call_count = 0; \
- object = PyCapsule_New(capsule_pointer, capsule_name, capsule_destructor);
- PyCapsule_SetContext(object, capsule_context);
- capsule_destructor(object);
- CHECK_DESTRUCTOR;
- Py_DECREF(object);
- CHECK_DESTRUCTOR;
- object = PyCapsule_New(known, "ignored", NULL);
- PyCapsule_SetPointer(object, capsule_pointer);
- PyCapsule_SetName(object, capsule_name);
- PyCapsule_SetDestructor(object, capsule_destructor);
- PyCapsule_SetContext(object, capsule_context);
- capsule_destructor(object);
- CHECK_DESTRUCTOR;
- /* intentionally access using the wrong name */
- pointer2 = PyCapsule_GetPointer(object, "the wrong name");
- if (!PyErr_Occurred()) {
- FAIL("PyCapsule_GetPointer should have failed but did not!");
- }
- PyErr_Clear();
- if (pointer2) {
- if (pointer2 == capsule_pointer) {
- FAIL("PyCapsule_GetPointer should not have"
- " returned the internal pointer!");
- } else {
- FAIL("PyCapsule_GetPointer should have "
- "returned NULL pointer but did not!");
- }
- }
- PyCapsule_SetDestructor(object, NULL);
- Py_DECREF(object);
- if (capsule_destructor_call_count) {
- FAIL("destructor called when it should not have been!");
- }
- for (known = &known_capsules[0]; known->module != NULL; known++) {
- /* yeah, ordinarily I wouldn't do this either,
- but it's fine for this test harness.
- */
- static char buffer[256];
- #undef FAIL
- #define FAIL(x) \
- { \
- sprintf(buffer, "%s module: \"%s\" attribute: \"%s\"", \
- x, known->module, known->attribute); \
- error = buffer; \
- goto exit; \
- } \
- PyObject *module = PyImport_ImportModule(known->module);
- if (module) {
- pointer = PyCapsule_Import(known->name, 0);
- if (!pointer) {
- Py_DECREF(module);
- FAIL("PyCapsule_GetPointer returned NULL unexpectedly!");
- }
- object = PyObject_GetAttrString(module, known->attribute);
- if (!object) {
- Py_DECREF(module);
- return NULL;
- }
- pointer2 = PyCapsule_GetPointer(object,
- "weebles wobble but they don't fall down");
- if (!PyErr_Occurred()) {
- Py_DECREF(object);
- Py_DECREF(module);
- FAIL("PyCapsule_GetPointer should have failed but did not!");
- }
- PyErr_Clear();
- if (pointer2) {
- Py_DECREF(module);
- Py_DECREF(object);
- if (pointer2 == pointer) {
- FAIL("PyCapsule_GetPointer should not have"
- " returned its internal pointer!");
- } else {
- FAIL("PyCapsule_GetPointer should have"
- " returned NULL pointer but did not!");
- }
- }
- Py_DECREF(object);
- Py_DECREF(module);
- }
- else
- PyErr_Clear();
- }
- exit:
- if (error) {
- return raiseTestError("test_capsule", error);
- }
- Py_RETURN_NONE;
- #undef FAIL
- }
- /* This is here to provide a docstring for test_descr. */
- static PyObject *
- test_with_docstring(PyObject *self)
- {
- Py_RETURN_NONE;
- }
- /* To test the format of tracebacks as printed out. */
- static PyObject *
- traceback_print(PyObject *self, PyObject *args)
- {
- PyObject *file;
- PyObject *traceback;
- int result;
- if (!PyArg_ParseTuple(args, "OO:traceback_print",
- &traceback, &file))
- return NULL;
- result = PyTraceBack_Print(traceback, file);
- if (result < 0)
- return NULL;
- Py_RETURN_NONE;
- }
- /* To test that the result of PyCode_NewEmpty has the right members. */
- static PyObject *
- code_newempty(PyObject *self, PyObject *args)
- {
- const char *filename;
- const char *funcname;
- int firstlineno;
- if (!PyArg_ParseTuple(args, "ssi:code_newempty",
- &filename, &funcname, &firstlineno))
- return NULL;
- return (PyObject *)PyCode_NewEmpty(filename, funcname, firstlineno);
- }
- /* Test PyErr_NewExceptionWithDoc (also exercise PyErr_NewException).
- Run via Lib/test/test_exceptions.py */
- static PyObject *
- make_exception_with_doc(PyObject *self, PyObject *args, PyObject *kwargs)
- {
- char *name;
- char *doc = NULL;
- PyObject *base = NULL;
- PyObject *dict = NULL;
- static char *kwlist[] = {"name", "doc", "base", "dict", NULL};
- if (!PyArg_ParseTupleAndKeywords(args, kwargs,
- "s|sOO:make_exception_with_doc", kwlist,
- &name, &doc, &base, &dict))
- return NULL;
- return PyErr_NewExceptionWithDoc(name, doc, base, dict);
- }
- static PyMethodDef TestMethods[] = {
- {"raise_exception", raise_exception, METH_VARARGS},
- {"test_config", (PyCFunction)test_config, METH_NOARGS},
- {"test_datetime_capi", test_datetime_capi, METH_NOARGS},
- {"test_list_api", (PyCFunction)test_list_api, METH_NOARGS},
- {"test_dict_iteration", (PyCFunction)test_dict_iteration,METH_NOARGS},
- {"test_lazy_hash_inheritance", (PyCFunction)test_lazy_hash_inheritance,METH_NOARGS},
- {"test_broken_memoryview", (PyCFunction)test_broken_memoryview,METH_NOARGS},
- {"test_long_api", (PyCFunction)test_long_api, METH_NOARGS},
- {"test_long_and_overflow", (PyCFunction)test_long_and_overflow,
- METH_NOARGS},
- {"test_long_numbits", (PyCFunction)test_long_numbits, METH_NOARGS},
- {"test_k_code", (PyCFunction)test_k_code, METH_NOARGS},
- {"test_empty_argparse", (PyCFunction)test_empty_argparse,METH_NOARGS},
- {"test_null_strings", (PyCFunction)test_null_strings, METH_NOARGS},
- {"test_string_from_format", (PyCFunction)test_string_from_format, METH_NOARGS},
- {"test_with_docstring", (PyCFunction)test_with_docstring, METH_NOARGS,
- PyDoc_STR("This is a pretty normal docstring.")},
- {"getargs_tuple", getargs_tuple, METH_VARARGS},
- {"getargs_keywords", (PyCFunction)getargs_keywords,
- METH_VARARGS|METH_KEYWORDS},
- {"getargs_b", getargs_b, METH_VARARGS},
- {"getargs_B", getargs_B, METH_VARARGS},
- {"getargs_h", getargs_h, METH_VARARGS},
- {"getargs_H", getargs_H, METH_VARARGS},
- {"getargs_I", getargs_I, METH_VARARGS},
- {"getargs_k", getargs_k, METH_VARARGS},
- {"getargs_i", getargs_i, METH_VARARGS},
- {"getargs_l", getargs_l, METH_VARARGS},
- {"getargs_n", getargs_n, METH_VARARGS},
- #ifdef HAVE_LONG_LONG
- {"getargs_L", getargs_L, METH_VARARGS},
- {"getargs_K", getargs_K, METH_VARARGS},
- {"test_longlong_api", test_longlong_api, METH_NOARGS},
- {"test_long_long_and_overflow",
- (PyCFunction)test_long_long_and_overflow, METH_NOARGS},
- {"test_L_code", (PyCFunction)test_L_code, METH_NOARGS},
- {"codec_incrementalencoder",
- (PyCFunction)codec_incrementalencoder, METH_VARARGS},
- {"codec_incrementaldecoder",
- (PyCFunction)codec_incrementaldecoder, METH_VARARGS},
- #endif
- #ifdef Py_USING_UNICODE
- {"test_u_code", (PyCFunction)test_u_code, METH_NOARGS},
- {"test_widechar", (PyCFunction)test_widechar, METH_NOARGS},
- #endif
- #ifdef WITH_THREAD
- {"_test_thread_state", test_thread_state, METH_VARARGS},
- {"_pending_threadfunc", pending_threadfunc, METH_VARARGS},
- #endif
- {"test_capsule", (PyCFunction)test_capsule, METH_NOARGS},
- {"traceback_print", traceback_print, METH_VARARGS},
- {"code_newempty", code_newempty, METH_VARARGS},
- {"make_exception_with_doc", (PyCFunction)make_exception_with_doc,
- METH_VARARGS | METH_KEYWORDS},
- {NULL, NULL} /* sentinel */
- };
- #define AddSym(d, n, f, v) {PyObject *o = f(v); PyDict_SetItemString(d, n, o); Py_DECREF(o);}
- typedef struct {
- char bool_member;
- char byte_member;
- unsigned char ubyte_member;
- short short_member;
- unsigned short ushort_member;
- int int_member;
- unsigned int uint_member;
- long long_member;
- unsigned long ulong_member;
- float float_member;
- double double_member;
- char inplace_member[6];
- #ifdef HAVE_LONG_LONG
- PY_LONG_LONG longlong_member;
- unsigned PY_LONG_LONG ulonglong_member;
- #endif
- } all_structmembers;
- typedef struct {
- PyObject_HEAD
- all_structmembers structmembers;
- } test_structmembers;
- static struct PyMemberDef test_members[] = {
- {"T_BOOL", T_BOOL, offsetof(test_structmembers, structmembers.bool_member), 0, NULL},
- {"T_BYTE", T_BYTE, offsetof(test_structmembers, structmembers.byte_member), 0, NULL},
- {"T_UBYTE", T_UBYTE, offsetof(test_structmembers, structmembers.ubyte_member), 0, NULL},
- {"T_SHORT", T_SHORT, offsetof(test_structmembers, structmembers.short_member), 0, NULL},
- {"T_USHORT", T_USHORT, offsetof(test_structmembers, structmembers.ushort_member), 0, NULL},
- {"T_INT", T_INT, offsetof(test_structmembers, structmembers.int_member), 0, NULL},
- {"T_UINT", T_UINT, offsetof(test_structmembers, structmembers.uint_member), 0, NULL},
- {"T_LONG", T_LONG, offsetof(test_structmembers, structmembers.long_member), 0, NULL},
- {"T_ULONG", T_ULONG, offsetof(test_structmembers, structmembers.ulong_member), 0, NULL},
- {"T_FLOAT", T_FLOAT, offsetof(test_structmembers, structmembers.float_member), 0, NULL},
- {"T_DOUBLE", T_DOUBLE, offsetof(test_structmembers, structmembers.double_member), 0, NULL},
- {"T_STRING_INPLACE", T_STRING_INPLACE, offsetof(test_structmembers, structmembers.inplace_member), 0, NULL},
- #ifdef HAVE_LONG_LONG
- {"T_LONGLONG", T_LONGLONG, offsetof(test_structmembers, structmembers.longlong_member), 0, NULL},
- {"T_ULONGLONG", T_ULONGLONG, offsetof(test_structmembers, structmembers.ulonglong_member), 0, NULL},
- #endif
- {NULL}
- };
- static PyObject *
- test_structmembers_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
- {
- static char *keywords[] = {
- "T_BOOL", "T_BYTE", "T_UBYTE", "T_SHORT", "T_USHORT",
- "T_INT", "T_UINT", "T_LONG", "T_ULONG",
- "T_FLOAT", "T_DOUBLE", "T_STRING_INPLACE",
- #ifdef HAVE_LONG_LONG
- "T_LONGLONG", "T_ULONGLONG",
- #endif
- NULL};
- static char *fmt = "|bbBhHiIlkfds#"
- #ifdef HAVE_LONG_LONG
- "LK"
- #endif
- ;
- test_structmembers *ob;
- const char *s = NULL;
- Py_ssize_t string_len = 0;
- ob = PyObject_New(test_structmembers, type);
- if (ob == NULL)
- return NULL;
- memset(&ob->structmembers, 0, sizeof(all_structmembers));
- if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,
- &ob->structmembers.bool_member,
- &ob->structmembers.byte_member,
- &ob->structmembers.ubyte_member,
- &ob->structmembers.short_member,
- &ob->structmembers.ushort_member,
- &ob->structmembers.int_member,
- &ob->structmembers.uint_member,
- &ob->structmembers.long_member,
- &ob->structmembers.ulong_member,
- &ob->structmembers.float_member,
- &ob->structmembers.double_member,
- &s, &string_len
- #ifdef HAVE_LONG_LONG
- , &ob->structmembers.longlong_member,
- &ob->structmembers.ulonglong_member
- #endif
- )) {
- Py_DECREF(ob);
- return NULL;
- }
- if (s != NULL) {
- if (string_len > 5) {
- Py_DECREF(ob);
- PyErr_SetString(PyExc_ValueError, "string too long");
- return NULL;
- }
- strcpy(ob->structmembers.inplace_member, s);
- }
- else {
- strcpy(ob->structmembers.inplace_member, "");
- }
- return (PyObject *)ob;
- }
- static void
- test_structmembers_free(PyObject *ob)
- {
- PyObject_FREE(ob);
- }
- static PyTypeObject test_structmembersType = {
- PyVarObject_HEAD_INIT(NULL, 0)
- "test_structmembersType",
- sizeof(test_structmembers), /* tp_basicsize */
- 0, /* tp_itemsize */
- test_structmembers_free, /* destructor 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 */
- PyObject_GenericSetAttr, /* tp_setattro */
- 0, /* tp_as_buffer */
- 0, /* tp_flags */
- "Type containing all structmember types",
- 0, /* traverseproc tp_traverse */
- 0, /* tp_clear */
- 0, /* tp_richcompare */
- 0, /* tp_weaklistoffset */
- 0, /* tp_iter */
- 0, /* tp_iternext */
- 0, /* tp_methods */
- test_members, /* tp_members */
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
- 0,
- test_structmembers_new, /* tp_new */
- };
- PyMODINIT_FUNC
- init_testcapi(void)
- {
- PyObject *m;
- m = Py_InitModule("_testcapi", TestMethods);
- if (m == NULL)
- return;
- Py_TYPE(&_HashInheritanceTester_Type)=&PyType_Type;
- Py_TYPE(&test_structmembersType)=&PyType_Type;
- Py_INCREF(&test_structmembersType);
- /* don't use a name starting with "test", since we don't want
- test_capi to automatically call this */
- PyModule_AddObject(m, "_test_structmembersType", (PyObject *)&test_structmembersType);
- PyModule_AddObject(m, "CHAR_MAX", PyInt_FromLong(CHAR_MAX));
- PyModule_AddObject(m, "CHAR_MIN", PyInt_FromLong(CHAR_MIN));
- PyModule_AddObject(m, "UCHAR_MAX", PyInt_FromLong(UCHAR_MAX));
- PyModule_AddObject(m, "SHRT_MAX", PyInt_FromLong(SHRT_MAX));
- PyModule_AddObject(m, "SHRT_MIN", PyInt_FromLong(SHRT_MIN));
- PyModule_AddObject(m, "USHRT_MAX", PyInt_FromLong(USHRT_MAX));
- PyModule_AddObject(m, "INT_MAX", PyLong_FromLong(INT_MAX));
- PyModule_AddObject(m, "INT_MIN", PyLong_FromLong(INT_MIN));
- PyModule_AddObject(m, "UINT_MAX", PyLong_FromUnsignedLong(UINT_MAX));
- PyModule_AddObject(m, "LONG_MAX", PyInt_FromLong(LONG_MAX));
- PyModule_AddObject(m, "LONG_MIN", PyInt_FromLong(LONG_MIN));
- PyModule_AddObject(m, "ULONG_MAX", PyLong_FromUnsignedLong(ULONG_MAX));
- PyModule_AddObject(m, "FLT_MAX", PyFloat_FromDouble(FLT_MAX));
- PyModule_AddObject(m, "FLT_MIN", PyFloat_FromDouble(FLT_MIN));
- PyModule_AddObject(m, "DBL_MAX", PyFloat_FromDouble(DBL_MAX));
- PyModule_AddObject(m, "DBL_MIN", PyFloat_FromDouble(DBL_MIN));
- PyModule_AddObject(m, "LLONG_MAX", PyLong_FromLongLong(PY_LLONG_MAX));
- PyModule_AddObject(m, "LLONG_MIN", PyLong_FromLongLong(PY_LLONG_MIN));
- PyModule_AddObject(m, "ULLONG_MAX", PyLong_FromUnsignedLongLong(PY_ULLONG_MAX));
- PyModule_AddObject(m, "PY_SSIZE_T_MAX", PyInt_FromSsize_t(PY_SSIZE_T_MAX));
- PyModule_AddObject(m, "PY_SSIZE_T_MIN", PyInt_FromSsize_t(PY_SSIZE_T_MIN));
- PyModule_AddObject(m, "SIZEOF_PYGC_HEAD", PyInt_FromSsize_t(sizeof(PyGC_Head)));
- TestError = PyErr_NewException("_testcapi.error", NULL, NULL);
- Py_INCREF(TestError);
- PyModule_AddObject(m, "error", TestError);
- }