+++ /dev/null
-/*\r
- * C Extension module to test Python interpreter C APIs.\r
- *\r
- * The 'test_*' functions exported by this module are run as part of the\r
- * standard Python regression test, via Lib/test/test_capi.py.\r
- */\r
-\r
-#include "Python.h"\r
-#include <float.h>\r
-#include "structmember.h"\r
-#include "datetime.h"\r
-\r
-#ifdef WITH_THREAD\r
-#include "pythread.h"\r
-#endif /* WITH_THREAD */\r
-static PyObject *TestError; /* set to exception object in init */\r
-\r
-/* Raise TestError with test_name + ": " + msg, and return NULL. */\r
-\r
-static PyObject *\r
-raiseTestError(const char* test_name, const char* msg)\r
-{\r
- char buf[2048];\r
-\r
- if (strlen(test_name) + strlen(msg) > sizeof(buf) - 50)\r
- PyErr_SetString(TestError, "internal error msg too large");\r
- else {\r
- PyOS_snprintf(buf, sizeof(buf), "%s: %s", test_name, msg);\r
- PyErr_SetString(TestError, buf);\r
- }\r
- return NULL;\r
-}\r
-\r
-/* Test #defines from pyconfig.h (particularly the SIZEOF_* defines).\r
-\r
- The ones derived from autoconf on the UNIX-like OSes can be relied\r
- upon (in the absence of sloppy cross-compiling), but the Windows\r
- platforms have these hardcoded. Better safe than sorry.\r
-*/\r
-static PyObject*\r
-sizeof_error(const char* fatname, const char* typname,\r
- int expected, int got)\r
-{\r
- char buf[1024];\r
- PyOS_snprintf(buf, sizeof(buf),\r
- "%.200s #define == %d but sizeof(%.200s) == %d",\r
- fatname, expected, typname, got);\r
- PyErr_SetString(TestError, buf);\r
- return (PyObject*)NULL;\r
-}\r
-\r
-static PyObject*\r
-test_config(PyObject *self)\r
-{\r
-#define CHECK_SIZEOF(FATNAME, TYPE) \\r
- if (FATNAME != sizeof(TYPE)) \\r
- return sizeof_error(#FATNAME, #TYPE, FATNAME, sizeof(TYPE))\r
-\r
- CHECK_SIZEOF(SIZEOF_SHORT, short);\r
- CHECK_SIZEOF(SIZEOF_INT, int);\r
- CHECK_SIZEOF(SIZEOF_LONG, long);\r
- CHECK_SIZEOF(SIZEOF_VOID_P, void*);\r
- CHECK_SIZEOF(SIZEOF_TIME_T, time_t);\r
-#ifdef HAVE_LONG_LONG\r
- CHECK_SIZEOF(SIZEOF_LONG_LONG, PY_LONG_LONG);\r
-#endif\r
-\r
-#undef CHECK_SIZEOF\r
-\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-static PyObject*\r
-test_list_api(PyObject *self)\r
-{\r
- PyObject* list;\r
- int i;\r
-\r
- /* SF bug 132008: PyList_Reverse segfaults */\r
-#define NLIST 30\r
- list = PyList_New(NLIST);\r
- if (list == (PyObject*)NULL)\r
- return (PyObject*)NULL;\r
- /* list = range(NLIST) */\r
- for (i = 0; i < NLIST; ++i) {\r
- PyObject* anint = PyInt_FromLong(i);\r
- if (anint == (PyObject*)NULL) {\r
- Py_DECREF(list);\r
- return (PyObject*)NULL;\r
- }\r
- PyList_SET_ITEM(list, i, anint);\r
- }\r
- /* list.reverse(), via PyList_Reverse() */\r
- i = PyList_Reverse(list); /* should not blow up! */\r
- if (i != 0) {\r
- Py_DECREF(list);\r
- return (PyObject*)NULL;\r
- }\r
- /* Check that list == range(29, -1, -1) now */\r
- for (i = 0; i < NLIST; ++i) {\r
- PyObject* anint = PyList_GET_ITEM(list, i);\r
- if (PyInt_AS_LONG(anint) != NLIST-1-i) {\r
- PyErr_SetString(TestError,\r
- "test_list_api: reverse screwed up");\r
- Py_DECREF(list);\r
- return (PyObject*)NULL;\r
- }\r
- }\r
- Py_DECREF(list);\r
-#undef NLIST\r
-\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-static int\r
-test_dict_inner(int count)\r
-{\r
- Py_ssize_t pos = 0, iterations = 0;\r
- int i;\r
- PyObject *dict = PyDict_New();\r
- PyObject *v, *k;\r
-\r
- if (dict == NULL)\r
- return -1;\r
-\r
- for (i = 0; i < count; i++) {\r
- v = PyInt_FromLong(i);\r
- PyDict_SetItem(dict, v, v);\r
- Py_DECREF(v);\r
- }\r
-\r
- while (PyDict_Next(dict, &pos, &k, &v)) {\r
- PyObject *o;\r
- iterations++;\r
-\r
- i = PyInt_AS_LONG(v) + 1;\r
- o = PyInt_FromLong(i);\r
- if (o == NULL)\r
- return -1;\r
- if (PyDict_SetItem(dict, k, o) < 0) {\r
- Py_DECREF(o);\r
- return -1;\r
- }\r
- Py_DECREF(o);\r
- }\r
-\r
- Py_DECREF(dict);\r
-\r
- if (iterations != count) {\r
- PyErr_SetString(\r
- TestError,\r
- "test_dict_iteration: dict iteration went wrong ");\r
- return -1;\r
- } else {\r
- return 0;\r
- }\r
-}\r
-\r
-static PyObject*\r
-test_dict_iteration(PyObject* self)\r
-{\r
- int i;\r
-\r
- for (i = 0; i < 200; i++) {\r
- if (test_dict_inner(i) < 0) {\r
- return NULL;\r
- }\r
- }\r
-\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-\r
-/* Issue #4701: Check that PyObject_Hash implicitly calls\r
- * PyType_Ready if it hasn't already been called\r
- */\r
-static PyTypeObject _HashInheritanceTester_Type = {\r
- PyObject_HEAD_INIT(NULL)\r
- 0, /* Number of items for varobject */\r
- "hashinheritancetester", /* Name of this type */\r
- sizeof(PyObject), /* Basic object size */\r
- 0, /* Item size for varobject */\r
- (destructor)PyObject_Del, /* tp_dealloc */\r
- 0, /* tp_print */\r
- 0, /* tp_getattr */\r
- 0, /* tp_setattr */\r
- 0, /* tp_compare */\r
- 0, /* tp_repr */\r
- 0, /* tp_as_number */\r
- 0, /* tp_as_sequence */\r
- 0, /* tp_as_mapping */\r
- 0, /* tp_hash */\r
- 0, /* tp_call */\r
- 0, /* tp_str */\r
- PyObject_GenericGetAttr, /* tp_getattro */\r
- 0, /* tp_setattro */\r
- 0, /* tp_as_buffer */\r
- Py_TPFLAGS_DEFAULT, /* tp_flags */\r
- 0, /* tp_doc */\r
- 0, /* tp_traverse */\r
- 0, /* tp_clear */\r
- 0, /* tp_richcompare */\r
- 0, /* tp_weaklistoffset */\r
- 0, /* tp_iter */\r
- 0, /* tp_iternext */\r
- 0, /* tp_methods */\r
- 0, /* tp_members */\r
- 0, /* tp_getset */\r
- 0, /* tp_base */\r
- 0, /* tp_dict */\r
- 0, /* tp_descr_get */\r
- 0, /* tp_descr_set */\r
- 0, /* tp_dictoffset */\r
- 0, /* tp_init */\r
- 0, /* tp_alloc */\r
- PyType_GenericNew, /* tp_new */\r
-};\r
-\r
-static PyObject*\r
-test_lazy_hash_inheritance(PyObject* self)\r
-{\r
- PyTypeObject *type;\r
- PyObject *obj;\r
- long hash;\r
-\r
- type = &_HashInheritanceTester_Type;\r
-\r
- if (type->tp_dict != NULL)\r
- /* The type has already been initialized. This probably means\r
- -R is being used. */\r
- Py_RETURN_NONE;\r
-\r
-\r
- obj = PyObject_New(PyObject, type);\r
- if (obj == NULL) {\r
- PyErr_Clear();\r
- PyErr_SetString(\r
- TestError,\r
- "test_lazy_hash_inheritance: failed to create object");\r
- return NULL;\r
- }\r
-\r
- if (type->tp_dict != NULL) {\r
- PyErr_SetString(\r
- TestError,\r
- "test_lazy_hash_inheritance: type initialised too soon");\r
- Py_DECREF(obj);\r
- return NULL;\r
- }\r
-\r
- hash = PyObject_Hash(obj);\r
- if ((hash == -1) && PyErr_Occurred()) {\r
- PyErr_Clear();\r
- PyErr_SetString(\r
- TestError,\r
- "test_lazy_hash_inheritance: could not hash object");\r
- Py_DECREF(obj);\r
- return NULL;\r
- }\r
-\r
- if (type->tp_dict == NULL) {\r
- PyErr_SetString(\r
- TestError,\r
- "test_lazy_hash_inheritance: type not initialised by hash()");\r
- Py_DECREF(obj);\r
- return NULL;\r
- }\r
-\r
- if (type->tp_hash != PyType_Type.tp_hash) {\r
- PyErr_SetString(\r
- TestError,\r
- "test_lazy_hash_inheritance: unexpected hash function");\r
- Py_DECREF(obj);\r
- return NULL;\r
- }\r
-\r
- Py_DECREF(obj);\r
-\r
- Py_RETURN_NONE;\r
-}\r
-\r
-\r
-/* Issue #7385: Check that memoryview() does not crash\r
- * when bf_getbuffer returns an error\r
- */\r
-\r
-static int\r
-broken_buffer_getbuffer(PyObject *self, Py_buffer *view, int flags)\r
-{\r
- PyErr_SetString(\r
- TestError,\r
- "test_broken_memoryview: expected error in bf_getbuffer");\r
- return -1;\r
-}\r
-\r
-static PyBufferProcs memoryviewtester_as_buffer = {\r
- 0, /* bf_getreadbuffer */\r
- 0, /* bf_getwritebuffer */\r
- 0, /* bf_getsegcount */\r
- 0, /* bf_getcharbuffer */\r
- (getbufferproc)broken_buffer_getbuffer, /* bf_getbuffer */\r
- 0, /* bf_releasebuffer */\r
-};\r
-\r
-static PyTypeObject _MemoryViewTester_Type = {\r
- PyObject_HEAD_INIT(NULL)\r
- 0, /* Number of items for varobject */\r
- "memoryviewtester", /* Name of this type */\r
- sizeof(PyObject), /* Basic object size */\r
- 0, /* Item size for varobject */\r
- (destructor)PyObject_Del, /* tp_dealloc */\r
- 0, /* tp_print */\r
- 0, /* tp_getattr */\r
- 0, /* tp_setattr */\r
- 0, /* tp_compare */\r
- 0, /* tp_repr */\r
- 0, /* tp_as_number */\r
- 0, /* tp_as_sequence */\r
- 0, /* tp_as_mapping */\r
- 0, /* tp_hash */\r
- 0, /* tp_call */\r
- 0, /* tp_str */\r
- PyObject_GenericGetAttr, /* tp_getattro */\r
- 0, /* tp_setattro */\r
- &memoryviewtester_as_buffer, /* tp_as_buffer */\r
- Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_NEWBUFFER, /* tp_flags */\r
- 0, /* tp_doc */\r
- 0, /* tp_traverse */\r
- 0, /* tp_clear */\r
- 0, /* tp_richcompare */\r
- 0, /* tp_weaklistoffset */\r
- 0, /* tp_iter */\r
- 0, /* tp_iternext */\r
- 0, /* tp_methods */\r
- 0, /* tp_members */\r
- 0, /* tp_getset */\r
- 0, /* tp_base */\r
- 0, /* tp_dict */\r
- 0, /* tp_descr_get */\r
- 0, /* tp_descr_set */\r
- 0, /* tp_dictoffset */\r
- 0, /* tp_init */\r
- 0, /* tp_alloc */\r
- PyType_GenericNew, /* tp_new */\r
-};\r
-\r
-static PyObject*\r
-test_broken_memoryview(PyObject* self)\r
-{\r
- PyObject *obj = PyObject_New(PyObject, &_MemoryViewTester_Type);\r
- PyObject *res;\r
-\r
- if (obj == NULL) {\r
- PyErr_Clear();\r
- PyErr_SetString(\r
- TestError,\r
- "test_broken_memoryview: failed to create object");\r
- return NULL;\r
- }\r
-\r
- res = PyMemoryView_FromObject(obj);\r
- if (res || !PyErr_Occurred()){\r
- PyErr_SetString(\r
- TestError,\r
- "test_broken_memoryview: memoryview() didn't raise an Exception");\r
- Py_XDECREF(res);\r
- Py_DECREF(obj);\r
- return NULL;\r
- }\r
-\r
- PyErr_Clear();\r
- Py_DECREF(obj);\r
- Py_RETURN_NONE;\r
-}\r
-\r
-\r
-/* Tests of PyLong_{As, From}{Unsigned,}Long(), and (#ifdef HAVE_LONG_LONG)\r
- PyLong_{As, From}{Unsigned,}LongLong().\r
-\r
- Note that the meat of the test is contained in testcapi_long.h.\r
- This is revolting, but delicate code duplication is worse: "almost\r
- exactly the same" code is needed to test PY_LONG_LONG, but the ubiquitous\r
- dependence on type names makes it impossible to use a parameterized\r
- function. A giant macro would be even worse than this. A C++ template\r
- would be perfect.\r
-\r
- The "report an error" functions are deliberately not part of the #include\r
- file: if the test fails, you can set a breakpoint in the appropriate\r
- error function directly, and crawl back from there in the debugger.\r
-*/\r
-\r
-#define UNBIND(X) Py_DECREF(X); (X) = NULL\r
-\r
-static PyObject *\r
-raise_test_long_error(const char* msg)\r
-{\r
- return raiseTestError("test_long_api", msg);\r
-}\r
-\r
-#define TESTNAME test_long_api_inner\r
-#define TYPENAME long\r
-#define F_S_TO_PY PyLong_FromLong\r
-#define F_PY_TO_S PyLong_AsLong\r
-#define F_U_TO_PY PyLong_FromUnsignedLong\r
-#define F_PY_TO_U PyLong_AsUnsignedLong\r
-\r
-#include "testcapi_long.h"\r
-\r
-static PyObject *\r
-test_long_api(PyObject* self)\r
-{\r
- return TESTNAME(raise_test_long_error);\r
-}\r
-\r
-#undef TESTNAME\r
-#undef TYPENAME\r
-#undef F_S_TO_PY\r
-#undef F_PY_TO_S\r
-#undef F_U_TO_PY\r
-#undef F_PY_TO_U\r
-\r
-#ifdef HAVE_LONG_LONG\r
-\r
-static PyObject *\r
-raise_test_longlong_error(const char* msg)\r
-{\r
- return raiseTestError("test_longlong_api", msg);\r
-}\r
-\r
-#define TESTNAME test_longlong_api_inner\r
-#define TYPENAME PY_LONG_LONG\r
-#define F_S_TO_PY PyLong_FromLongLong\r
-#define F_PY_TO_S PyLong_AsLongLong\r
-#define F_U_TO_PY PyLong_FromUnsignedLongLong\r
-#define F_PY_TO_U PyLong_AsUnsignedLongLong\r
-\r
-#include "testcapi_long.h"\r
-\r
-static PyObject *\r
-test_longlong_api(PyObject* self, PyObject *args)\r
-{\r
- return TESTNAME(raise_test_longlong_error);\r
-}\r
-\r
-#undef TESTNAME\r
-#undef TYPENAME\r
-#undef F_S_TO_PY\r
-#undef F_PY_TO_S\r
-#undef F_U_TO_PY\r
-#undef F_PY_TO_U\r
-\r
-/* Test the PyLong_AsLongAndOverflow API. General conversion to PY_LONG\r
- is tested by test_long_api_inner. This test will concentrate on proper\r
- handling of overflow.\r
-*/\r
-\r
-static PyObject *\r
-test_long_and_overflow(PyObject *self)\r
-{\r
- PyObject *num, *one, *temp;\r
- long value;\r
- int overflow;\r
-\r
- /* Test that overflow is set properly for a large value. */\r
- /* num is a number larger than LONG_MAX even on 64-bit platforms */\r
- num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);\r
- if (num == NULL)\r
- return NULL;\r
- overflow = 1234;\r
- value = PyLong_AsLongAndOverflow(num, &overflow);\r
- Py_DECREF(num);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (value != -1)\r
- return raiseTestError("test_long_and_overflow",\r
- "return value was not set to -1");\r
- if (overflow != 1)\r
- return raiseTestError("test_long_and_overflow",\r
- "overflow was not set to 1");\r
-\r
- /* Same again, with num = LONG_MAX + 1 */\r
- num = PyLong_FromLong(LONG_MAX);\r
- if (num == NULL)\r
- return NULL;\r
- one = PyLong_FromLong(1L);\r
- if (one == NULL) {\r
- Py_DECREF(num);\r
- return NULL;\r
- }\r
- temp = PyNumber_Add(num, one);\r
- Py_DECREF(one);\r
- Py_DECREF(num);\r
- num = temp;\r
- if (num == NULL)\r
- return NULL;\r
- overflow = 0;\r
- value = PyLong_AsLongAndOverflow(num, &overflow);\r
- Py_DECREF(num);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (value != -1)\r
- return raiseTestError("test_long_and_overflow",\r
- "return value was not set to -1");\r
- if (overflow != 1)\r
- return raiseTestError("test_long_and_overflow",\r
- "overflow was not set to 1");\r
-\r
- /* Test that overflow is set properly for a large negative value. */\r
- /* num is a number smaller than LONG_MIN even on 64-bit platforms */\r
- num = PyLong_FromString("-FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);\r
- if (num == NULL)\r
- return NULL;\r
- overflow = 1234;\r
- value = PyLong_AsLongAndOverflow(num, &overflow);\r
- Py_DECREF(num);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (value != -1)\r
- return raiseTestError("test_long_and_overflow",\r
- "return value was not set to -1");\r
- if (overflow != -1)\r
- return raiseTestError("test_long_and_overflow",\r
- "overflow was not set to -1");\r
-\r
- /* Same again, with num = LONG_MIN - 1 */\r
- num = PyLong_FromLong(LONG_MIN);\r
- if (num == NULL)\r
- return NULL;\r
- one = PyLong_FromLong(1L);\r
- if (one == NULL) {\r
- Py_DECREF(num);\r
- return NULL;\r
- }\r
- temp = PyNumber_Subtract(num, one);\r
- Py_DECREF(one);\r
- Py_DECREF(num);\r
- num = temp;\r
- if (num == NULL)\r
- return NULL;\r
- overflow = 0;\r
- value = PyLong_AsLongAndOverflow(num, &overflow);\r
- Py_DECREF(num);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (value != -1)\r
- return raiseTestError("test_long_and_overflow",\r
- "return value was not set to -1");\r
- if (overflow != -1)\r
- return raiseTestError("test_long_and_overflow",\r
- "overflow was not set to -1");\r
-\r
- /* Test that overflow is cleared properly for small values. */\r
- num = PyLong_FromString("FF", NULL, 16);\r
- if (num == NULL)\r
- return NULL;\r
- overflow = 1234;\r
- value = PyLong_AsLongAndOverflow(num, &overflow);\r
- Py_DECREF(num);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (value != 0xFF)\r
- return raiseTestError("test_long_and_overflow",\r
- "expected return value 0xFF");\r
- if (overflow != 0)\r
- return raiseTestError("test_long_and_overflow",\r
- "overflow was not cleared");\r
-\r
- num = PyLong_FromString("-FF", NULL, 16);\r
- if (num == NULL)\r
- return NULL;\r
- overflow = 0;\r
- value = PyLong_AsLongAndOverflow(num, &overflow);\r
- Py_DECREF(num);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (value != -0xFF)\r
- return raiseTestError("test_long_and_overflow",\r
- "expected return value 0xFF");\r
- if (overflow != 0)\r
- return raiseTestError("test_long_and_overflow",\r
- "overflow was set incorrectly");\r
-\r
- num = PyLong_FromLong(LONG_MAX);\r
- if (num == NULL)\r
- return NULL;\r
- overflow = 1234;\r
- value = PyLong_AsLongAndOverflow(num, &overflow);\r
- Py_DECREF(num);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (value != LONG_MAX)\r
- return raiseTestError("test_long_and_overflow",\r
- "expected return value LONG_MAX");\r
- if (overflow != 0)\r
- return raiseTestError("test_long_and_overflow",\r
- "overflow was not cleared");\r
-\r
- num = PyLong_FromLong(LONG_MIN);\r
- if (num == NULL)\r
- return NULL;\r
- overflow = 0;\r
- value = PyLong_AsLongAndOverflow(num, &overflow);\r
- Py_DECREF(num);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (value != LONG_MIN)\r
- return raiseTestError("test_long_and_overflow",\r
- "expected return value LONG_MIN");\r
- if (overflow != 0)\r
- return raiseTestError("test_long_and_overflow",\r
- "overflow was not cleared");\r
-\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-/* Test the PyLong_AsLongLongAndOverflow API. General conversion to\r
- PY_LONG_LONG is tested by test_long_api_inner. This test will\r
- concentrate on proper handling of overflow.\r
-*/\r
-\r
-static PyObject *\r
-test_long_long_and_overflow(PyObject *self)\r
-{\r
- PyObject *num, *one, *temp;\r
- PY_LONG_LONG value;\r
- int overflow;\r
-\r
- /* Test that overflow is set properly for a large value. */\r
- /* num is a number larger than PY_LLONG_MAX on a typical machine. */\r
- num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);\r
- if (num == NULL)\r
- return NULL;\r
- overflow = 1234;\r
- value = PyLong_AsLongLongAndOverflow(num, &overflow);\r
- Py_DECREF(num);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (value != -1)\r
- return raiseTestError("test_long_long_and_overflow",\r
- "return value was not set to -1");\r
- if (overflow != 1)\r
- return raiseTestError("test_long_long_and_overflow",\r
- "overflow was not set to 1");\r
-\r
- /* Same again, with num = PY_LLONG_MAX + 1 */\r
- num = PyLong_FromLongLong(PY_LLONG_MAX);\r
- if (num == NULL)\r
- return NULL;\r
- one = PyLong_FromLong(1L);\r
- if (one == NULL) {\r
- Py_DECREF(num);\r
- return NULL;\r
- }\r
- temp = PyNumber_Add(num, one);\r
- Py_DECREF(one);\r
- Py_DECREF(num);\r
- num = temp;\r
- if (num == NULL)\r
- return NULL;\r
- overflow = 0;\r
- value = PyLong_AsLongLongAndOverflow(num, &overflow);\r
- Py_DECREF(num);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (value != -1)\r
- return raiseTestError("test_long_long_and_overflow",\r
- "return value was not set to -1");\r
- if (overflow != 1)\r
- return raiseTestError("test_long_long_and_overflow",\r
- "overflow was not set to 1");\r
-\r
- /* Test that overflow is set properly for a large negative value. */\r
- /* num is a number smaller than PY_LLONG_MIN on a typical platform */\r
- num = PyLong_FromString("-FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);\r
- if (num == NULL)\r
- return NULL;\r
- overflow = 1234;\r
- value = PyLong_AsLongLongAndOverflow(num, &overflow);\r
- Py_DECREF(num);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (value != -1)\r
- return raiseTestError("test_long_long_and_overflow",\r
- "return value was not set to -1");\r
- if (overflow != -1)\r
- return raiseTestError("test_long_long_and_overflow",\r
- "overflow was not set to -1");\r
-\r
- /* Same again, with num = PY_LLONG_MIN - 1 */\r
- num = PyLong_FromLongLong(PY_LLONG_MIN);\r
- if (num == NULL)\r
- return NULL;\r
- one = PyLong_FromLong(1L);\r
- if (one == NULL) {\r
- Py_DECREF(num);\r
- return NULL;\r
- }\r
- temp = PyNumber_Subtract(num, one);\r
- Py_DECREF(one);\r
- Py_DECREF(num);\r
- num = temp;\r
- if (num == NULL)\r
- return NULL;\r
- overflow = 0;\r
- value = PyLong_AsLongLongAndOverflow(num, &overflow);\r
- Py_DECREF(num);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (value != -1)\r
- return raiseTestError("test_long_long_and_overflow",\r
- "return value was not set to -1");\r
- if (overflow != -1)\r
- return raiseTestError("test_long_long_and_overflow",\r
- "overflow was not set to -1");\r
-\r
- /* Test that overflow is cleared properly for small values. */\r
- num = PyLong_FromString("FF", NULL, 16);\r
- if (num == NULL)\r
- return NULL;\r
- overflow = 1234;\r
- value = PyLong_AsLongLongAndOverflow(num, &overflow);\r
- Py_DECREF(num);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (value != 0xFF)\r
- return raiseTestError("test_long_long_and_overflow",\r
- "expected return value 0xFF");\r
- if (overflow != 0)\r
- return raiseTestError("test_long_long_and_overflow",\r
- "overflow was not cleared");\r
-\r
- num = PyLong_FromString("-FF", NULL, 16);\r
- if (num == NULL)\r
- return NULL;\r
- overflow = 0;\r
- value = PyLong_AsLongLongAndOverflow(num, &overflow);\r
- Py_DECREF(num);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (value != -0xFF)\r
- return raiseTestError("test_long_long_and_overflow",\r
- "expected return value 0xFF");\r
- if (overflow != 0)\r
- return raiseTestError("test_long_long_and_overflow",\r
- "overflow was set incorrectly");\r
-\r
- num = PyLong_FromLongLong(PY_LLONG_MAX);\r
- if (num == NULL)\r
- return NULL;\r
- overflow = 1234;\r
- value = PyLong_AsLongLongAndOverflow(num, &overflow);\r
- Py_DECREF(num);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (value != PY_LLONG_MAX)\r
- return raiseTestError("test_long_long_and_overflow",\r
- "expected return value PY_LLONG_MAX");\r
- if (overflow != 0)\r
- return raiseTestError("test_long_long_and_overflow",\r
- "overflow was not cleared");\r
-\r
- num = PyLong_FromLongLong(PY_LLONG_MIN);\r
- if (num == NULL)\r
- return NULL;\r
- overflow = 0;\r
- value = PyLong_AsLongLongAndOverflow(num, &overflow);\r
- Py_DECREF(num);\r
- if (value == -1 && PyErr_Occurred())\r
- return NULL;\r
- if (value != PY_LLONG_MIN)\r
- return raiseTestError("test_long_long_and_overflow",\r
- "expected return value PY_LLONG_MIN");\r
- if (overflow != 0)\r
- return raiseTestError("test_long_long_and_overflow",\r
- "overflow was not cleared");\r
-\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-/* Test the L code for PyArg_ParseTuple. This should deliver a PY_LONG_LONG\r
- for both long and int arguments. The test may leak a little memory if\r
- it fails.\r
-*/\r
-static PyObject *\r
-test_L_code(PyObject *self)\r
-{\r
- PyObject *tuple, *num;\r
- PY_LONG_LONG value;\r
-\r
- tuple = PyTuple_New(1);\r
- if (tuple == NULL)\r
- return NULL;\r
-\r
- num = PyLong_FromLong(42);\r
- if (num == NULL)\r
- return NULL;\r
-\r
- PyTuple_SET_ITEM(tuple, 0, num);\r
-\r
- value = -1;\r
- if (PyArg_ParseTuple(tuple, "L:test_L_code", &value) < 0)\r
- return NULL;\r
- if (value != 42)\r
- return raiseTestError("test_L_code",\r
- "L code returned wrong value for long 42");\r
-\r
- Py_DECREF(num);\r
- num = PyInt_FromLong(42);\r
- if (num == NULL)\r
- return NULL;\r
-\r
- PyTuple_SET_ITEM(tuple, 0, num);\r
-\r
- value = -1;\r
- if (PyArg_ParseTuple(tuple, "L:test_L_code", &value) < 0)\r
- return NULL;\r
- if (value != 42)\r
- return raiseTestError("test_L_code",\r
- "L code returned wrong value for int 42");\r
-\r
- Py_DECREF(tuple);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-#endif /* ifdef HAVE_LONG_LONG */\r
-\r
-/* Test tuple argument processing */\r
-static PyObject *\r
-getargs_tuple(PyObject *self, PyObject *args)\r
-{\r
- int a, b, c;\r
- if (!PyArg_ParseTuple(args, "i(ii)", &a, &b, &c))\r
- return NULL;\r
- return Py_BuildValue("iii", a, b, c);\r
-}\r
-\r
-/* test PyArg_ParseTupleAndKeywords */\r
-static PyObject *getargs_keywords(PyObject *self, PyObject *args, PyObject *kwargs)\r
-{\r
- static char *keywords[] = {"arg1","arg2","arg3","arg4","arg5", NULL};\r
- static char *fmt="(ii)i|(i(ii))(iii)i";\r
- int int_args[10]={-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};\r
-\r
- if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,\r
- &int_args[0], &int_args[1], &int_args[2], &int_args[3], &int_args[4],\r
- &int_args[5], &int_args[6], &int_args[7], &int_args[8], &int_args[9]))\r
- return NULL;\r
- return Py_BuildValue("iiiiiiiiii",\r
- int_args[0], int_args[1], int_args[2], int_args[3], int_args[4],\r
- int_args[5], int_args[6], int_args[7], int_args[8], int_args[9]);\r
-}\r
-\r
-/* Functions to call PyArg_ParseTuple with integer format codes,\r
- and return the result.\r
-*/\r
-static PyObject *\r
-getargs_b(PyObject *self, PyObject *args)\r
-{\r
- unsigned char value;\r
- if (!PyArg_ParseTuple(args, "b", &value))\r
- return NULL;\r
- return PyLong_FromUnsignedLong((unsigned long)value);\r
-}\r
-\r
-static PyObject *\r
-getargs_B(PyObject *self, PyObject *args)\r
-{\r
- unsigned char value;\r
- if (!PyArg_ParseTuple(args, "B", &value))\r
- return NULL;\r
- return PyLong_FromUnsignedLong((unsigned long)value);\r
-}\r
-\r
-static PyObject *\r
-getargs_h(PyObject *self, PyObject *args)\r
-{\r
- short value;\r
- if (!PyArg_ParseTuple(args, "h", &value))\r
- return NULL;\r
- return PyLong_FromLong((long)value);\r
-}\r
-\r
-static PyObject *\r
-getargs_H(PyObject *self, PyObject *args)\r
-{\r
- unsigned short value;\r
- if (!PyArg_ParseTuple(args, "H", &value))\r
- return NULL;\r
- return PyLong_FromUnsignedLong((unsigned long)value);\r
-}\r
-\r
-static PyObject *\r
-getargs_I(PyObject *self, PyObject *args)\r
-{\r
- unsigned int value;\r
- if (!PyArg_ParseTuple(args, "I", &value))\r
- return NULL;\r
- return PyLong_FromUnsignedLong((unsigned long)value);\r
-}\r
-\r
-static PyObject *\r
-getargs_k(PyObject *self, PyObject *args)\r
-{\r
- unsigned long value;\r
- if (!PyArg_ParseTuple(args, "k", &value))\r
- return NULL;\r
- return PyLong_FromUnsignedLong(value);\r
-}\r
-\r
-static PyObject *\r
-getargs_i(PyObject *self, PyObject *args)\r
-{\r
- int value;\r
- if (!PyArg_ParseTuple(args, "i", &value))\r
- return NULL;\r
- return PyLong_FromLong((long)value);\r
-}\r
-\r
-static PyObject *\r
-getargs_l(PyObject *self, PyObject *args)\r
-{\r
- long value;\r
- if (!PyArg_ParseTuple(args, "l", &value))\r
- return NULL;\r
- return PyLong_FromLong(value);\r
-}\r
-\r
-static PyObject *\r
-getargs_n(PyObject *self, PyObject *args)\r
-{\r
- Py_ssize_t value;\r
- if (!PyArg_ParseTuple(args, "n", &value))\r
- return NULL;\r
- return PyInt_FromSsize_t(value);\r
-}\r
-\r
-#ifdef HAVE_LONG_LONG\r
-static PyObject *\r
-getargs_L(PyObject *self, PyObject *args)\r
-{\r
- PY_LONG_LONG value;\r
- if (!PyArg_ParseTuple(args, "L", &value))\r
- return NULL;\r
- return PyLong_FromLongLong(value);\r
-}\r
-\r
-static PyObject *\r
-getargs_K(PyObject *self, PyObject *args)\r
-{\r
- unsigned PY_LONG_LONG value;\r
- if (!PyArg_ParseTuple(args, "K", &value))\r
- return NULL;\r
- return PyLong_FromUnsignedLongLong(value);\r
-}\r
-#endif\r
-\r
-/* This function not only tests the 'k' getargs code, but also the\r
- PyInt_AsUnsignedLongMask() and PyInt_AsUnsignedLongMask() functions. */\r
-static PyObject *\r
-test_k_code(PyObject *self)\r
-{\r
- PyObject *tuple, *num;\r
- unsigned long value;\r
-\r
- tuple = PyTuple_New(1);\r
- if (tuple == NULL)\r
- return NULL;\r
-\r
- /* a number larger than ULONG_MAX even on 64-bit platforms */\r
- num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);\r
- if (num == NULL)\r
- return NULL;\r
-\r
- value = PyInt_AsUnsignedLongMask(num);\r
- if (value != ULONG_MAX)\r
- return raiseTestError("test_k_code",\r
- "PyInt_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");\r
-\r
- PyTuple_SET_ITEM(tuple, 0, num);\r
-\r
- value = 0;\r
- if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)\r
- return NULL;\r
- if (value != ULONG_MAX)\r
- return raiseTestError("test_k_code",\r
- "k code returned wrong value for long 0xFFF...FFF");\r
-\r
- Py_DECREF(num);\r
- num = PyLong_FromString("-FFFFFFFF000000000000000042", NULL, 16);\r
- if (num == NULL)\r
- return NULL;\r
-\r
- value = PyInt_AsUnsignedLongMask(num);\r
- if (value != (unsigned long)-0x42)\r
- return raiseTestError("test_k_code",\r
- "PyInt_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");\r
-\r
- PyTuple_SET_ITEM(tuple, 0, num);\r
-\r
- value = 0;\r
- if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)\r
- return NULL;\r
- if (value != (unsigned long)-0x42)\r
- return raiseTestError("test_k_code",\r
- "k code returned wrong value for long -0xFFF..000042");\r
-\r
- Py_DECREF(tuple);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-#ifdef Py_USING_UNICODE\r
-\r
-static volatile int x;\r
-\r
-/* Test the u and u# codes for PyArg_ParseTuple. May leak memory in case\r
- of an error.\r
-*/\r
-static PyObject *\r
-test_u_code(PyObject *self)\r
-{\r
- PyObject *tuple, *obj;\r
- Py_UNICODE *value;\r
- int len;\r
-\r
- /* issue4122: Undefined reference to _Py_ascii_whitespace on Windows */\r
- /* Just use the macro and check that it compiles */\r
- x = Py_UNICODE_ISSPACE(25);\r
-\r
- tuple = PyTuple_New(1);\r
- if (tuple == NULL)\r
- return NULL;\r
-\r
- obj = PyUnicode_Decode("test", strlen("test"),\r
- "ascii", NULL);\r
- if (obj == NULL)\r
- return NULL;\r
-\r
- PyTuple_SET_ITEM(tuple, 0, obj);\r
-\r
- value = 0;\r
- if (PyArg_ParseTuple(tuple, "u:test_u_code", &value) < 0)\r
- return NULL;\r
- if (value != PyUnicode_AS_UNICODE(obj))\r
- return raiseTestError("test_u_code",\r
- "u code returned wrong value for u'test'");\r
- value = 0;\r
- if (PyArg_ParseTuple(tuple, "u#:test_u_code", &value, &len) < 0)\r
- return NULL;\r
- if (value != PyUnicode_AS_UNICODE(obj) ||\r
- len != PyUnicode_GET_SIZE(obj))\r
- return raiseTestError("test_u_code",\r
- "u# code returned wrong values for u'test'");\r
-\r
- Py_DECREF(tuple);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-static PyObject *\r
-test_widechar(PyObject *self)\r
-{\r
-#if defined(SIZEOF_WCHAR_T) && (SIZEOF_WCHAR_T == 4)\r
- const wchar_t wtext[2] = {(wchar_t)0x10ABCDu};\r
- size_t wtextlen = 1;\r
-#else\r
- const wchar_t wtext[3] = {(wchar_t)0xDBEAu, (wchar_t)0xDFCDu};\r
- size_t wtextlen = 2;\r
-#endif\r
- PyObject *wide, *utf8;\r
-\r
- wide = PyUnicode_FromWideChar(wtext, wtextlen);\r
- if (wide == NULL)\r
- return NULL;\r
-\r
- utf8 = PyUnicode_FromString("\xf4\x8a\xaf\x8d");\r
- if (utf8 == NULL) {\r
- Py_DECREF(wide);\r
- return NULL;\r
- }\r
-\r
- if (PyUnicode_GET_SIZE(wide) != PyUnicode_GET_SIZE(utf8)) {\r
- Py_DECREF(wide);\r
- Py_DECREF(utf8);\r
- return raiseTestError("test_widechar",\r
- "wide string and utf8 string have different length");\r
- }\r
- if (PyUnicode_Compare(wide, utf8)) {\r
- Py_DECREF(wide);\r
- Py_DECREF(utf8);\r
- if (PyErr_Occurred())\r
- return NULL;\r
- return raiseTestError("test_widechar",\r
- "wide string and utf8 string are differents");\r
- }\r
-\r
- Py_DECREF(wide);\r
- Py_DECREF(utf8);\r
- Py_RETURN_NONE;\r
-}\r
-\r
-static PyObject *\r
-test_empty_argparse(PyObject *self)\r
-{\r
- /* Test that formats can begin with '|'. See issue #4720. */\r
- PyObject *tuple, *dict = NULL;\r
- static char *kwlist[] = {NULL};\r
- int result;\r
- tuple = PyTuple_New(0);\r
- if (!tuple)\r
- return NULL;\r
- if ((result = PyArg_ParseTuple(tuple, "|:test_empty_argparse")) < 0)\r
- goto done;\r
- dict = PyDict_New();\r
- if (!dict)\r
- goto done;\r
- result = PyArg_ParseTupleAndKeywords(tuple, dict, "|:test_empty_argparse", kwlist);\r
- done:\r
- Py_DECREF(tuple);\r
- Py_XDECREF(dict);\r
- if (result < 0)\r
- return NULL;\r
- else {\r
- Py_RETURN_NONE;\r
- }\r
-}\r
-\r
-static PyObject *\r
-codec_incrementalencoder(PyObject *self, PyObject *args)\r
-{\r
- const char *encoding, *errors = NULL;\r
- if (!PyArg_ParseTuple(args, "s|s:test_incrementalencoder",\r
- &encoding, &errors))\r
- return NULL;\r
- return PyCodec_IncrementalEncoder(encoding, errors);\r
-}\r
-\r
-static PyObject *\r
-codec_incrementaldecoder(PyObject *self, PyObject *args)\r
-{\r
- const char *encoding, *errors = NULL;\r
- if (!PyArg_ParseTuple(args, "s|s:test_incrementaldecoder",\r
- &encoding, &errors))\r
- return NULL;\r
- return PyCodec_IncrementalDecoder(encoding, errors);\r
-}\r
-\r
-#endif\r
-\r
-/* Simple test of _PyLong_NumBits and _PyLong_Sign. */\r
-static PyObject *\r
-test_long_numbits(PyObject *self)\r
-{\r
- struct triple {\r
- long input;\r
- size_t nbits;\r
- int sign;\r
- } testcases[] = {{0, 0, 0},\r
- {1L, 1, 1},\r
- {-1L, 1, -1},\r
- {2L, 2, 1},\r
- {-2L, 2, -1},\r
- {3L, 2, 1},\r
- {-3L, 2, -1},\r
- {4L, 3, 1},\r
- {-4L, 3, -1},\r
- {0x7fffL, 15, 1}, /* one Python long digit */\r
- {-0x7fffL, 15, -1},\r
- {0xffffL, 16, 1},\r
- {-0xffffL, 16, -1},\r
- {0xfffffffL, 28, 1},\r
- {-0xfffffffL, 28, -1}};\r
- int i;\r
-\r
- for (i = 0; i < sizeof(testcases) / sizeof(struct triple); ++i) {\r
- PyObject *plong = PyLong_FromLong(testcases[i].input);\r
- size_t nbits = _PyLong_NumBits(plong);\r
- int sign = _PyLong_Sign(plong);\r
-\r
- Py_DECREF(plong);\r
- if (nbits != testcases[i].nbits)\r
- return raiseTestError("test_long_numbits",\r
- "wrong result for _PyLong_NumBits");\r
- if (sign != testcases[i].sign)\r
- return raiseTestError("test_long_numbits",\r
- "wrong result for _PyLong_Sign");\r
- }\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-/* Example passing NULLs to PyObject_Str(NULL) and PyObject_Unicode(NULL). */\r
-\r
-static PyObject *\r
-test_null_strings(PyObject *self)\r
-{\r
- PyObject *o1 = PyObject_Str(NULL), *o2 = PyObject_Unicode(NULL);\r
- PyObject *tuple = PyTuple_Pack(2, o1, o2);\r
- Py_XDECREF(o1);\r
- Py_XDECREF(o2);\r
- return tuple;\r
-}\r
-\r
-static PyObject *\r
-raise_exception(PyObject *self, PyObject *args)\r
-{\r
- PyObject *exc;\r
- PyObject *exc_args, *v;\r
- int num_args, i;\r
-\r
- if (!PyArg_ParseTuple(args, "Oi:raise_exception",\r
- &exc, &num_args))\r
- return NULL;\r
- if (!PyExceptionClass_Check(exc)) {\r
- PyErr_Format(PyExc_TypeError, "an exception class is required");\r
- return NULL;\r
- }\r
-\r
- exc_args = PyTuple_New(num_args);\r
- if (exc_args == NULL)\r
- return NULL;\r
- for (i = 0; i < num_args; ++i) {\r
- v = PyInt_FromLong(i);\r
- if (v == NULL) {\r
- Py_DECREF(exc_args);\r
- return NULL;\r
- }\r
- PyTuple_SET_ITEM(exc_args, i, v);\r
- }\r
- PyErr_SetObject(exc, exc_args);\r
- Py_DECREF(exc_args);\r
- return NULL;\r
-}\r
-\r
-\r
-static int test_run_counter = 0;\r
-\r
-static PyObject *\r
-test_datetime_capi(PyObject *self, PyObject *args) {\r
- if (PyDateTimeAPI) {\r
- if (test_run_counter) {\r
- /* Probably regrtest.py -R */\r
- Py_RETURN_NONE;\r
- }\r
- else {\r
- PyErr_SetString(PyExc_AssertionError,\r
- "PyDateTime_CAPI somehow initialized");\r
- return NULL;\r
- }\r
- }\r
- test_run_counter++;\r
- PyDateTime_IMPORT;\r
- if (PyDateTimeAPI)\r
- Py_RETURN_NONE;\r
- else\r
- return NULL;\r
-}\r
-\r
-\r
-#ifdef WITH_THREAD\r
-\r
-/* test_thread_state spawns a thread of its own, and that thread releases\r
- * `thread_done` when it's finished. The driver code has to know when the\r
- * thread finishes, because the thread uses a PyObject (the callable) that\r
- * may go away when the driver finishes. The former lack of this explicit\r
- * synchronization caused rare segfaults, so rare that they were seen only\r
- * on a Mac buildbot (although they were possible on any box).\r
- */\r
-static PyThread_type_lock thread_done = NULL;\r
-\r
-static int\r
-_make_call(void *callable)\r
-{\r
- PyObject *rc;\r
- int success;\r
- PyGILState_STATE s = PyGILState_Ensure();\r
- rc = PyObject_CallFunction((PyObject *)callable, "");\r
- success = (rc != NULL);\r
- Py_XDECREF(rc);\r
- PyGILState_Release(s);\r
- return success;\r
-}\r
-\r
-/* Same thing, but releases `thread_done` when it returns. This variant\r
- * should be called only from threads spawned by test_thread_state().\r
- */\r
-static void\r
-_make_call_from_thread(void *callable)\r
-{\r
- _make_call(callable);\r
- PyThread_release_lock(thread_done);\r
-}\r
-\r
-static PyObject *\r
-test_thread_state(PyObject *self, PyObject *args)\r
-{\r
- PyObject *fn;\r
- int success = 1;\r
-\r
- if (!PyArg_ParseTuple(args, "O:test_thread_state", &fn))\r
- return NULL;\r
-\r
- if (!PyCallable_Check(fn)) {\r
- PyErr_Format(PyExc_TypeError, "'%s' object is not callable",\r
- fn->ob_type->tp_name);\r
- return NULL;\r
- }\r
-\r
- /* Ensure Python is set up for threading */\r
- PyEval_InitThreads();\r
- thread_done = PyThread_allocate_lock();\r
- if (thread_done == NULL)\r
- return PyErr_NoMemory();\r
- PyThread_acquire_lock(thread_done, 1);\r
-\r
- /* Start a new thread with our callback. */\r
- PyThread_start_new_thread(_make_call_from_thread, fn);\r
- /* Make the callback with the thread lock held by this thread */\r
- success &= _make_call(fn);\r
- /* Do it all again, but this time with the thread-lock released */\r
- Py_BEGIN_ALLOW_THREADS\r
- success &= _make_call(fn);\r
- PyThread_acquire_lock(thread_done, 1); /* wait for thread to finish */\r
- Py_END_ALLOW_THREADS\r
-\r
- /* And once more with and without a thread\r
- XXX - should use a lock and work out exactly what we are trying\r
- to test <wink>\r
- */\r
- Py_BEGIN_ALLOW_THREADS\r
- PyThread_start_new_thread(_make_call_from_thread, fn);\r
- success &= _make_call(fn);\r
- PyThread_acquire_lock(thread_done, 1); /* wait for thread to finish */\r
- Py_END_ALLOW_THREADS\r
-\r
- /* Release lock we acquired above. This is required on HP-UX. */\r
- PyThread_release_lock(thread_done);\r
-\r
- PyThread_free_lock(thread_done);\r
- if (!success)\r
- return NULL;\r
- Py_RETURN_NONE;\r
-}\r
-\r
-/* test Py_AddPendingCalls using threads */\r
-static int _pending_callback(void *arg)\r
-{\r
- /* we assume the argument is callable object to which we own a reference */\r
- PyObject *callable = (PyObject *)arg;\r
- PyObject *r = PyObject_CallObject(callable, NULL);\r
- Py_DECREF(callable);\r
- Py_XDECREF(r);\r
- return r != NULL ? 0 : -1;\r
-}\r
-\r
-/* The following requests n callbacks to _pending_callback. It can be\r
- * run from any python thread.\r
- */\r
-PyObject *pending_threadfunc(PyObject *self, PyObject *arg)\r
-{\r
- PyObject *callable;\r
- int r;\r
- if (PyArg_ParseTuple(arg, "O", &callable) == 0)\r
- return NULL;\r
-\r
- /* create the reference for the callbackwhile we hold the lock */\r
- Py_INCREF(callable);\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- r = Py_AddPendingCall(&_pending_callback, callable);\r
- Py_END_ALLOW_THREADS\r
-\r
- if (r<0) {\r
- Py_DECREF(callable); /* unsuccessful add, destroy the extra reference */\r
- Py_INCREF(Py_False);\r
- return Py_False;\r
- }\r
- Py_INCREF(Py_True);\r
- return Py_True;\r
-}\r
-#endif\r
-\r
-/* Some tests of PyString_FromFormat(). This needs more tests. */\r
-static PyObject *\r
-test_string_from_format(PyObject *self, PyObject *args)\r
-{\r
- PyObject *result;\r
- char *msg;\r
-\r
-#define CHECK_1_FORMAT(FORMAT, TYPE) \\r
- result = PyString_FromFormat(FORMAT, (TYPE)1); \\r
- if (result == NULL) \\r
- return NULL; \\r
- if (strcmp(PyString_AsString(result), "1")) { \\r
- msg = FORMAT " failed at 1"; \\r
- goto Fail; \\r
- } \\r
- Py_DECREF(result)\r
-\r
- CHECK_1_FORMAT("%d", int);\r
- CHECK_1_FORMAT("%ld", long);\r
- /* The z width modifier was added in Python 2.5. */\r
- CHECK_1_FORMAT("%zd", Py_ssize_t);\r
-\r
- /* The u type code was added in Python 2.5. */\r
- CHECK_1_FORMAT("%u", unsigned int);\r
- CHECK_1_FORMAT("%lu", unsigned long);\r
- CHECK_1_FORMAT("%zu", size_t);\r
-\r
- /* "%lld" and "%llu" support added in Python 2.7. */\r
-#ifdef HAVE_LONG_LONG\r
- CHECK_1_FORMAT("%llu", unsigned PY_LONG_LONG);\r
- CHECK_1_FORMAT("%lld", PY_LONG_LONG);\r
-#endif\r
-\r
- Py_RETURN_NONE;\r
-\r
- Fail:\r
- Py_XDECREF(result);\r
- return raiseTestError("test_string_from_format", msg);\r
-\r
-#undef CHECK_1_FORMAT\r
-}\r
-\r
-/* Coverage testing of capsule objects. */\r
-\r
-static const char *capsule_name = "capsule name";\r
-static char *capsule_pointer = "capsule pointer";\r
-static char *capsule_context = "capsule context";\r
-static const char *capsule_error = NULL;\r
-static int\r
-capsule_destructor_call_count = 0;\r
-\r
-static void\r
-capsule_destructor(PyObject *o) {\r
- capsule_destructor_call_count++;\r
- if (PyCapsule_GetContext(o) != capsule_context) {\r
- capsule_error = "context did not match in destructor!";\r
- } else if (PyCapsule_GetDestructor(o) != capsule_destructor) {\r
- capsule_error = "destructor did not match in destructor! (woah!)";\r
- } else if (PyCapsule_GetName(o) != capsule_name) {\r
- capsule_error = "name did not match in destructor!";\r
- } else if (PyCapsule_GetPointer(o, capsule_name) != capsule_pointer) {\r
- capsule_error = "pointer did not match in destructor!";\r
- }\r
-}\r
-\r
-typedef struct {\r
- char *name;\r
- char *module;\r
- char *attribute;\r
-} known_capsule;\r
-\r
-static PyObject *\r
-test_capsule(PyObject *self, PyObject *args)\r
-{\r
- PyObject *object;\r
- const char *error = NULL;\r
- void *pointer;\r
- void *pointer2;\r
- known_capsule known_capsules[] = {\r
- #define KNOWN_CAPSULE(module, name) { module "." name, module, name }\r
- KNOWN_CAPSULE("_socket", "CAPI"),\r
- KNOWN_CAPSULE("_curses", "_C_API"),\r
- KNOWN_CAPSULE("datetime", "datetime_CAPI"),\r
- { NULL, NULL },\r
- };\r
- known_capsule *known = &known_capsules[0];\r
-\r
-#define FAIL(x) { error = (x); goto exit; }\r
-\r
-#define CHECK_DESTRUCTOR \\r
- if (capsule_error) { \\r
- FAIL(capsule_error); \\r
- } \\r
- else if (!capsule_destructor_call_count) { \\r
- FAIL("destructor not called!"); \\r
- } \\r
- capsule_destructor_call_count = 0; \\r
-\r
- object = PyCapsule_New(capsule_pointer, capsule_name, capsule_destructor);\r
- PyCapsule_SetContext(object, capsule_context);\r
- capsule_destructor(object);\r
- CHECK_DESTRUCTOR;\r
- Py_DECREF(object);\r
- CHECK_DESTRUCTOR;\r
-\r
- object = PyCapsule_New(known, "ignored", NULL);\r
- PyCapsule_SetPointer(object, capsule_pointer);\r
- PyCapsule_SetName(object, capsule_name);\r
- PyCapsule_SetDestructor(object, capsule_destructor);\r
- PyCapsule_SetContext(object, capsule_context);\r
- capsule_destructor(object);\r
- CHECK_DESTRUCTOR;\r
- /* intentionally access using the wrong name */\r
- pointer2 = PyCapsule_GetPointer(object, "the wrong name");\r
- if (!PyErr_Occurred()) {\r
- FAIL("PyCapsule_GetPointer should have failed but did not!");\r
- }\r
- PyErr_Clear();\r
- if (pointer2) {\r
- if (pointer2 == capsule_pointer) {\r
- FAIL("PyCapsule_GetPointer should not have"\r
- " returned the internal pointer!");\r
- } else {\r
- FAIL("PyCapsule_GetPointer should have "\r
- "returned NULL pointer but did not!");\r
- }\r
- }\r
- PyCapsule_SetDestructor(object, NULL);\r
- Py_DECREF(object);\r
- if (capsule_destructor_call_count) {\r
- FAIL("destructor called when it should not have been!");\r
- }\r
-\r
- for (known = &known_capsules[0]; known->module != NULL; known++) {\r
- /* yeah, ordinarily I wouldn't do this either,\r
- but it's fine for this test harness.\r
- */\r
- static char buffer[256];\r
-#undef FAIL\r
-#define FAIL(x) \\r
- { \\r
- sprintf(buffer, "%s module: \"%s\" attribute: \"%s\"", \\r
- x, known->module, known->attribute); \\r
- error = buffer; \\r
- goto exit; \\r
- } \\r
-\r
- PyObject *module = PyImport_ImportModule(known->module);\r
- if (module) {\r
- pointer = PyCapsule_Import(known->name, 0);\r
- if (!pointer) {\r
- Py_DECREF(module);\r
- FAIL("PyCapsule_GetPointer returned NULL unexpectedly!");\r
- }\r
- object = PyObject_GetAttrString(module, known->attribute);\r
- if (!object) {\r
- Py_DECREF(module);\r
- return NULL;\r
- }\r
- pointer2 = PyCapsule_GetPointer(object,\r
- "weebles wobble but they don't fall down");\r
- if (!PyErr_Occurred()) {\r
- Py_DECREF(object);\r
- Py_DECREF(module);\r
- FAIL("PyCapsule_GetPointer should have failed but did not!");\r
- }\r
- PyErr_Clear();\r
- if (pointer2) {\r
- Py_DECREF(module);\r
- Py_DECREF(object);\r
- if (pointer2 == pointer) {\r
- FAIL("PyCapsule_GetPointer should not have"\r
- " returned its internal pointer!");\r
- } else {\r
- FAIL("PyCapsule_GetPointer should have"\r
- " returned NULL pointer but did not!");\r
- }\r
- }\r
- Py_DECREF(object);\r
- Py_DECREF(module);\r
- }\r
- else\r
- PyErr_Clear();\r
- }\r
-\r
- exit:\r
- if (error) {\r
- return raiseTestError("test_capsule", error);\r
- }\r
- Py_RETURN_NONE;\r
-#undef FAIL\r
-}\r
-\r
-/* This is here to provide a docstring for test_descr. */\r
-static PyObject *\r
-test_with_docstring(PyObject *self)\r
-{\r
- Py_RETURN_NONE;\r
-}\r
-\r
-/* To test the format of tracebacks as printed out. */\r
-static PyObject *\r
-traceback_print(PyObject *self, PyObject *args)\r
-{\r
- PyObject *file;\r
- PyObject *traceback;\r
- int result;\r
-\r
- if (!PyArg_ParseTuple(args, "OO:traceback_print",\r
- &traceback, &file))\r
- return NULL;\r
-\r
- result = PyTraceBack_Print(traceback, file);\r
- if (result < 0)\r
- return NULL;\r
- Py_RETURN_NONE;\r
-}\r
-\r
-/* To test that the result of PyCode_NewEmpty has the right members. */\r
-static PyObject *\r
-code_newempty(PyObject *self, PyObject *args)\r
-{\r
- const char *filename;\r
- const char *funcname;\r
- int firstlineno;\r
-\r
- if (!PyArg_ParseTuple(args, "ssi:code_newempty",\r
- &filename, &funcname, &firstlineno))\r
- return NULL;\r
-\r
- return (PyObject *)PyCode_NewEmpty(filename, funcname, firstlineno);\r
-}\r
-\r
-/* Test PyErr_NewExceptionWithDoc (also exercise PyErr_NewException).\r
- Run via Lib/test/test_exceptions.py */\r
-static PyObject *\r
-make_exception_with_doc(PyObject *self, PyObject *args, PyObject *kwargs)\r
-{\r
- char *name;\r
- char *doc = NULL;\r
- PyObject *base = NULL;\r
- PyObject *dict = NULL;\r
-\r
- static char *kwlist[] = {"name", "doc", "base", "dict", NULL};\r
-\r
- if (!PyArg_ParseTupleAndKeywords(args, kwargs,\r
- "s|sOO:make_exception_with_doc", kwlist,\r
- &name, &doc, &base, &dict))\r
- return NULL;\r
-\r
- return PyErr_NewExceptionWithDoc(name, doc, base, dict);\r
-}\r
-\r
-static PyMethodDef TestMethods[] = {\r
- {"raise_exception", raise_exception, METH_VARARGS},\r
- {"test_config", (PyCFunction)test_config, METH_NOARGS},\r
- {"test_datetime_capi", test_datetime_capi, METH_NOARGS},\r
- {"test_list_api", (PyCFunction)test_list_api, METH_NOARGS},\r
- {"test_dict_iteration", (PyCFunction)test_dict_iteration,METH_NOARGS},\r
- {"test_lazy_hash_inheritance", (PyCFunction)test_lazy_hash_inheritance,METH_NOARGS},\r
- {"test_broken_memoryview", (PyCFunction)test_broken_memoryview,METH_NOARGS},\r
- {"test_long_api", (PyCFunction)test_long_api, METH_NOARGS},\r
- {"test_long_and_overflow", (PyCFunction)test_long_and_overflow,\r
- METH_NOARGS},\r
- {"test_long_numbits", (PyCFunction)test_long_numbits, METH_NOARGS},\r
- {"test_k_code", (PyCFunction)test_k_code, METH_NOARGS},\r
- {"test_empty_argparse", (PyCFunction)test_empty_argparse,METH_NOARGS},\r
- {"test_null_strings", (PyCFunction)test_null_strings, METH_NOARGS},\r
- {"test_string_from_format", (PyCFunction)test_string_from_format, METH_NOARGS},\r
- {"test_with_docstring", (PyCFunction)test_with_docstring, METH_NOARGS,\r
- PyDoc_STR("This is a pretty normal docstring.")},\r
-\r
- {"getargs_tuple", getargs_tuple, METH_VARARGS},\r
- {"getargs_keywords", (PyCFunction)getargs_keywords,\r
- METH_VARARGS|METH_KEYWORDS},\r
- {"getargs_b", getargs_b, METH_VARARGS},\r
- {"getargs_B", getargs_B, METH_VARARGS},\r
- {"getargs_h", getargs_h, METH_VARARGS},\r
- {"getargs_H", getargs_H, METH_VARARGS},\r
- {"getargs_I", getargs_I, METH_VARARGS},\r
- {"getargs_k", getargs_k, METH_VARARGS},\r
- {"getargs_i", getargs_i, METH_VARARGS},\r
- {"getargs_l", getargs_l, METH_VARARGS},\r
- {"getargs_n", getargs_n, METH_VARARGS},\r
-#ifdef HAVE_LONG_LONG\r
- {"getargs_L", getargs_L, METH_VARARGS},\r
- {"getargs_K", getargs_K, METH_VARARGS},\r
- {"test_longlong_api", test_longlong_api, METH_NOARGS},\r
- {"test_long_long_and_overflow",\r
- (PyCFunction)test_long_long_and_overflow, METH_NOARGS},\r
- {"test_L_code", (PyCFunction)test_L_code, METH_NOARGS},\r
- {"codec_incrementalencoder",\r
- (PyCFunction)codec_incrementalencoder, METH_VARARGS},\r
- {"codec_incrementaldecoder",\r
- (PyCFunction)codec_incrementaldecoder, METH_VARARGS},\r
-#endif\r
-#ifdef Py_USING_UNICODE\r
- {"test_u_code", (PyCFunction)test_u_code, METH_NOARGS},\r
- {"test_widechar", (PyCFunction)test_widechar, METH_NOARGS},\r
-#endif\r
-#ifdef WITH_THREAD\r
- {"_test_thread_state", test_thread_state, METH_VARARGS},\r
- {"_pending_threadfunc", pending_threadfunc, METH_VARARGS},\r
-#endif\r
- {"test_capsule", (PyCFunction)test_capsule, METH_NOARGS},\r
- {"traceback_print", traceback_print, METH_VARARGS},\r
- {"code_newempty", code_newempty, METH_VARARGS},\r
- {"make_exception_with_doc", (PyCFunction)make_exception_with_doc,\r
- METH_VARARGS | METH_KEYWORDS},\r
- {NULL, NULL} /* sentinel */\r
-};\r
-\r
-#define AddSym(d, n, f, v) {PyObject *o = f(v); PyDict_SetItemString(d, n, o); Py_DECREF(o);}\r
-\r
-typedef struct {\r
- char bool_member;\r
- char byte_member;\r
- unsigned char ubyte_member;\r
- short short_member;\r
- unsigned short ushort_member;\r
- int int_member;\r
- unsigned int uint_member;\r
- long long_member;\r
- unsigned long ulong_member;\r
- float float_member;\r
- double double_member;\r
- char inplace_member[6];\r
-#ifdef HAVE_LONG_LONG\r
- PY_LONG_LONG longlong_member;\r
- unsigned PY_LONG_LONG ulonglong_member;\r
-#endif\r
-} all_structmembers;\r
-\r
-typedef struct {\r
- PyObject_HEAD\r
- all_structmembers structmembers;\r
-} test_structmembers;\r
-\r
-static struct PyMemberDef test_members[] = {\r
- {"T_BOOL", T_BOOL, offsetof(test_structmembers, structmembers.bool_member), 0, NULL},\r
- {"T_BYTE", T_BYTE, offsetof(test_structmembers, structmembers.byte_member), 0, NULL},\r
- {"T_UBYTE", T_UBYTE, offsetof(test_structmembers, structmembers.ubyte_member), 0, NULL},\r
- {"T_SHORT", T_SHORT, offsetof(test_structmembers, structmembers.short_member), 0, NULL},\r
- {"T_USHORT", T_USHORT, offsetof(test_structmembers, structmembers.ushort_member), 0, NULL},\r
- {"T_INT", T_INT, offsetof(test_structmembers, structmembers.int_member), 0, NULL},\r
- {"T_UINT", T_UINT, offsetof(test_structmembers, structmembers.uint_member), 0, NULL},\r
- {"T_LONG", T_LONG, offsetof(test_structmembers, structmembers.long_member), 0, NULL},\r
- {"T_ULONG", T_ULONG, offsetof(test_structmembers, structmembers.ulong_member), 0, NULL},\r
- {"T_FLOAT", T_FLOAT, offsetof(test_structmembers, structmembers.float_member), 0, NULL},\r
- {"T_DOUBLE", T_DOUBLE, offsetof(test_structmembers, structmembers.double_member), 0, NULL},\r
- {"T_STRING_INPLACE", T_STRING_INPLACE, offsetof(test_structmembers, structmembers.inplace_member), 0, NULL},\r
-#ifdef HAVE_LONG_LONG\r
- {"T_LONGLONG", T_LONGLONG, offsetof(test_structmembers, structmembers.longlong_member), 0, NULL},\r
- {"T_ULONGLONG", T_ULONGLONG, offsetof(test_structmembers, structmembers.ulonglong_member), 0, NULL},\r
-#endif\r
- {NULL}\r
-};\r
-\r
-\r
-static PyObject *\r
-test_structmembers_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)\r
-{\r
- static char *keywords[] = {\r
- "T_BOOL", "T_BYTE", "T_UBYTE", "T_SHORT", "T_USHORT",\r
- "T_INT", "T_UINT", "T_LONG", "T_ULONG",\r
- "T_FLOAT", "T_DOUBLE", "T_STRING_INPLACE",\r
-#ifdef HAVE_LONG_LONG\r
- "T_LONGLONG", "T_ULONGLONG",\r
-#endif\r
- NULL};\r
- static char *fmt = "|bbBhHiIlkfds#"\r
-#ifdef HAVE_LONG_LONG\r
- "LK"\r
-#endif\r
- ;\r
- test_structmembers *ob;\r
- const char *s = NULL;\r
- Py_ssize_t string_len = 0;\r
- ob = PyObject_New(test_structmembers, type);\r
- if (ob == NULL)\r
- return NULL;\r
- memset(&ob->structmembers, 0, sizeof(all_structmembers));\r
- if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,\r
- &ob->structmembers.bool_member,\r
- &ob->structmembers.byte_member,\r
- &ob->structmembers.ubyte_member,\r
- &ob->structmembers.short_member,\r
- &ob->structmembers.ushort_member,\r
- &ob->structmembers.int_member,\r
- &ob->structmembers.uint_member,\r
- &ob->structmembers.long_member,\r
- &ob->structmembers.ulong_member,\r
- &ob->structmembers.float_member,\r
- &ob->structmembers.double_member,\r
- &s, &string_len\r
-#ifdef HAVE_LONG_LONG\r
- , &ob->structmembers.longlong_member,\r
- &ob->structmembers.ulonglong_member\r
-#endif\r
- )) {\r
- Py_DECREF(ob);\r
- return NULL;\r
- }\r
- if (s != NULL) {\r
- if (string_len > 5) {\r
- Py_DECREF(ob);\r
- PyErr_SetString(PyExc_ValueError, "string too long");\r
- return NULL;\r
- }\r
- strcpy(ob->structmembers.inplace_member, s);\r
- }\r
- else {\r
- strcpy(ob->structmembers.inplace_member, "");\r
- }\r
- return (PyObject *)ob;\r
-}\r
-\r
-static void\r
-test_structmembers_free(PyObject *ob)\r
-{\r
- PyObject_FREE(ob);\r
-}\r
-\r
-static PyTypeObject test_structmembersType = {\r
- PyVarObject_HEAD_INIT(NULL, 0)\r
- "test_structmembersType",\r
- sizeof(test_structmembers), /* tp_basicsize */\r
- 0, /* tp_itemsize */\r
- test_structmembers_free, /* destructor tp_dealloc */\r
- 0, /* tp_print */\r
- 0, /* tp_getattr */\r
- 0, /* tp_setattr */\r
- 0, /* tp_compare */\r
- 0, /* tp_repr */\r
- 0, /* tp_as_number */\r
- 0, /* tp_as_sequence */\r
- 0, /* tp_as_mapping */\r
- 0, /* tp_hash */\r
- 0, /* tp_call */\r
- 0, /* tp_str */\r
- PyObject_GenericGetAttr, /* tp_getattro */\r
- PyObject_GenericSetAttr, /* tp_setattro */\r
- 0, /* tp_as_buffer */\r
- 0, /* tp_flags */\r
- "Type containing all structmember types",\r
- 0, /* traverseproc tp_traverse */\r
- 0, /* tp_clear */\r
- 0, /* tp_richcompare */\r
- 0, /* tp_weaklistoffset */\r
- 0, /* tp_iter */\r
- 0, /* tp_iternext */\r
- 0, /* tp_methods */\r
- test_members, /* tp_members */\r
- 0,\r
- 0,\r
- 0,\r
- 0,\r
- 0,\r
- 0,\r
- 0,\r
- 0,\r
- test_structmembers_new, /* tp_new */\r
-};\r
-\r
-\r
-PyMODINIT_FUNC\r
-init_testcapi(void)\r
-{\r
- PyObject *m;\r
-\r
- m = Py_InitModule("_testcapi", TestMethods);\r
- if (m == NULL)\r
- return;\r
-\r
- Py_TYPE(&_HashInheritanceTester_Type)=&PyType_Type;\r
-\r
- Py_TYPE(&test_structmembersType)=&PyType_Type;\r
- Py_INCREF(&test_structmembersType);\r
- /* don't use a name starting with "test", since we don't want\r
- test_capi to automatically call this */\r
- PyModule_AddObject(m, "_test_structmembersType", (PyObject *)&test_structmembersType);\r
-\r
- PyModule_AddObject(m, "CHAR_MAX", PyInt_FromLong(CHAR_MAX));\r
- PyModule_AddObject(m, "CHAR_MIN", PyInt_FromLong(CHAR_MIN));\r
- PyModule_AddObject(m, "UCHAR_MAX", PyInt_FromLong(UCHAR_MAX));\r
- PyModule_AddObject(m, "SHRT_MAX", PyInt_FromLong(SHRT_MAX));\r
- PyModule_AddObject(m, "SHRT_MIN", PyInt_FromLong(SHRT_MIN));\r
- PyModule_AddObject(m, "USHRT_MAX", PyInt_FromLong(USHRT_MAX));\r
- PyModule_AddObject(m, "INT_MAX", PyLong_FromLong(INT_MAX));\r
- PyModule_AddObject(m, "INT_MIN", PyLong_FromLong(INT_MIN));\r
- PyModule_AddObject(m, "UINT_MAX", PyLong_FromUnsignedLong(UINT_MAX));\r
- PyModule_AddObject(m, "LONG_MAX", PyInt_FromLong(LONG_MAX));\r
- PyModule_AddObject(m, "LONG_MIN", PyInt_FromLong(LONG_MIN));\r
- PyModule_AddObject(m, "ULONG_MAX", PyLong_FromUnsignedLong(ULONG_MAX));\r
- PyModule_AddObject(m, "FLT_MAX", PyFloat_FromDouble(FLT_MAX));\r
- PyModule_AddObject(m, "FLT_MIN", PyFloat_FromDouble(FLT_MIN));\r
- PyModule_AddObject(m, "DBL_MAX", PyFloat_FromDouble(DBL_MAX));\r
- PyModule_AddObject(m, "DBL_MIN", PyFloat_FromDouble(DBL_MIN));\r
- PyModule_AddObject(m, "LLONG_MAX", PyLong_FromLongLong(PY_LLONG_MAX));\r
- PyModule_AddObject(m, "LLONG_MIN", PyLong_FromLongLong(PY_LLONG_MIN));\r
- PyModule_AddObject(m, "ULLONG_MAX", PyLong_FromUnsignedLongLong(PY_ULLONG_MAX));\r
- PyModule_AddObject(m, "PY_SSIZE_T_MAX", PyInt_FromSsize_t(PY_SSIZE_T_MAX));\r
- PyModule_AddObject(m, "PY_SSIZE_T_MIN", PyInt_FromSsize_t(PY_SSIZE_T_MIN));\r
- PyModule_AddObject(m, "SIZEOF_PYGC_HEAD", PyInt_FromSsize_t(sizeof(PyGC_Head)));\r
-\r
- TestError = PyErr_NewException("_testcapi.error", NULL, NULL);\r
- Py_INCREF(TestError);\r
- PyModule_AddObject(m, "error", TestError);\r
-}\r
projects / mirror_edk2.git / blobdiff