blob: 74422a2f8db97005d3fc3f7a45a9bb2b8d45b713 [file] [log] [blame]
Tim Peters9ea17ac2001-02-02 05:57:15 +00001/*
2 * C Extension module to test Python interpreter C APIs.
3 *
4 * The 'test_*' functions exported by this module are run as part of the
5 * standard Python regression test, via Lib/test/test_capi.py.
6 */
7
Neal Norwitz8866e0a2007-10-27 04:01:17 +00008#define PY_SSIZE_T_CLEAN
9
Tim Peters9ea17ac2001-02-02 05:57:15 +000010#include "Python.h"
Thomas Wouters89f507f2006-12-13 04:49:30 +000011#include <float.h>
12#include "structmember.h"
Benjamin Peterson91d58bd2009-12-13 21:30:54 +000013#include "datetime.h"
Serhiy Storchakab5181342015-02-06 08:58:56 +020014#include "marshal.h"
Victor Stinner56e8c292014-07-21 12:30:22 +020015#include <signal.h>
Tim Peters9ea17ac2001-02-02 05:57:15 +000016
Victor Stinner95e9cef2015-03-28 01:26:47 +010017#ifdef MS_WINDOWS
Victor Stinner09e5cf22015-03-30 00:09:18 +020018# include <winsock2.h> /* struct timeval */
Victor Stinner95e9cef2015-03-28 01:26:47 +010019#endif
20
Mark Hammond8d98d2c2003-04-19 15:41:53 +000021#ifdef WITH_THREAD
22#include "pythread.h"
23#endif /* WITH_THREAD */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000024static PyObject *TestError; /* set to exception object in init */
Tim Peters9ea17ac2001-02-02 05:57:15 +000025
Tim Peters91621db2001-06-12 20:10:01 +000026/* Raise TestError with test_name + ": " + msg, and return NULL. */
27
28static PyObject *
29raiseTestError(const char* test_name, const char* msg)
30{
Victor Stinner6ced7c42011-03-21 18:15:42 +010031 PyErr_Format(TestError, "%s: %s", test_name, msg);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000032 return NULL;
Tim Peters91621db2001-06-12 20:10:01 +000033}
34
Martin v. Löwis4f1cd8b2001-07-26 13:41:06 +000035/* Test #defines from pyconfig.h (particularly the SIZEOF_* defines).
Tim Peters9ea17ac2001-02-02 05:57:15 +000036
37 The ones derived from autoconf on the UNIX-like OSes can be relied
38 upon (in the absence of sloppy cross-compiling), but the Windows
39 platforms have these hardcoded. Better safe than sorry.
40*/
41static PyObject*
Thomas Wouters89f507f2006-12-13 04:49:30 +000042sizeof_error(const char* fatname, const char* typname,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000043 int expected, int got)
Tim Peters9ea17ac2001-02-02 05:57:15 +000044{
Victor Stinner499dfcf2011-03-21 13:26:24 +010045 PyErr_Format(TestError,
46 "%s #define == %d but sizeof(%s) == %d",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000047 fatname, expected, typname, got);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000048 return (PyObject*)NULL;
Tim Peters9ea17ac2001-02-02 05:57:15 +000049}
50
51static PyObject*
Fred Drakeacee69f2002-04-01 14:28:58 +000052test_config(PyObject *self)
Tim Peters9ea17ac2001-02-02 05:57:15 +000053{
Tim Peters9ea17ac2001-02-02 05:57:15 +000054#define CHECK_SIZEOF(FATNAME, TYPE) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000055 if (FATNAME != sizeof(TYPE)) \
56 return sizeof_error(#FATNAME, #TYPE, FATNAME, sizeof(TYPE))
Tim Peters9ea17ac2001-02-02 05:57:15 +000057
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000058 CHECK_SIZEOF(SIZEOF_SHORT, short);
59 CHECK_SIZEOF(SIZEOF_INT, int);
60 CHECK_SIZEOF(SIZEOF_LONG, long);
61 CHECK_SIZEOF(SIZEOF_VOID_P, void*);
62 CHECK_SIZEOF(SIZEOF_TIME_T, time_t);
Benjamin Petersonaf580df2016-09-06 10:46:49 -070063 CHECK_SIZEOF(SIZEOF_LONG_LONG, long long);
Tim Peters9ea17ac2001-02-02 05:57:15 +000064
65#undef CHECK_SIZEOF
66
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000067 Py_INCREF(Py_None);
68 return Py_None;
Tim Peters9ea17ac2001-02-02 05:57:15 +000069}
70
Tim Peters5c4d5bf2001-02-12 22:13:26 +000071static PyObject*
Victor Stinner01076552013-10-29 19:39:52 +010072test_sizeof_c_types(PyObject *self)
73{
Ned Deilye37a1942015-03-05 15:47:10 -080074#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))
Serhiy Storchakab48af342015-02-26 15:27:57 +020075#pragma GCC diagnostic push
76#pragma GCC diagnostic ignored "-Wtype-limits"
77#endif
Victor Stinnerf866f972013-10-29 19:59:31 +010078#define CHECK_SIZEOF(TYPE, EXPECTED) \
Victor Stinner01076552013-10-29 19:39:52 +010079 if (EXPECTED != sizeof(TYPE)) { \
80 PyErr_Format(TestError, \
81 "sizeof(%s) = %u instead of %u", \
82 #TYPE, sizeof(TYPE), EXPECTED); \
83 return (PyObject*)NULL; \
84 }
Victor Stinnerf866f972013-10-29 19:59:31 +010085#define IS_SIGNED(TYPE) (((TYPE)-1) < (TYPE)0)
86#define CHECK_SIGNNESS(TYPE, SIGNED) \
87 if (IS_SIGNED(TYPE) != SIGNED) { \
88 PyErr_Format(TestError, \
89 "%s signness is, instead of %i", \
90 #TYPE, IS_SIGNED(TYPE), SIGNED); \
91 return (PyObject*)NULL; \
92 }
Victor Stinner01076552013-10-29 19:39:52 +010093
94 /* integer types */
Victor Stinnerf866f972013-10-29 19:59:31 +010095 CHECK_SIZEOF(Py_UCS1, 1);
96 CHECK_SIZEOF(Py_UCS2, 2);
97 CHECK_SIZEOF(Py_UCS4, 4);
98 CHECK_SIGNNESS(Py_UCS1, 0);
99 CHECK_SIGNNESS(Py_UCS2, 0);
100 CHECK_SIGNNESS(Py_UCS4, 0);
Benjamin Peterson9b3d7702016-09-06 13:24:00 -0700101 CHECK_SIZEOF(int32_t, 4);
102 CHECK_SIGNNESS(int32_t, 1);
103 CHECK_SIZEOF(uint32_t, 4);
104 CHECK_SIGNNESS(uint32_t, 0);
105 CHECK_SIZEOF(int64_t, 8);
106 CHECK_SIGNNESS(int64_t, 1);
107 CHECK_SIZEOF(uint64_t, 8);
108 CHECK_SIGNNESS(uint64_t, 0);
Victor Stinner01076552013-10-29 19:39:52 +0100109
110 /* pointer/size types */
Victor Stinnerf866f972013-10-29 19:59:31 +0100111 CHECK_SIZEOF(size_t, sizeof(void *));
112 CHECK_SIGNNESS(size_t, 0);
113 CHECK_SIZEOF(Py_ssize_t, sizeof(void *));
114 CHECK_SIGNNESS(Py_ssize_t, 1);
115
Benjamin Petersonca470632016-09-06 13:47:26 -0700116 CHECK_SIZEOF(uintptr_t, sizeof(void *));
117 CHECK_SIGNNESS(uintptr_t, 0);
118 CHECK_SIZEOF(intptr_t, sizeof(void *));
119 CHECK_SIGNNESS(intptr_t, 1);
Victor Stinner01076552013-10-29 19:39:52 +0100120
121 Py_INCREF(Py_None);
122 return Py_None;
123
Victor Stinnerf866f972013-10-29 19:59:31 +0100124#undef IS_SIGNED
125#undef CHECK_SIGNESS
Victor Stinner01076552013-10-29 19:39:52 +0100126#undef CHECK_SIZEOF
Ned Deilye37a1942015-03-05 15:47:10 -0800127#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))
Serhiy Storchakab48af342015-02-26 15:27:57 +0200128#pragma GCC diagnostic pop
129#endif
Victor Stinner01076552013-10-29 19:39:52 +0100130}
131
132
133static PyObject*
Fred Drakeacee69f2002-04-01 14:28:58 +0000134test_list_api(PyObject *self)
Tim Peters5c4d5bf2001-02-12 22:13:26 +0000135{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000136 PyObject* list;
137 int i;
Tim Peters5c4d5bf2001-02-12 22:13:26 +0000138
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000139 /* SF bug 132008: PyList_Reverse segfaults */
Tim Peters5c4d5bf2001-02-12 22:13:26 +0000140#define NLIST 30
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000141 list = PyList_New(NLIST);
142 if (list == (PyObject*)NULL)
143 return (PyObject*)NULL;
144 /* list = range(NLIST) */
145 for (i = 0; i < NLIST; ++i) {
146 PyObject* anint = PyLong_FromLong(i);
147 if (anint == (PyObject*)NULL) {
148 Py_DECREF(list);
149 return (PyObject*)NULL;
150 }
151 PyList_SET_ITEM(list, i, anint);
152 }
153 /* list.reverse(), via PyList_Reverse() */
154 i = PyList_Reverse(list); /* should not blow up! */
155 if (i != 0) {
156 Py_DECREF(list);
157 return (PyObject*)NULL;
158 }
159 /* Check that list == range(29, -1, -1) now */
160 for (i = 0; i < NLIST; ++i) {
161 PyObject* anint = PyList_GET_ITEM(list, i);
162 if (PyLong_AS_LONG(anint) != NLIST-1-i) {
163 PyErr_SetString(TestError,
164 "test_list_api: reverse screwed up");
165 Py_DECREF(list);
166 return (PyObject*)NULL;
167 }
168 }
169 Py_DECREF(list);
Tim Peters5c4d5bf2001-02-12 22:13:26 +0000170#undef NLIST
171
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000172 Py_INCREF(Py_None);
173 return Py_None;
Tim Peters5c4d5bf2001-02-12 22:13:26 +0000174}
175
Guido van Rossumeb0d9922001-04-13 17:08:15 +0000176static int
177test_dict_inner(int count)
178{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000179 Py_ssize_t pos = 0, iterations = 0;
180 int i;
181 PyObject *dict = PyDict_New();
182 PyObject *v, *k;
Guido van Rossumeb0d9922001-04-13 17:08:15 +0000183
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000184 if (dict == NULL)
185 return -1;
Guido van Rossumeb0d9922001-04-13 17:08:15 +0000186
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000187 for (i = 0; i < count; i++) {
188 v = PyLong_FromLong(i);
Christian Heimesff369a52013-07-26 14:52:18 +0200189 if (v == NULL) {
Christian Heimesff369a52013-07-26 14:52:18 +0200190 return -1;
191 }
Christian Heimes97cb67b2013-07-20 15:01:26 +0200192 if (PyDict_SetItem(dict, v, v) < 0) {
193 Py_DECREF(v);
194 return -1;
195 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000196 Py_DECREF(v);
197 }
Guido van Rossumeb0d9922001-04-13 17:08:15 +0000198
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000199 while (PyDict_Next(dict, &pos, &k, &v)) {
200 PyObject *o;
201 iterations++;
Guido van Rossumeb0d9922001-04-13 17:08:15 +0000202
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000203 i = PyLong_AS_LONG(v) + 1;
204 o = PyLong_FromLong(i);
205 if (o == NULL)
206 return -1;
207 if (PyDict_SetItem(dict, k, o) < 0) {
208 Py_DECREF(o);
209 return -1;
210 }
211 Py_DECREF(o);
212 }
Guido van Rossumeb0d9922001-04-13 17:08:15 +0000213
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000214 Py_DECREF(dict);
Guido van Rossumeb0d9922001-04-13 17:08:15 +0000215
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000216 if (iterations != count) {
217 PyErr_SetString(
218 TestError,
219 "test_dict_iteration: dict iteration went wrong ");
220 return -1;
221 } else {
222 return 0;
223 }
Guido van Rossumeb0d9922001-04-13 17:08:15 +0000224}
225
226static PyObject*
Fred Drakeacee69f2002-04-01 14:28:58 +0000227test_dict_iteration(PyObject* self)
Guido van Rossumeb0d9922001-04-13 17:08:15 +0000228{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000229 int i;
Guido van Rossumeb0d9922001-04-13 17:08:15 +0000230
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000231 for (i = 0; i < 200; i++) {
232 if (test_dict_inner(i) < 0) {
233 return NULL;
234 }
235 }
Guido van Rossumeb0d9922001-04-13 17:08:15 +0000236
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000237 Py_INCREF(Py_None);
238 return Py_None;
Guido van Rossumeb0d9922001-04-13 17:08:15 +0000239}
240
Tim Peters91621db2001-06-12 20:10:01 +0000241
Nick Coghlanf1f2f682008-12-30 07:29:12 +0000242/* Issue #4701: Check that PyObject_Hash implicitly calls
243 * PyType_Ready if it hasn't already been called
244 */
245static PyTypeObject _HashInheritanceTester_Type = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000246 PyVarObject_HEAD_INIT(NULL, 0)
247 "hashinheritancetester", /* Name of this type */
248 sizeof(PyObject), /* Basic object size */
249 0, /* Item size for varobject */
250 (destructor)PyObject_Del, /* tp_dealloc */
251 0, /* tp_print */
252 0, /* tp_getattr */
253 0, /* tp_setattr */
254 0, /* tp_reserved */
255 0, /* tp_repr */
256 0, /* tp_as_number */
257 0, /* tp_as_sequence */
258 0, /* tp_as_mapping */
259 0, /* tp_hash */
260 0, /* tp_call */
261 0, /* tp_str */
262 PyObject_GenericGetAttr, /* tp_getattro */
263 0, /* tp_setattro */
264 0, /* tp_as_buffer */
265 Py_TPFLAGS_DEFAULT, /* tp_flags */
266 0, /* tp_doc */
267 0, /* tp_traverse */
268 0, /* tp_clear */
269 0, /* tp_richcompare */
270 0, /* tp_weaklistoffset */
271 0, /* tp_iter */
272 0, /* tp_iternext */
273 0, /* tp_methods */
274 0, /* tp_members */
275 0, /* tp_getset */
276 0, /* tp_base */
277 0, /* tp_dict */
278 0, /* tp_descr_get */
279 0, /* tp_descr_set */
280 0, /* tp_dictoffset */
281 0, /* tp_init */
282 0, /* tp_alloc */
283 PyType_GenericNew, /* tp_new */
Nick Coghlanf1f2f682008-12-30 07:29:12 +0000284};
285
286static PyObject*
287test_lazy_hash_inheritance(PyObject* self)
288{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000289 PyTypeObject *type;
290 PyObject *obj;
Antoine Pitrou29aad002010-10-23 19:42:38 +0000291 Py_hash_t hash;
Nick Coghlanf1f2f682008-12-30 07:29:12 +0000292
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000293 type = &_HashInheritanceTester_Type;
Benjamin Petersonf1726372009-05-05 21:11:54 +0000294
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000295 if (type->tp_dict != NULL)
296 /* The type has already been initialized. This probably means
297 -R is being used. */
298 Py_RETURN_NONE;
Benjamin Petersonf1726372009-05-05 21:11:54 +0000299
300
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000301 obj = PyObject_New(PyObject, type);
302 if (obj == NULL) {
303 PyErr_Clear();
304 PyErr_SetString(
305 TestError,
306 "test_lazy_hash_inheritance: failed to create object");
307 return NULL;
308 }
Nick Coghlanf1f2f682008-12-30 07:29:12 +0000309
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000310 if (type->tp_dict != NULL) {
311 PyErr_SetString(
312 TestError,
313 "test_lazy_hash_inheritance: type initialised too soon");
314 Py_DECREF(obj);
315 return NULL;
316 }
Nick Coghlanf1f2f682008-12-30 07:29:12 +0000317
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000318 hash = PyObject_Hash(obj);
319 if ((hash == -1) && PyErr_Occurred()) {
320 PyErr_Clear();
321 PyErr_SetString(
322 TestError,
323 "test_lazy_hash_inheritance: could not hash object");
324 Py_DECREF(obj);
325 return NULL;
326 }
Nick Coghlanf1f2f682008-12-30 07:29:12 +0000327
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000328 if (type->tp_dict == NULL) {
329 PyErr_SetString(
330 TestError,
331 "test_lazy_hash_inheritance: type not initialised by hash()");
332 Py_DECREF(obj);
333 return NULL;
334 }
Nick Coghlanf1f2f682008-12-30 07:29:12 +0000335
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000336 if (type->tp_hash != PyType_Type.tp_hash) {
337 PyErr_SetString(
338 TestError,
339 "test_lazy_hash_inheritance: unexpected hash function");
340 Py_DECREF(obj);
341 return NULL;
342 }
Nick Coghlanf1f2f682008-12-30 07:29:12 +0000343
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000344 Py_DECREF(obj);
Benjamin Petersonf1726372009-05-05 21:11:54 +0000345
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000346 Py_RETURN_NONE;
Nick Coghlanf1f2f682008-12-30 07:29:12 +0000347}
348
349
Benjamin Petersoned4aa832016-09-05 17:44:18 -0700350/* Tests of PyLong_{As, From}{Unsigned,}Long(), and
Tim Petersff70d3c2001-06-14 01:11:03 +0000351 PyLong_{As, From}{Unsigned,}LongLong().
Tim Peterse7c1f9b2001-06-14 00:55:41 +0000352
353 Note that the meat of the test is contained in testcapi_long.h.
354 This is revolting, but delicate code duplication is worse: "almost
Benjamin Petersonaf580df2016-09-06 10:46:49 -0700355 exactly the same" code is needed to test long long, but the ubiquitous
Tim Peterse7c1f9b2001-06-14 00:55:41 +0000356 dependence on type names makes it impossible to use a parameterized
357 function. A giant macro would be even worse than this. A C++ template
358 would be perfect.
359
360 The "report an error" functions are deliberately not part of the #include
361 file: if the test fails, you can set a breakpoint in the appropriate
362 error function directly, and crawl back from there in the debugger.
363*/
364
365#define UNBIND(X) Py_DECREF(X); (X) = NULL
366
367static PyObject *
368raise_test_long_error(const char* msg)
369{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000370 return raiseTestError("test_long_api", msg);
Tim Peterse7c1f9b2001-06-14 00:55:41 +0000371}
372
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000373#define TESTNAME test_long_api_inner
374#define TYPENAME long
375#define F_S_TO_PY PyLong_FromLong
376#define F_PY_TO_S PyLong_AsLong
377#define F_U_TO_PY PyLong_FromUnsignedLong
378#define F_PY_TO_U PyLong_AsUnsignedLong
Tim Peterse7c1f9b2001-06-14 00:55:41 +0000379
380#include "testcapi_long.h"
381
382static PyObject *
Fred Drakeacee69f2002-04-01 14:28:58 +0000383test_long_api(PyObject* self)
Tim Peterse7c1f9b2001-06-14 00:55:41 +0000384{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000385 return TESTNAME(raise_test_long_error);
Tim Peterse7c1f9b2001-06-14 00:55:41 +0000386}
387
388#undef TESTNAME
389#undef TYPENAME
390#undef F_S_TO_PY
391#undef F_PY_TO_S
392#undef F_U_TO_PY
393#undef F_PY_TO_U
Tim Peterse7c1f9b2001-06-14 00:55:41 +0000394
Tim Peters91621db2001-06-12 20:10:01 +0000395static PyObject *
Tim Petersd1a7da62001-06-13 00:35:57 +0000396raise_test_longlong_error(const char* msg)
397{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000398 return raiseTestError("test_longlong_api", msg);
Tim Petersd1a7da62001-06-13 00:35:57 +0000399}
400
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000401#define TESTNAME test_longlong_api_inner
Benjamin Petersonaf580df2016-09-06 10:46:49 -0700402#define TYPENAME long long
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000403#define F_S_TO_PY PyLong_FromLongLong
404#define F_PY_TO_S PyLong_AsLongLong
405#define F_U_TO_PY PyLong_FromUnsignedLongLong
406#define F_PY_TO_U PyLong_AsUnsignedLongLong
Tim Peterse7c1f9b2001-06-14 00:55:41 +0000407
408#include "testcapi_long.h"
Tim Petersd1a7da62001-06-13 00:35:57 +0000409
410static PyObject *
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000411test_longlong_api(PyObject* self, PyObject *args)
Tim Peters91621db2001-06-12 20:10:01 +0000412{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000413 return TESTNAME(raise_test_longlong_error);
Tim Peters91621db2001-06-12 20:10:01 +0000414}
415
Tim Peterse7c1f9b2001-06-14 00:55:41 +0000416#undef TESTNAME
417#undef TYPENAME
418#undef F_S_TO_PY
419#undef F_PY_TO_S
420#undef F_U_TO_PY
421#undef F_PY_TO_U
Tim Peterse7c1f9b2001-06-14 00:55:41 +0000422
Mark Dickinson309aa2d2009-12-21 12:37:06 +0000423/* Test the PyLong_AsLongAndOverflow API. General conversion to PY_LONG
424 is tested by test_long_api_inner. This test will concentrate on proper
425 handling of overflow.
426*/
427
428static PyObject *
429test_long_and_overflow(PyObject *self)
430{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000431 PyObject *num, *one, *temp;
432 long value;
433 int overflow;
Mark Dickinson309aa2d2009-12-21 12:37:06 +0000434
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000435 /* Test that overflow is set properly for a large value. */
436 /* num is a number larger than LONG_MAX even on 64-bit platforms */
437 num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
438 if (num == NULL)
439 return NULL;
440 overflow = 1234;
441 value = PyLong_AsLongAndOverflow(num, &overflow);
442 Py_DECREF(num);
443 if (value == -1 && PyErr_Occurred())
444 return NULL;
445 if (value != -1)
446 return raiseTestError("test_long_and_overflow",
447 "return value was not set to -1");
448 if (overflow != 1)
449 return raiseTestError("test_long_and_overflow",
450 "overflow was not set to 1");
Mark Dickinson309aa2d2009-12-21 12:37:06 +0000451
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000452 /* Same again, with num = LONG_MAX + 1 */
453 num = PyLong_FromLong(LONG_MAX);
454 if (num == NULL)
455 return NULL;
456 one = PyLong_FromLong(1L);
457 if (one == NULL) {
458 Py_DECREF(num);
459 return NULL;
460 }
461 temp = PyNumber_Add(num, one);
462 Py_DECREF(one);
463 Py_DECREF(num);
464 num = temp;
465 if (num == NULL)
466 return NULL;
467 overflow = 0;
468 value = PyLong_AsLongAndOverflow(num, &overflow);
469 Py_DECREF(num);
470 if (value == -1 && PyErr_Occurred())
471 return NULL;
472 if (value != -1)
473 return raiseTestError("test_long_and_overflow",
474 "return value was not set to -1");
475 if (overflow != 1)
476 return raiseTestError("test_long_and_overflow",
477 "overflow was not set to 1");
Mark Dickinson309aa2d2009-12-21 12:37:06 +0000478
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000479 /* Test that overflow is set properly for a large negative value. */
480 /* num is a number smaller than LONG_MIN even on 64-bit platforms */
481 num = PyLong_FromString("-FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
482 if (num == NULL)
483 return NULL;
484 overflow = 1234;
485 value = PyLong_AsLongAndOverflow(num, &overflow);
486 Py_DECREF(num);
487 if (value == -1 && PyErr_Occurred())
488 return NULL;
489 if (value != -1)
490 return raiseTestError("test_long_and_overflow",
491 "return value was not set to -1");
492 if (overflow != -1)
493 return raiseTestError("test_long_and_overflow",
494 "overflow was not set to -1");
Mark Dickinson309aa2d2009-12-21 12:37:06 +0000495
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000496 /* Same again, with num = LONG_MIN - 1 */
497 num = PyLong_FromLong(LONG_MIN);
498 if (num == NULL)
499 return NULL;
500 one = PyLong_FromLong(1L);
501 if (one == NULL) {
502 Py_DECREF(num);
503 return NULL;
504 }
505 temp = PyNumber_Subtract(num, one);
506 Py_DECREF(one);
507 Py_DECREF(num);
508 num = temp;
509 if (num == NULL)
510 return NULL;
511 overflow = 0;
512 value = PyLong_AsLongAndOverflow(num, &overflow);
513 Py_DECREF(num);
514 if (value == -1 && PyErr_Occurred())
515 return NULL;
516 if (value != -1)
517 return raiseTestError("test_long_and_overflow",
518 "return value was not set to -1");
519 if (overflow != -1)
520 return raiseTestError("test_long_and_overflow",
521 "overflow was not set to -1");
Mark Dickinson309aa2d2009-12-21 12:37:06 +0000522
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000523 /* Test that overflow is cleared properly for small values. */
524 num = PyLong_FromString("FF", NULL, 16);
525 if (num == NULL)
526 return NULL;
527 overflow = 1234;
528 value = PyLong_AsLongAndOverflow(num, &overflow);
529 Py_DECREF(num);
530 if (value == -1 && PyErr_Occurred())
531 return NULL;
532 if (value != 0xFF)
533 return raiseTestError("test_long_and_overflow",
534 "expected return value 0xFF");
535 if (overflow != 0)
536 return raiseTestError("test_long_and_overflow",
537 "overflow was not cleared");
Mark Dickinson309aa2d2009-12-21 12:37:06 +0000538
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000539 num = PyLong_FromString("-FF", NULL, 16);
540 if (num == NULL)
541 return NULL;
542 overflow = 0;
543 value = PyLong_AsLongAndOverflow(num, &overflow);
544 Py_DECREF(num);
545 if (value == -1 && PyErr_Occurred())
546 return NULL;
547 if (value != -0xFF)
548 return raiseTestError("test_long_and_overflow",
549 "expected return value 0xFF");
550 if (overflow != 0)
551 return raiseTestError("test_long_and_overflow",
552 "overflow was set incorrectly");
Mark Dickinson309aa2d2009-12-21 12:37:06 +0000553
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000554 num = PyLong_FromLong(LONG_MAX);
555 if (num == NULL)
556 return NULL;
557 overflow = 1234;
558 value = PyLong_AsLongAndOverflow(num, &overflow);
559 Py_DECREF(num);
560 if (value == -1 && PyErr_Occurred())
561 return NULL;
562 if (value != LONG_MAX)
563 return raiseTestError("test_long_and_overflow",
564 "expected return value LONG_MAX");
565 if (overflow != 0)
566 return raiseTestError("test_long_and_overflow",
567 "overflow was not cleared");
Mark Dickinson309aa2d2009-12-21 12:37:06 +0000568
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000569 num = PyLong_FromLong(LONG_MIN);
570 if (num == NULL)
571 return NULL;
572 overflow = 0;
573 value = PyLong_AsLongAndOverflow(num, &overflow);
574 Py_DECREF(num);
575 if (value == -1 && PyErr_Occurred())
576 return NULL;
577 if (value != LONG_MIN)
578 return raiseTestError("test_long_and_overflow",
579 "expected return value LONG_MIN");
580 if (overflow != 0)
581 return raiseTestError("test_long_and_overflow",
582 "overflow was not cleared");
Mark Dickinson309aa2d2009-12-21 12:37:06 +0000583
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000584 Py_INCREF(Py_None);
585 return Py_None;
Mark Dickinson309aa2d2009-12-21 12:37:06 +0000586}
587
Mark Dickinson93f562c2010-01-30 10:30:15 +0000588/* Test the PyLong_AsLongLongAndOverflow API. General conversion to
Benjamin Petersonaf580df2016-09-06 10:46:49 -0700589 long long is tested by test_long_api_inner. This test will
Mark Dickinson93f562c2010-01-30 10:30:15 +0000590 concentrate on proper handling of overflow.
591*/
592
593static PyObject *
594test_long_long_and_overflow(PyObject *self)
595{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000596 PyObject *num, *one, *temp;
Benjamin Petersonaf580df2016-09-06 10:46:49 -0700597 long long value;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000598 int overflow;
Mark Dickinson93f562c2010-01-30 10:30:15 +0000599
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000600 /* Test that overflow is set properly for a large value. */
601 /* num is a number larger than PY_LLONG_MAX on a typical machine. */
602 num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
603 if (num == NULL)
604 return NULL;
605 overflow = 1234;
606 value = PyLong_AsLongLongAndOverflow(num, &overflow);
607 Py_DECREF(num);
608 if (value == -1 && PyErr_Occurred())
609 return NULL;
610 if (value != -1)
611 return raiseTestError("test_long_long_and_overflow",
612 "return value was not set to -1");
613 if (overflow != 1)
614 return raiseTestError("test_long_long_and_overflow",
615 "overflow was not set to 1");
Mark Dickinson93f562c2010-01-30 10:30:15 +0000616
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000617 /* Same again, with num = PY_LLONG_MAX + 1 */
618 num = PyLong_FromLongLong(PY_LLONG_MAX);
619 if (num == NULL)
620 return NULL;
621 one = PyLong_FromLong(1L);
622 if (one == NULL) {
623 Py_DECREF(num);
624 return NULL;
625 }
626 temp = PyNumber_Add(num, one);
627 Py_DECREF(one);
628 Py_DECREF(num);
629 num = temp;
630 if (num == NULL)
631 return NULL;
632 overflow = 0;
633 value = PyLong_AsLongLongAndOverflow(num, &overflow);
634 Py_DECREF(num);
635 if (value == -1 && PyErr_Occurred())
636 return NULL;
637 if (value != -1)
638 return raiseTestError("test_long_long_and_overflow",
639 "return value was not set to -1");
640 if (overflow != 1)
641 return raiseTestError("test_long_long_and_overflow",
642 "overflow was not set to 1");
Mark Dickinson93f562c2010-01-30 10:30:15 +0000643
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000644 /* Test that overflow is set properly for a large negative value. */
645 /* num is a number smaller than PY_LLONG_MIN on a typical platform */
646 num = PyLong_FromString("-FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
647 if (num == NULL)
648 return NULL;
649 overflow = 1234;
650 value = PyLong_AsLongLongAndOverflow(num, &overflow);
651 Py_DECREF(num);
652 if (value == -1 && PyErr_Occurred())
653 return NULL;
654 if (value != -1)
655 return raiseTestError("test_long_long_and_overflow",
656 "return value was not set to -1");
657 if (overflow != -1)
658 return raiseTestError("test_long_long_and_overflow",
659 "overflow was not set to -1");
Mark Dickinson93f562c2010-01-30 10:30:15 +0000660
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000661 /* Same again, with num = PY_LLONG_MIN - 1 */
662 num = PyLong_FromLongLong(PY_LLONG_MIN);
663 if (num == NULL)
664 return NULL;
665 one = PyLong_FromLong(1L);
666 if (one == NULL) {
667 Py_DECREF(num);
668 return NULL;
669 }
670 temp = PyNumber_Subtract(num, one);
671 Py_DECREF(one);
672 Py_DECREF(num);
673 num = temp;
674 if (num == NULL)
675 return NULL;
676 overflow = 0;
677 value = PyLong_AsLongLongAndOverflow(num, &overflow);
678 Py_DECREF(num);
679 if (value == -1 && PyErr_Occurred())
680 return NULL;
681 if (value != -1)
682 return raiseTestError("test_long_long_and_overflow",
683 "return value was not set to -1");
684 if (overflow != -1)
685 return raiseTestError("test_long_long_and_overflow",
686 "overflow was not set to -1");
Mark Dickinson93f562c2010-01-30 10:30:15 +0000687
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000688 /* Test that overflow is cleared properly for small values. */
689 num = PyLong_FromString("FF", NULL, 16);
690 if (num == NULL)
691 return NULL;
692 overflow = 1234;
693 value = PyLong_AsLongLongAndOverflow(num, &overflow);
694 Py_DECREF(num);
695 if (value == -1 && PyErr_Occurred())
696 return NULL;
697 if (value != 0xFF)
698 return raiseTestError("test_long_long_and_overflow",
699 "expected return value 0xFF");
700 if (overflow != 0)
701 return raiseTestError("test_long_long_and_overflow",
702 "overflow was not cleared");
Mark Dickinson93f562c2010-01-30 10:30:15 +0000703
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000704 num = PyLong_FromString("-FF", NULL, 16);
705 if (num == NULL)
706 return NULL;
707 overflow = 0;
708 value = PyLong_AsLongLongAndOverflow(num, &overflow);
709 Py_DECREF(num);
710 if (value == -1 && PyErr_Occurred())
711 return NULL;
712 if (value != -0xFF)
713 return raiseTestError("test_long_long_and_overflow",
714 "expected return value 0xFF");
715 if (overflow != 0)
716 return raiseTestError("test_long_long_and_overflow",
717 "overflow was set incorrectly");
Mark Dickinson93f562c2010-01-30 10:30:15 +0000718
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000719 num = PyLong_FromLongLong(PY_LLONG_MAX);
720 if (num == NULL)
721 return NULL;
722 overflow = 1234;
723 value = PyLong_AsLongLongAndOverflow(num, &overflow);
724 Py_DECREF(num);
725 if (value == -1 && PyErr_Occurred())
726 return NULL;
727 if (value != PY_LLONG_MAX)
728 return raiseTestError("test_long_long_and_overflow",
729 "expected return value PY_LLONG_MAX");
730 if (overflow != 0)
731 return raiseTestError("test_long_long_and_overflow",
732 "overflow was not cleared");
Mark Dickinson93f562c2010-01-30 10:30:15 +0000733
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000734 num = PyLong_FromLongLong(PY_LLONG_MIN);
735 if (num == NULL)
736 return NULL;
737 overflow = 0;
738 value = PyLong_AsLongLongAndOverflow(num, &overflow);
739 Py_DECREF(num);
740 if (value == -1 && PyErr_Occurred())
741 return NULL;
742 if (value != PY_LLONG_MIN)
743 return raiseTestError("test_long_long_and_overflow",
744 "expected return value PY_LLONG_MIN");
745 if (overflow != 0)
746 return raiseTestError("test_long_long_and_overflow",
747 "overflow was not cleared");
Mark Dickinson93f562c2010-01-30 10:30:15 +0000748
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000749 Py_INCREF(Py_None);
750 return Py_None;
Mark Dickinson93f562c2010-01-30 10:30:15 +0000751}
752
Nadeem Vawda3d5881e2011-09-07 21:40:26 +0200753/* Test the PyLong_As{Size,Ssize}_t API. At present this just tests that
754 non-integer arguments are handled correctly. It should be extended to
755 test overflow handling.
756 */
757
758static PyObject *
759test_long_as_size_t(PyObject *self)
760{
761 size_t out_u;
762 Py_ssize_t out_s;
763
764 Py_INCREF(Py_None);
765
766 out_u = PyLong_AsSize_t(Py_None);
767 if (out_u != (size_t)-1 || !PyErr_Occurred())
768 return raiseTestError("test_long_as_size_t",
769 "PyLong_AsSize_t(None) didn't complain");
770 if (!PyErr_ExceptionMatches(PyExc_TypeError))
771 return raiseTestError("test_long_as_size_t",
772 "PyLong_AsSize_t(None) raised "
773 "something other than TypeError");
774 PyErr_Clear();
775
776 out_s = PyLong_AsSsize_t(Py_None);
777 if (out_s != (Py_ssize_t)-1 || !PyErr_Occurred())
778 return raiseTestError("test_long_as_size_t",
779 "PyLong_AsSsize_t(None) didn't complain");
780 if (!PyErr_ExceptionMatches(PyExc_TypeError))
781 return raiseTestError("test_long_as_size_t",
782 "PyLong_AsSsize_t(None) raised "
783 "something other than TypeError");
784 PyErr_Clear();
785
786 /* Py_INCREF(Py_None) omitted - we already have a reference to it. */
787 return Py_None;
788}
789
790/* Test the PyLong_AsDouble API. At present this just tests that
791 non-integer arguments are handled correctly.
792 */
793
794static PyObject *
795test_long_as_double(PyObject *self)
796{
797 double out;
798
799 Py_INCREF(Py_None);
800
801 out = PyLong_AsDouble(Py_None);
802 if (out != -1.0 || !PyErr_Occurred())
803 return raiseTestError("test_long_as_double",
804 "PyLong_AsDouble(None) didn't complain");
805 if (!PyErr_ExceptionMatches(PyExc_TypeError))
806 return raiseTestError("test_long_as_double",
807 "PyLong_AsDouble(None) raised "
808 "something other than TypeError");
809 PyErr_Clear();
810
811 /* Py_INCREF(Py_None) omitted - we already have a reference to it. */
812 return Py_None;
813}
814
Benjamin Petersonaf580df2016-09-06 10:46:49 -0700815/* Test the L code for PyArg_ParseTuple. This should deliver a long long
Tim Petersd38b1c72001-09-30 05:09:37 +0000816 for both long and int arguments. The test may leak a little memory if
817 it fails.
818*/
819static PyObject *
Fred Drakeacee69f2002-04-01 14:28:58 +0000820test_L_code(PyObject *self)
Tim Petersd38b1c72001-09-30 05:09:37 +0000821{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000822 PyObject *tuple, *num;
Benjamin Petersonaf580df2016-09-06 10:46:49 -0700823 long long value;
Tim Petersd38b1c72001-09-30 05:09:37 +0000824
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000825 tuple = PyTuple_New(1);
826 if (tuple == NULL)
827 return NULL;
Tim Petersd38b1c72001-09-30 05:09:37 +0000828
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000829 num = PyLong_FromLong(42);
830 if (num == NULL)
831 return NULL;
Tim Petersd38b1c72001-09-30 05:09:37 +0000832
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000833 PyTuple_SET_ITEM(tuple, 0, num);
Tim Petersd38b1c72001-09-30 05:09:37 +0000834
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000835 value = -1;
836 if (PyArg_ParseTuple(tuple, "L:test_L_code", &value) < 0)
837 return NULL;
838 if (value != 42)
839 return raiseTestError("test_L_code",
840 "L code returned wrong value for long 42");
Tim Petersd38b1c72001-09-30 05:09:37 +0000841
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000842 Py_DECREF(num);
843 num = PyLong_FromLong(42);
844 if (num == NULL)
845 return NULL;
Tim Petersd38b1c72001-09-30 05:09:37 +0000846
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000847 PyTuple_SET_ITEM(tuple, 0, num);
Tim Petersd38b1c72001-09-30 05:09:37 +0000848
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000849 value = -1;
850 if (PyArg_ParseTuple(tuple, "L:test_L_code", &value) < 0)
851 return NULL;
852 if (value != 42)
853 return raiseTestError("test_L_code",
854 "L code returned wrong value for int 42");
Tim Petersd38b1c72001-09-30 05:09:37 +0000855
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000856 Py_DECREF(tuple);
857 Py_INCREF(Py_None);
858 return Py_None;
Tim Petersd38b1c72001-09-30 05:09:37 +0000859}
860
Serhiy Storchakace412872016-05-08 23:36:44 +0300861static PyObject *
Serhiy Storchaka13e602e2016-05-20 22:31:14 +0300862return_none(void *unused)
863{
864 Py_RETURN_NONE;
865}
866
867static PyObject *
868raise_error(void *unused)
869{
870 PyErr_SetNone(PyExc_ValueError);
871 return NULL;
872}
873
874static int
875test_buildvalue_N_error(const char *fmt)
876{
877 PyObject *arg, *res;
878
879 arg = PyList_New(0);
880 if (arg == NULL) {
881 return -1;
882 }
883
884 Py_INCREF(arg);
885 res = Py_BuildValue(fmt, return_none, NULL, arg);
886 if (res == NULL) {
887 return -1;
888 }
889 Py_DECREF(res);
890 if (Py_REFCNT(arg) != 1) {
891 PyErr_Format(TestError, "test_buildvalue_N: "
892 "arg was not decrefed in successful "
893 "Py_BuildValue(\"%s\")", fmt);
894 return -1;
895 }
896
897 Py_INCREF(arg);
898 res = Py_BuildValue(fmt, raise_error, NULL, arg);
899 if (res != NULL || !PyErr_Occurred()) {
900 PyErr_Format(TestError, "test_buildvalue_N: "
901 "Py_BuildValue(\"%s\") didn't complain", fmt);
902 return -1;
903 }
904 PyErr_Clear();
905 if (Py_REFCNT(arg) != 1) {
906 PyErr_Format(TestError, "test_buildvalue_N: "
907 "arg was not decrefed in failed "
908 "Py_BuildValue(\"%s\")", fmt);
909 return -1;
910 }
911 Py_DECREF(arg);
912 return 0;
913}
914
915static PyObject *
916test_buildvalue_N(PyObject *self, PyObject *noargs)
917{
918 PyObject *arg, *res;
919
920 arg = PyList_New(0);
921 if (arg == NULL) {
922 return NULL;
923 }
924 Py_INCREF(arg);
925 res = Py_BuildValue("N", arg);
926 if (res == NULL) {
927 return NULL;
928 }
929 if (res != arg) {
930 return raiseTestError("test_buildvalue_N",
931 "Py_BuildValue(\"N\") returned wrong result");
932 }
933 if (Py_REFCNT(arg) != 2) {
934 return raiseTestError("test_buildvalue_N",
935 "arg was not decrefed in Py_BuildValue(\"N\")");
936 }
937 Py_DECREF(res);
938 Py_DECREF(arg);
939
940 if (test_buildvalue_N_error("O&N") < 0)
941 return NULL;
942 if (test_buildvalue_N_error("(O&N)") < 0)
943 return NULL;
944 if (test_buildvalue_N_error("[O&N]") < 0)
945 return NULL;
946 if (test_buildvalue_N_error("{O&N}") < 0)
947 return NULL;
948 if (test_buildvalue_N_error("{()O&(())N}") < 0)
949 return NULL;
950
951 Py_RETURN_NONE;
952}
953
954
955static PyObject *
Serhiy Storchakace412872016-05-08 23:36:44 +0300956get_args(PyObject *self, PyObject *args)
957{
958 if (args == NULL) {
959 args = Py_None;
960 }
961 Py_INCREF(args);
962 return args;
963}
964
965static PyObject *
966get_kwargs(PyObject *self, PyObject *args, PyObject *kwargs)
967{
968 if (kwargs == NULL) {
969 kwargs = Py_None;
970 }
971 Py_INCREF(kwargs);
972 return kwargs;
973}
974
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000975/* Test tuple argument processing */
976static PyObject *
977getargs_tuple(PyObject *self, PyObject *args)
978{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000979 int a, b, c;
980 if (!PyArg_ParseTuple(args, "i(ii)", &a, &b, &c))
981 return NULL;
982 return Py_BuildValue("iii", a, b, c);
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000983}
984
Christian Heimes380f7f22008-02-28 11:19:05 +0000985/* test PyArg_ParseTupleAndKeywords */
Larry Hastings83a9f482012-03-20 20:06:16 +0000986static PyObject *
987getargs_keywords(PyObject *self, PyObject *args, PyObject *kwargs)
Christian Heimes380f7f22008-02-28 11:19:05 +0000988{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000989 static char *keywords[] = {"arg1","arg2","arg3","arg4","arg5", NULL};
Serhiy Storchaka2d06e842015-12-25 19:53:18 +0200990 static const char fmt[] = "(ii)i|(i(ii))(iii)i";
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000991 int int_args[10]={-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
Christian Heimes380f7f22008-02-28 11:19:05 +0000992
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000993 if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,
994 &int_args[0], &int_args[1], &int_args[2], &int_args[3], &int_args[4],
995 &int_args[5], &int_args[6], &int_args[7], &int_args[8], &int_args[9]))
996 return NULL;
997 return Py_BuildValue("iiiiiiiiii",
998 int_args[0], int_args[1], int_args[2], int_args[3], int_args[4],
999 int_args[5], int_args[6], int_args[7], int_args[8], int_args[9]);
Christian Heimes380f7f22008-02-28 11:19:05 +00001000}
1001
Larry Hastings83a9f482012-03-20 20:06:16 +00001002/* test PyArg_ParseTupleAndKeywords keyword-only arguments */
1003static PyObject *
1004getargs_keyword_only(PyObject *self, PyObject *args, PyObject *kwargs)
1005{
1006 static char *keywords[] = {"required", "optional", "keyword_only", NULL};
1007 int required = -1;
1008 int optional = -1;
1009 int keyword_only = -1;
1010
1011 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|i$i", keywords,
1012 &required, &optional, &keyword_only))
1013 return NULL;
1014 return Py_BuildValue("iii", required, optional, keyword_only);
1015}
1016
Serhiy Storchakaf41b82f2016-06-09 16:30:29 +03001017/* test PyArg_ParseTupleAndKeywords positional-only arguments */
1018static PyObject *
1019getargs_positional_only_and_keywords(PyObject *self, PyObject *args, PyObject *kwargs)
1020{
1021 static char *keywords[] = {"", "", "keyword", NULL};
1022 int required = -1;
1023 int optional = -1;
1024 int keyword = -1;
1025
1026 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|ii", keywords,
1027 &required, &optional, &keyword))
1028 return NULL;
1029 return Py_BuildValue("iii", required, optional, keyword);
1030}
1031
Thomas Heller3457e4b2003-04-24 16:14:27 +00001032/* Functions to call PyArg_ParseTuple with integer format codes,
1033 and return the result.
1034*/
Thomas Hellera4ea6032003-04-17 18:55:45 +00001035static PyObject *
Thomas Heller3457e4b2003-04-24 16:14:27 +00001036getargs_b(PyObject *self, PyObject *args)
Thomas Hellera4ea6032003-04-17 18:55:45 +00001037{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001038 unsigned char value;
1039 if (!PyArg_ParseTuple(args, "b", &value))
1040 return NULL;
1041 return PyLong_FromUnsignedLong((unsigned long)value);
Thomas Hellera4ea6032003-04-17 18:55:45 +00001042}
1043
Thomas Heller3457e4b2003-04-24 16:14:27 +00001044static PyObject *
1045getargs_B(PyObject *self, PyObject *args)
1046{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001047 unsigned char value;
1048 if (!PyArg_ParseTuple(args, "B", &value))
1049 return NULL;
1050 return PyLong_FromUnsignedLong((unsigned long)value);
Thomas Heller3457e4b2003-04-24 16:14:27 +00001051}
1052
1053static PyObject *
Mark Dickinson1554b182009-12-20 16:03:30 +00001054getargs_h(PyObject *self, PyObject *args)
1055{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001056 short value;
1057 if (!PyArg_ParseTuple(args, "h", &value))
1058 return NULL;
1059 return PyLong_FromLong((long)value);
Mark Dickinson1554b182009-12-20 16:03:30 +00001060}
1061
1062static PyObject *
Thomas Heller3457e4b2003-04-24 16:14:27 +00001063getargs_H(PyObject *self, PyObject *args)
1064{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001065 unsigned short value;
1066 if (!PyArg_ParseTuple(args, "H", &value))
1067 return NULL;
1068 return PyLong_FromUnsignedLong((unsigned long)value);
Thomas Heller3457e4b2003-04-24 16:14:27 +00001069}
1070
1071static PyObject *
1072getargs_I(PyObject *self, PyObject *args)
1073{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001074 unsigned int value;
1075 if (!PyArg_ParseTuple(args, "I", &value))
1076 return NULL;
1077 return PyLong_FromUnsignedLong((unsigned long)value);
Thomas Heller3457e4b2003-04-24 16:14:27 +00001078}
1079
1080static PyObject *
1081getargs_k(PyObject *self, PyObject *args)
1082{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001083 unsigned long value;
1084 if (!PyArg_ParseTuple(args, "k", &value))
1085 return NULL;
1086 return PyLong_FromUnsignedLong(value);
Thomas Heller3457e4b2003-04-24 16:14:27 +00001087}
1088
1089static PyObject *
1090getargs_i(PyObject *self, PyObject *args)
1091{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001092 int value;
1093 if (!PyArg_ParseTuple(args, "i", &value))
1094 return NULL;
1095 return PyLong_FromLong((long)value);
Thomas Heller3457e4b2003-04-24 16:14:27 +00001096}
1097
Thomas Hellera4ea6032003-04-17 18:55:45 +00001098static PyObject *
1099getargs_l(PyObject *self, PyObject *args)
1100{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001101 long value;
1102 if (!PyArg_ParseTuple(args, "l", &value))
1103 return NULL;
1104 return PyLong_FromLong(value);
Thomas Hellera4ea6032003-04-17 18:55:45 +00001105}
1106
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001107static PyObject *
1108getargs_n(PyObject *self, PyObject *args)
1109{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001110 Py_ssize_t value;
1111 if (!PyArg_ParseTuple(args, "n", &value))
1112 return NULL;
1113 return PyLong_FromSsize_t(value);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001114}
1115
Larry Hastingsfaf91e72012-05-05 16:54:29 -07001116static PyObject *
1117getargs_p(PyObject *self, PyObject *args)
1118{
1119 int value;
1120 if (!PyArg_ParseTuple(args, "p", &value))
1121 return NULL;
1122 return PyLong_FromLong(value);
1123}
1124
Thomas Hellera4ea6032003-04-17 18:55:45 +00001125static PyObject *
Thomas Heller3457e4b2003-04-24 16:14:27 +00001126getargs_L(PyObject *self, PyObject *args)
Thomas Hellera4ea6032003-04-17 18:55:45 +00001127{
Benjamin Petersonaf580df2016-09-06 10:46:49 -07001128 long long value;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001129 if (!PyArg_ParseTuple(args, "L", &value))
1130 return NULL;
1131 return PyLong_FromLongLong(value);
Thomas Hellera4ea6032003-04-17 18:55:45 +00001132}
1133
Thomas Hellera4ea6032003-04-17 18:55:45 +00001134static PyObject *
Thomas Heller3457e4b2003-04-24 16:14:27 +00001135getargs_K(PyObject *self, PyObject *args)
Thomas Hellera4ea6032003-04-17 18:55:45 +00001136{
Benjamin Petersonaf580df2016-09-06 10:46:49 -07001137 unsigned long long value;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001138 if (!PyArg_ParseTuple(args, "K", &value))
1139 return NULL;
1140 return PyLong_FromUnsignedLongLong(value);
Thomas Hellera4ea6032003-04-17 18:55:45 +00001141}
Thomas Hellera4ea6032003-04-17 18:55:45 +00001142
1143/* This function not only tests the 'k' getargs code, but also the
Christian Heimes217cfd12007-12-02 14:31:20 +00001144 PyLong_AsUnsignedLongMask() and PyLong_AsUnsignedLongMask() functions. */
Thomas Hellera4ea6032003-04-17 18:55:45 +00001145static PyObject *
1146test_k_code(PyObject *self)
1147{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001148 PyObject *tuple, *num;
1149 unsigned long value;
Thomas Hellera4ea6032003-04-17 18:55:45 +00001150
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001151 tuple = PyTuple_New(1);
1152 if (tuple == NULL)
1153 return NULL;
Thomas Hellera4ea6032003-04-17 18:55:45 +00001154
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001155 /* a number larger than ULONG_MAX even on 64-bit platforms */
1156 num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
1157 if (num == NULL)
1158 return NULL;
Thomas Hellera4ea6032003-04-17 18:55:45 +00001159
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001160 value = PyLong_AsUnsignedLongMask(num);
1161 if (value != ULONG_MAX)
1162 return raiseTestError("test_k_code",
Georg Brandl4b5b0622016-01-18 08:00:15 +01001163 "PyLong_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
Thomas Hellera4ea6032003-04-17 18:55:45 +00001164
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001165 PyTuple_SET_ITEM(tuple, 0, num);
Thomas Hellera4ea6032003-04-17 18:55:45 +00001166
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001167 value = 0;
1168 if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)
1169 return NULL;
1170 if (value != ULONG_MAX)
1171 return raiseTestError("test_k_code",
1172 "k code returned wrong value for long 0xFFF...FFF");
Thomas Hellera4ea6032003-04-17 18:55:45 +00001173
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001174 Py_DECREF(num);
1175 num = PyLong_FromString("-FFFFFFFF000000000000000042", NULL, 16);
1176 if (num == NULL)
1177 return NULL;
Thomas Hellera4ea6032003-04-17 18:55:45 +00001178
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001179 value = PyLong_AsUnsignedLongMask(num);
1180 if (value != (unsigned long)-0x42)
1181 return raiseTestError("test_k_code",
Georg Brandl4b5b0622016-01-18 08:00:15 +01001182 "PyLong_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
Thomas Hellera4ea6032003-04-17 18:55:45 +00001183
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001184 PyTuple_SET_ITEM(tuple, 0, num);
Thomas Hellera4ea6032003-04-17 18:55:45 +00001185
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001186 value = 0;
1187 if (PyArg_ParseTuple(tuple, "k:test_k_code", &value) < 0)
1188 return NULL;
1189 if (value != (unsigned long)-0x42)
1190 return raiseTestError("test_k_code",
1191 "k code returned wrong value for long -0xFFF..000042");
Thomas Hellera4ea6032003-04-17 18:55:45 +00001192
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001193 Py_DECREF(tuple);
1194 Py_INCREF(Py_None);
1195 return Py_None;
Thomas Hellera4ea6032003-04-17 18:55:45 +00001196}
1197
Victor Stinner06e49dd2010-06-13 18:21:50 +00001198static PyObject *
Serhiy Storchakaf95455d2016-05-16 10:11:47 +03001199getargs_f(PyObject *self, PyObject *args)
1200{
1201 float f;
1202 if (!PyArg_ParseTuple(args, "f", &f))
1203 return NULL;
1204 return PyFloat_FromDouble(f);
1205}
1206
1207static PyObject *
1208getargs_d(PyObject *self, PyObject *args)
1209{
1210 double d;
1211 if (!PyArg_ParseTuple(args, "d", &d))
1212 return NULL;
1213 return PyFloat_FromDouble(d);
1214}
1215
1216static PyObject *
1217getargs_D(PyObject *self, PyObject *args)
1218{
1219 Py_complex cval;
1220 if (!PyArg_ParseTuple(args, "D", &cval))
1221 return NULL;
1222 return PyComplex_FromCComplex(cval);
1223}
1224
1225static PyObject *
1226getargs_S(PyObject *self, PyObject *args)
1227{
1228 PyObject *obj;
1229 if (!PyArg_ParseTuple(args, "S", &obj))
1230 return NULL;
1231 Py_INCREF(obj);
1232 return obj;
1233}
1234
1235static PyObject *
1236getargs_Y(PyObject *self, PyObject *args)
1237{
1238 PyObject *obj;
1239 if (!PyArg_ParseTuple(args, "Y", &obj))
1240 return NULL;
1241 Py_INCREF(obj);
1242 return obj;
1243}
1244
1245static PyObject *
1246getargs_U(PyObject *self, PyObject *args)
1247{
1248 PyObject *obj;
1249 if (!PyArg_ParseTuple(args, "U", &obj))
1250 return NULL;
1251 Py_INCREF(obj);
1252 return obj;
1253}
1254
1255static PyObject *
Eli Bendersky906b88f2011-07-29 07:05:08 +03001256getargs_c(PyObject *self, PyObject *args)
1257{
1258 char c;
1259 if (!PyArg_ParseTuple(args, "c", &c))
1260 return NULL;
Serhiy Storchakac8241fd2016-01-28 19:49:54 +02001261 return PyLong_FromLong((unsigned char)c);
1262}
1263
1264static PyObject *
1265getargs_C(PyObject *self, PyObject *args)
1266{
1267 int c;
1268 if (!PyArg_ParseTuple(args, "C", &c))
1269 return NULL;
1270 return PyLong_FromLong(c);
Eli Bendersky906b88f2011-07-29 07:05:08 +03001271}
1272
1273static PyObject *
Victor Stinner06e49dd2010-06-13 18:21:50 +00001274getargs_s(PyObject *self, PyObject *args)
1275{
1276 char *str;
1277 if (!PyArg_ParseTuple(args, "s", &str))
1278 return NULL;
1279 return PyBytes_FromString(str);
1280}
1281
1282static PyObject *
1283getargs_s_star(PyObject *self, PyObject *args)
1284{
1285 Py_buffer buffer;
1286 PyObject *bytes;
1287 if (!PyArg_ParseTuple(args, "s*", &buffer))
1288 return NULL;
1289 bytes = PyBytes_FromStringAndSize(buffer.buf, buffer.len);
1290 PyBuffer_Release(&buffer);
1291 return bytes;
1292}
1293
1294static PyObject *
1295getargs_s_hash(PyObject *self, PyObject *args)
1296{
1297 char *str;
1298 Py_ssize_t size;
1299 if (!PyArg_ParseTuple(args, "s#", &str, &size))
1300 return NULL;
1301 return PyBytes_FromStringAndSize(str, size);
1302}
1303
1304static PyObject *
1305getargs_z(PyObject *self, PyObject *args)
1306{
1307 char *str;
1308 if (!PyArg_ParseTuple(args, "z", &str))
1309 return NULL;
1310 if (str != NULL)
1311 return PyBytes_FromString(str);
1312 else
1313 Py_RETURN_NONE;
1314}
1315
1316static PyObject *
1317getargs_z_star(PyObject *self, PyObject *args)
1318{
1319 Py_buffer buffer;
1320 PyObject *bytes;
1321 if (!PyArg_ParseTuple(args, "z*", &buffer))
1322 return NULL;
1323 if (buffer.buf != NULL)
1324 bytes = PyBytes_FromStringAndSize(buffer.buf, buffer.len);
1325 else {
1326 Py_INCREF(Py_None);
1327 bytes = Py_None;
1328 }
1329 PyBuffer_Release(&buffer);
1330 return bytes;
1331}
1332
1333static PyObject *
1334getargs_z_hash(PyObject *self, PyObject *args)
1335{
1336 char *str;
1337 Py_ssize_t size;
1338 if (!PyArg_ParseTuple(args, "z#", &str, &size))
1339 return NULL;
1340 if (str != NULL)
1341 return PyBytes_FromStringAndSize(str, size);
1342 else
1343 Py_RETURN_NONE;
1344}
1345
1346static PyObject *
1347getargs_y(PyObject *self, PyObject *args)
1348{
1349 char *str;
1350 if (!PyArg_ParseTuple(args, "y", &str))
1351 return NULL;
1352 return PyBytes_FromString(str);
1353}
1354
1355static PyObject *
1356getargs_y_star(PyObject *self, PyObject *args)
1357{
1358 Py_buffer buffer;
1359 PyObject *bytes;
1360 if (!PyArg_ParseTuple(args, "y*", &buffer))
1361 return NULL;
1362 bytes = PyBytes_FromStringAndSize(buffer.buf, buffer.len);
1363 PyBuffer_Release(&buffer);
1364 return bytes;
1365}
1366
1367static PyObject *
1368getargs_y_hash(PyObject *self, PyObject *args)
1369{
1370 char *str;
1371 Py_ssize_t size;
1372 if (!PyArg_ParseTuple(args, "y#", &str, &size))
1373 return NULL;
1374 return PyBytes_FromStringAndSize(str, size);
1375}
1376
1377static PyObject *
1378getargs_u(PyObject *self, PyObject *args)
1379{
1380 Py_UNICODE *str;
1381 Py_ssize_t size;
1382 if (!PyArg_ParseTuple(args, "u", &str))
1383 return NULL;
1384 size = Py_UNICODE_strlen(str);
1385 return PyUnicode_FromUnicode(str, size);
1386}
1387
1388static PyObject *
1389getargs_u_hash(PyObject *self, PyObject *args)
1390{
1391 Py_UNICODE *str;
1392 Py_ssize_t size;
1393 if (!PyArg_ParseTuple(args, "u#", &str, &size))
1394 return NULL;
1395 return PyUnicode_FromUnicode(str, size);
1396}
1397
1398static PyObject *
1399getargs_Z(PyObject *self, PyObject *args)
1400{
1401 Py_UNICODE *str;
1402 Py_ssize_t size;
1403 if (!PyArg_ParseTuple(args, "Z", &str))
1404 return NULL;
1405 if (str != NULL) {
1406 size = Py_UNICODE_strlen(str);
1407 return PyUnicode_FromUnicode(str, size);
1408 } else
1409 Py_RETURN_NONE;
1410}
1411
1412static PyObject *
1413getargs_Z_hash(PyObject *self, PyObject *args)
1414{
1415 Py_UNICODE *str;
1416 Py_ssize_t size;
1417 if (!PyArg_ParseTuple(args, "Z#", &str, &size))
1418 return NULL;
1419 if (str != NULL)
1420 return PyUnicode_FromUnicode(str, size);
1421 else
1422 Py_RETURN_NONE;
1423}
Marc-André Lemburg3e3eacb2002-01-09 16:21:27 +00001424
Serhiy Storchakac8241fd2016-01-28 19:49:54 +02001425static PyObject *
1426getargs_es(PyObject *self, PyObject *args)
1427{
1428 PyObject *arg, *result;
1429 const char *encoding = NULL;
1430 char *str;
1431
1432 if (!PyArg_ParseTuple(args, "O|s", &arg, &encoding))
1433 return NULL;
1434 if (!PyArg_Parse(arg, "es", encoding, &str))
1435 return NULL;
1436 result = PyBytes_FromString(str);
1437 PyMem_Free(str);
1438 return result;
1439}
1440
1441static PyObject *
1442getargs_et(PyObject *self, PyObject *args)
1443{
1444 PyObject *arg, *result;
1445 const char *encoding = NULL;
1446 char *str;
1447
1448 if (!PyArg_ParseTuple(args, "O|s", &arg, &encoding))
1449 return NULL;
1450 if (!PyArg_Parse(arg, "et", encoding, &str))
1451 return NULL;
1452 result = PyBytes_FromString(str);
1453 PyMem_Free(str);
1454 return result;
1455}
1456
1457static PyObject *
1458getargs_es_hash(PyObject *self, PyObject *args)
1459{
1460 PyObject *arg, *result;
1461 const char *encoding = NULL;
1462 PyByteArrayObject *buffer = NULL;
1463 char *str = NULL;
1464 Py_ssize_t size;
1465
1466 if (!PyArg_ParseTuple(args, "O|sY", &arg, &encoding, &buffer))
1467 return NULL;
1468 if (buffer != NULL) {
1469 str = PyByteArray_AS_STRING(buffer);
1470 size = PyByteArray_GET_SIZE(buffer);
1471 }
1472 if (!PyArg_Parse(arg, "es#", encoding, &str, &size))
1473 return NULL;
1474 result = PyBytes_FromStringAndSize(str, size);
1475 if (buffer == NULL)
1476 PyMem_Free(str);
1477 return result;
1478}
1479
1480static PyObject *
1481getargs_et_hash(PyObject *self, PyObject *args)
1482{
1483 PyObject *arg, *result;
1484 const char *encoding = NULL;
1485 PyByteArrayObject *buffer = NULL;
1486 char *str = NULL;
1487 Py_ssize_t size;
1488
1489 if (!PyArg_ParseTuple(args, "O|sY", &arg, &encoding, &buffer))
1490 return NULL;
1491 if (buffer != NULL) {
1492 str = PyByteArray_AS_STRING(buffer);
1493 size = PyByteArray_GET_SIZE(buffer);
1494 }
1495 if (!PyArg_Parse(arg, "et#", encoding, &str, &size))
1496 return NULL;
1497 result = PyBytes_FromStringAndSize(str, size);
1498 if (buffer == NULL)
1499 PyMem_Free(str);
1500 return result;
1501}
1502
Amaury Forgeot d'Arc07404592008-05-12 13:19:07 +00001503/* Test the s and z codes for PyArg_ParseTuple.
1504*/
1505static PyObject *
1506test_s_code(PyObject *self)
1507{
1508 /* Unicode strings should be accepted */
1509 PyObject *tuple, *obj;
1510 char *value;
1511
1512 tuple = PyTuple_New(1);
1513 if (tuple == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001514 return NULL;
Amaury Forgeot d'Arc07404592008-05-12 13:19:07 +00001515
1516 obj = PyUnicode_Decode("t\xeate", strlen("t\xeate"),
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001517 "latin-1", NULL);
Amaury Forgeot d'Arc07404592008-05-12 13:19:07 +00001518 if (obj == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001519 return NULL;
Amaury Forgeot d'Arc07404592008-05-12 13:19:07 +00001520
1521 PyTuple_SET_ITEM(tuple, 0, obj);
1522
1523 /* These two blocks used to raise a TypeError:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001524 * "argument must be string without null bytes, not str"
Amaury Forgeot d'Arc07404592008-05-12 13:19:07 +00001525 */
1526 if (PyArg_ParseTuple(tuple, "s:test_s_code1", &value) < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001527 return NULL;
Amaury Forgeot d'Arc07404592008-05-12 13:19:07 +00001528
1529 if (PyArg_ParseTuple(tuple, "z:test_s_code2", &value) < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001530 return NULL;
Amaury Forgeot d'Arc07404592008-05-12 13:19:07 +00001531
Alexandre Vassalottib645bc72008-05-15 22:06:59 +00001532 Py_DECREF(tuple);
Amaury Forgeot d'Arc07404592008-05-12 13:19:07 +00001533 Py_RETURN_NONE;
1534}
1535
Mark Dickinsonf08173b2009-12-03 10:59:46 +00001536static PyObject *
Larry Hastings8f904da2012-06-22 03:56:29 -07001537parse_tuple_and_keywords(PyObject *self, PyObject *args)
Mark Dickinsonf08173b2009-12-03 10:59:46 +00001538{
Larry Hastings8f904da2012-06-22 03:56:29 -07001539 PyObject *sub_args;
1540 PyObject *sub_kwargs;
1541 char *sub_format;
1542 PyObject *sub_keywords;
Mark Dickinsonf08173b2009-12-03 10:59:46 +00001543
Larry Hastings8f904da2012-06-22 03:56:29 -07001544 Py_ssize_t i, size;
1545 char *keywords[8 + 1]; /* space for NULL at end */
1546 PyObject *o;
1547 PyObject *converted[8];
Mark Dickinsonf08173b2009-12-03 10:59:46 +00001548
Larry Hastings8f904da2012-06-22 03:56:29 -07001549 int result;
1550 PyObject *return_value = NULL;
Mark Dickinsonf08173b2009-12-03 10:59:46 +00001551
Larry Hastings22701e82012-08-08 14:52:22 -07001552 double buffers[8][4]; /* double ensures alignment where necessary */
Mark Dickinsonf08173b2009-12-03 10:59:46 +00001553
Larry Hastings8f904da2012-06-22 03:56:29 -07001554 if (!PyArg_ParseTuple(args, "OOyO:parse_tuple_and_keywords",
1555 &sub_args, &sub_kwargs,
1556 &sub_format, &sub_keywords))
1557 return NULL;
Mark Dickinsonf08173b2009-12-03 10:59:46 +00001558
Larry Hastings8f904da2012-06-22 03:56:29 -07001559 if (!(PyList_CheckExact(sub_keywords) || PyTuple_CheckExact(sub_keywords))) {
1560 PyErr_SetString(PyExc_ValueError,
1561 "parse_tuple_and_keywords: sub_keywords must be either list or tuple");
1562 return NULL;
1563 }
1564
1565 memset(buffers, 0, sizeof(buffers));
1566 memset(converted, 0, sizeof(converted));
1567 memset(keywords, 0, sizeof(keywords));
1568
1569 size = PySequence_Fast_GET_SIZE(sub_keywords);
1570 if (size > 8) {
1571 PyErr_SetString(PyExc_ValueError,
1572 "parse_tuple_and_keywords: too many keywords in sub_keywords");
1573 goto exit;
1574 }
1575
1576 for (i = 0; i < size; i++) {
1577 o = PySequence_Fast_GET_ITEM(sub_keywords, i);
1578 if (!PyUnicode_FSConverter(o, (void *)(converted + i))) {
1579 PyErr_Format(PyExc_ValueError,
Jesus Cea6e1d2b62012-10-04 16:06:30 +02001580 "parse_tuple_and_keywords: could not convert keywords[%zd] to narrow string", i);
Larry Hastings8f904da2012-06-22 03:56:29 -07001581 goto exit;
1582 }
1583 keywords[i] = PyBytes_AS_STRING(converted[i]);
1584 }
1585
1586 result = PyArg_ParseTupleAndKeywords(sub_args, sub_kwargs,
1587 sub_format, keywords,
1588 buffers + 0, buffers + 1, buffers + 2, buffers + 3,
1589 buffers + 4, buffers + 5, buffers + 6, buffers + 7);
1590
1591 if (result) {
1592 return_value = Py_None;
1593 Py_INCREF(Py_None);
1594 }
1595
1596exit:
1597 size = sizeof(converted) / sizeof(converted[0]);
1598 for (i = 0; i < size; i++) {
1599 Py_XDECREF(converted[i]);
1600 }
1601 return return_value;
Mark Dickinsonf08173b2009-12-03 10:59:46 +00001602}
1603
Benjamin Peterson92035012008-12-27 16:00:54 +00001604static volatile int x;
1605
Marc-André Lemburg3e3eacb2002-01-09 16:21:27 +00001606/* Test the u and u# codes for PyArg_ParseTuple. May leak memory in case
1607 of an error.
1608*/
1609static PyObject *
Fred Drakeacee69f2002-04-01 14:28:58 +00001610test_u_code(PyObject *self)
Marc-André Lemburg3e3eacb2002-01-09 16:21:27 +00001611{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001612 PyObject *tuple, *obj;
1613 Py_UNICODE *value;
1614 Py_ssize_t len;
Marc-André Lemburg3e3eacb2002-01-09 16:21:27 +00001615
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001616 /* issue4122: Undefined reference to _Py_ascii_whitespace on Windows */
1617 /* Just use the macro and check that it compiles */
1618 x = Py_UNICODE_ISSPACE(25);
Benjamin Peterson206e3072008-10-19 14:07:49 +00001619
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001620 tuple = PyTuple_New(1);
1621 if (tuple == NULL)
1622 return NULL;
Marc-André Lemburg3e3eacb2002-01-09 16:21:27 +00001623
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001624 obj = PyUnicode_Decode("test", strlen("test"),
1625 "ascii", NULL);
1626 if (obj == NULL)
1627 return NULL;
Marc-André Lemburg3e3eacb2002-01-09 16:21:27 +00001628
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001629 PyTuple_SET_ITEM(tuple, 0, obj);
Marc-André Lemburg3e3eacb2002-01-09 16:21:27 +00001630
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001631 value = 0;
1632 if (PyArg_ParseTuple(tuple, "u:test_u_code", &value) < 0)
1633 return NULL;
1634 if (value != PyUnicode_AS_UNICODE(obj))
1635 return raiseTestError("test_u_code",
1636 "u code returned wrong value for u'test'");
1637 value = 0;
1638 if (PyArg_ParseTuple(tuple, "u#:test_u_code", &value, &len) < 0)
1639 return NULL;
1640 if (value != PyUnicode_AS_UNICODE(obj) ||
1641 len != PyUnicode_GET_SIZE(obj))
1642 return raiseTestError("test_u_code",
1643 "u# code returned wrong values for u'test'");
Tim Petersbaefd9e2003-01-28 20:37:45 +00001644
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001645 Py_DECREF(tuple);
1646 Py_INCREF(Py_None);
1647 return Py_None;
Marc-André Lemburg3e3eacb2002-01-09 16:21:27 +00001648}
1649
Guido van Rossumfb67be22007-08-29 18:38:11 +00001650/* Test Z and Z# codes for PyArg_ParseTuple */
1651static PyObject *
1652test_Z_code(PyObject *self)
1653{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001654 PyObject *tuple, *obj;
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02001655 const Py_UNICODE *value1, *value2;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001656 Py_ssize_t len1, len2;
Guido van Rossumfb67be22007-08-29 18:38:11 +00001657
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001658 tuple = PyTuple_New(2);
1659 if (tuple == NULL)
1660 return NULL;
Guido van Rossumfb67be22007-08-29 18:38:11 +00001661
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001662 obj = PyUnicode_FromString("test");
1663 PyTuple_SET_ITEM(tuple, 0, obj);
1664 Py_INCREF(Py_None);
1665 PyTuple_SET_ITEM(tuple, 1, Py_None);
Guido van Rossumfb67be22007-08-29 18:38:11 +00001666
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001667 /* swap values on purpose */
1668 value1 = NULL;
1669 value2 = PyUnicode_AS_UNICODE(obj);
Guido van Rossumfb67be22007-08-29 18:38:11 +00001670
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001671 /* Test Z for both values */
1672 if (PyArg_ParseTuple(tuple, "ZZ:test_Z_code", &value1, &value2) < 0)
1673 return NULL;
1674 if (value1 != PyUnicode_AS_UNICODE(obj))
1675 return raiseTestError("test_Z_code",
1676 "Z code returned wrong value for 'test'");
1677 if (value2 != NULL)
1678 return raiseTestError("test_Z_code",
1679 "Z code returned wrong value for None");
Guido van Rossumfb67be22007-08-29 18:38:11 +00001680
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001681 value1 = NULL;
1682 value2 = PyUnicode_AS_UNICODE(obj);
1683 len1 = -1;
1684 len2 = -1;
Guido van Rossumfb67be22007-08-29 18:38:11 +00001685
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001686 /* Test Z# for both values */
1687 if (PyArg_ParseTuple(tuple, "Z#Z#:test_Z_code", &value1, &len1,
1688 &value2, &len2) < 0)
1689 return NULL;
1690 if (value1 != PyUnicode_AS_UNICODE(obj) ||
1691 len1 != PyUnicode_GET_SIZE(obj))
1692 return raiseTestError("test_Z_code",
1693 "Z# code returned wrong values for 'test'");
1694 if (value2 != NULL ||
1695 len2 != 0)
1696 return raiseTestError("test_Z_code",
1697 "Z# code returned wrong values for None'");
Guido van Rossumfb67be22007-08-29 18:38:11 +00001698
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001699 Py_DECREF(tuple);
1700 Py_RETURN_NONE;
Guido van Rossumfb67be22007-08-29 18:38:11 +00001701}
1702
Thomas Wouters477c8d52006-05-27 19:21:47 +00001703static PyObject *
Mark Dickinson081dfee2009-03-18 14:47:41 +00001704test_widechar(PyObject *self)
1705{
1706#if defined(SIZEOF_WCHAR_T) && (SIZEOF_WCHAR_T == 4)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001707 const wchar_t wtext[2] = {(wchar_t)0x10ABCDu};
1708 size_t wtextlen = 1;
Victor Stinnere3b47152011-12-09 20:49:49 +01001709 const wchar_t invalid[1] = {(wchar_t)0x110000u};
Mark Dickinson081dfee2009-03-18 14:47:41 +00001710#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001711 const wchar_t wtext[3] = {(wchar_t)0xDBEAu, (wchar_t)0xDFCDu};
1712 size_t wtextlen = 2;
Mark Dickinson081dfee2009-03-18 14:47:41 +00001713#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001714 PyObject *wide, *utf8;
Mark Dickinson081dfee2009-03-18 14:47:41 +00001715
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001716 wide = PyUnicode_FromWideChar(wtext, wtextlen);
1717 if (wide == NULL)
1718 return NULL;
Mark Dickinson081dfee2009-03-18 14:47:41 +00001719
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001720 utf8 = PyUnicode_FromString("\xf4\x8a\xaf\x8d");
1721 if (utf8 == NULL) {
1722 Py_DECREF(wide);
1723 return NULL;
1724 }
Mark Dickinson081dfee2009-03-18 14:47:41 +00001725
Victor Stinner8ef18872011-11-21 02:06:57 +01001726 if (PyUnicode_GET_LENGTH(wide) != PyUnicode_GET_LENGTH(utf8)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001727 Py_DECREF(wide);
1728 Py_DECREF(utf8);
1729 return raiseTestError("test_widechar",
1730 "wide string and utf8 string "
1731 "have different length");
1732 }
1733 if (PyUnicode_Compare(wide, utf8)) {
1734 Py_DECREF(wide);
1735 Py_DECREF(utf8);
1736 if (PyErr_Occurred())
1737 return NULL;
1738 return raiseTestError("test_widechar",
1739 "wide string and utf8 string "
1740 "are different");
1741 }
Mark Dickinson081dfee2009-03-18 14:47:41 +00001742
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001743 Py_DECREF(wide);
1744 Py_DECREF(utf8);
Victor Stinnere3b47152011-12-09 20:49:49 +01001745
1746#if defined(SIZEOF_WCHAR_T) && (SIZEOF_WCHAR_T == 4)
1747 wide = PyUnicode_FromWideChar(invalid, 1);
1748 if (wide == NULL)
1749 PyErr_Clear();
1750 else
1751 return raiseTestError("test_widechar",
1752 "PyUnicode_FromWideChar(L\"\\U00110000\", 1) didn't fail");
1753
1754 wide = PyUnicode_FromUnicode(invalid, 1);
1755 if (wide == NULL)
1756 PyErr_Clear();
1757 else
1758 return raiseTestError("test_widechar",
1759 "PyUnicode_FromUnicode(L\"\\U00110000\", 1) didn't fail");
Victor Stinnere5c05332013-03-06 00:39:03 +01001760
1761 wide = PyUnicode_FromUnicode(NULL, 1);
1762 if (wide == NULL)
1763 return NULL;
1764 PyUnicode_AS_UNICODE(wide)[0] = invalid[0];
Ezio Melotti03e667d2013-03-07 21:18:45 +02001765 if (_PyUnicode_Ready(wide) < 0) {
1766 Py_DECREF(wide);
Victor Stinnere5c05332013-03-06 00:39:03 +01001767 PyErr_Clear();
Ezio Melotti03e667d2013-03-07 21:18:45 +02001768 }
1769 else {
1770 Py_DECREF(wide);
Victor Stinnere5c05332013-03-06 00:39:03 +01001771 return raiseTestError("test_widechar",
1772 "PyUnicode_Ready() didn't fail");
Ezio Melotti03e667d2013-03-07 21:18:45 +02001773 }
Victor Stinnere3b47152011-12-09 20:49:49 +01001774#endif
1775
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001776 Py_RETURN_NONE;
Mark Dickinson081dfee2009-03-18 14:47:41 +00001777}
1778
1779static PyObject *
Victor Stinner46c7b3b2010-10-02 11:49:31 +00001780unicode_aswidechar(PyObject *self, PyObject *args)
Victor Stinner1c24bd02010-10-02 11:03:13 +00001781{
1782 PyObject *unicode, *result;
1783 Py_ssize_t buflen, size;
1784 wchar_t *buffer;
1785
1786 if (!PyArg_ParseTuple(args, "Un", &unicode, &buflen))
1787 return NULL;
Serhiy Storchaka1a1ff292015-02-16 13:28:22 +02001788 buffer = PyMem_New(wchar_t, buflen);
Victor Stinner1c24bd02010-10-02 11:03:13 +00001789 if (buffer == NULL)
1790 return PyErr_NoMemory();
1791
Martin v. Löwis4d0d4712010-12-03 20:14:31 +00001792 size = PyUnicode_AsWideChar(unicode, buffer, buflen);
Victor Stinner1c24bd02010-10-02 11:03:13 +00001793 if (size == -1) {
1794 PyMem_Free(buffer);
1795 return NULL;
1796 }
1797
1798 if (size < buflen)
1799 buflen = size + 1;
1800 else
1801 buflen = size;
1802 result = PyUnicode_FromWideChar(buffer, buflen);
1803 PyMem_Free(buffer);
1804 if (result == NULL)
1805 return NULL;
1806
1807 return Py_BuildValue("(Nn)", result, size);
1808}
1809
1810static PyObject *
Victor Stinner46c7b3b2010-10-02 11:49:31 +00001811unicode_aswidecharstring(PyObject *self, PyObject *args)
Victor Stinner1c24bd02010-10-02 11:03:13 +00001812{
1813 PyObject *unicode, *result;
1814 Py_ssize_t size;
1815 wchar_t *buffer;
1816
1817 if (!PyArg_ParseTuple(args, "U", &unicode))
1818 return NULL;
1819
Victor Stinnerbeb4135b2010-10-07 01:02:42 +00001820 buffer = PyUnicode_AsWideCharString(unicode, &size);
Victor Stinner1c24bd02010-10-02 11:03:13 +00001821 if (buffer == NULL)
1822 return NULL;
1823
1824 result = PyUnicode_FromWideChar(buffer, size + 1);
1825 PyMem_Free(buffer);
1826 if (result == NULL)
1827 return NULL;
1828 return Py_BuildValue("(Nn)", result, size);
1829}
1830
1831static PyObject *
Serhiy Storchakacc164232016-10-02 21:29:26 +03001832unicode_asucs4(PyObject *self, PyObject *args)
1833{
1834 PyObject *unicode, *result;
1835 Py_UCS4 *buffer;
1836 int copy_null;
1837 Py_ssize_t str_len, buf_len;
1838
1839 if (!PyArg_ParseTuple(args, "Unp:unicode_asucs4", &unicode, &str_len, &copy_null)) {
1840 return NULL;
1841 }
1842
1843 buf_len = str_len + 1;
1844 buffer = PyMem_NEW(Py_UCS4, buf_len);
1845 if (buffer == NULL) {
1846 return PyErr_NoMemory();
1847 }
1848 memset(buffer, 0, sizeof(Py_UCS4)*buf_len);
1849 buffer[str_len] = 0xffffU;
1850
1851 if (!PyUnicode_AsUCS4(unicode, buffer, buf_len, copy_null)) {
1852 PyMem_FREE(buffer);
1853 return NULL;
1854 }
1855
1856 result = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, buffer, buf_len);
1857 PyMem_FREE(buffer);
1858 return result;
1859}
1860
1861static PyObject *
Serhiy Storchaka9c0e1f82016-10-08 22:45:38 +03001862unicode_copycharacters(PyObject *self, PyObject *args)
1863{
1864 PyObject *from, *to, *to_copy;
1865 Py_ssize_t from_start, to_start, how_many, copied;
1866
1867 if (!PyArg_ParseTuple(args, "UnOnn:unicode_copycharacters", &to, &to_start,
1868 &from, &from_start, &how_many)) {
1869 return NULL;
1870 }
1871
1872 if (PyUnicode_READY(to) < 0) {
1873 return NULL;
1874 }
1875
1876 if (!(to_copy = PyUnicode_New(PyUnicode_GET_LENGTH(to),
1877 PyUnicode_MAX_CHAR_VALUE(to)))) {
1878 return NULL;
1879 }
1880 if (PyUnicode_Fill(to_copy, 0, PyUnicode_GET_LENGTH(to_copy), 0U) < 0) {
1881 Py_DECREF(to_copy);
1882 return NULL;
1883 }
1884
1885 if ((copied = PyUnicode_CopyCharacters(to_copy, to_start, from,
1886 from_start, how_many)) < 0) {
1887 Py_DECREF(to_copy);
1888 return NULL;
1889 }
1890
1891 return Py_BuildValue("(Nn)", to_copy, copied);
1892}
1893
1894static PyObject *
Victor Stinner42bf7752011-11-21 22:52:58 +01001895unicode_encodedecimal(PyObject *self, PyObject *args)
1896{
1897 Py_UNICODE *unicode;
1898 Py_ssize_t length;
1899 char *errors = NULL;
1900 PyObject *decimal;
1901 Py_ssize_t decimal_length, new_length;
1902 int res;
1903
1904 if (!PyArg_ParseTuple(args, "u#|s", &unicode, &length, &errors))
1905 return NULL;
1906
1907 decimal_length = length * 7; /* len('&#8364;') */
1908 decimal = PyBytes_FromStringAndSize(NULL, decimal_length);
1909 if (decimal == NULL)
1910 return NULL;
1911
1912 res = PyUnicode_EncodeDecimal(unicode, length,
1913 PyBytes_AS_STRING(decimal),
1914 errors);
1915 if (res < 0) {
1916 Py_DECREF(decimal);
1917 return NULL;
1918 }
1919
1920 new_length = strlen(PyBytes_AS_STRING(decimal));
1921 assert(new_length <= decimal_length);
1922 res = _PyBytes_Resize(&decimal, new_length);
1923 if (res < 0)
1924 return NULL;
1925
1926 return decimal;
1927}
1928
1929static PyObject *
1930unicode_transformdecimaltoascii(PyObject *self, PyObject *args)
1931{
1932 Py_UNICODE *unicode;
1933 Py_ssize_t length;
1934 if (!PyArg_ParseTuple(args, "u#|s", &unicode, &length))
1935 return NULL;
1936 return PyUnicode_TransformDecimalToASCII(unicode, length);
1937}
1938
1939static PyObject *
Stefan Krahe6996ed2012-11-02 14:44:20 +01001940unicode_legacy_string(PyObject *self, PyObject *args)
1941{
1942 Py_UNICODE *data;
1943 Py_ssize_t len;
1944 PyObject *u;
1945
1946 if (!PyArg_ParseTuple(args, "u#", &data, &len))
1947 return NULL;
1948
1949 u = PyUnicode_FromUnicode(NULL, len);
1950 if (u == NULL)
1951 return NULL;
1952
1953 memcpy(PyUnicode_AS_UNICODE(u), data, len * sizeof(Py_UNICODE));
1954
1955 if (len > 0) { /* The empty string is always ready. */
1956 assert(!PyUnicode_IS_READY(u));
1957 }
1958
1959 return u;
1960}
1961
1962static PyObject *
Victor Stinner25e8ec42010-06-25 00:02:38 +00001963getargs_w_star(PyObject *self, PyObject *args)
1964{
1965 Py_buffer buffer;
1966 PyObject *result;
1967 char *str;
1968
1969 if (!PyArg_ParseTuple(args, "w*:getargs_w_star", &buffer))
1970 return NULL;
1971
1972 if (2 <= buffer.len) {
1973 str = buffer.buf;
1974 str[0] = '[';
1975 str[buffer.len-1] = ']';
1976 }
1977
1978 result = PyBytes_FromStringAndSize(buffer.buf, buffer.len);
1979 PyBuffer_Release(&buffer);
1980 return result;
1981}
1982
1983
1984static PyObject *
Benjamin Peterson92035012008-12-27 16:00:54 +00001985test_empty_argparse(PyObject *self)
1986{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001987 /* Test that formats can begin with '|'. See issue #4720. */
1988 PyObject *tuple, *dict = NULL;
1989 static char *kwlist[] = {NULL};
1990 int result;
1991 tuple = PyTuple_New(0);
1992 if (!tuple)
1993 return NULL;
1994 if ((result = PyArg_ParseTuple(tuple, "|:test_empty_argparse")) < 0)
1995 goto done;
1996 dict = PyDict_New();
1997 if (!dict)
1998 goto done;
1999 result = PyArg_ParseTupleAndKeywords(tuple, dict, "|:test_empty_argparse", kwlist);
Benjamin Peterson92035012008-12-27 16:00:54 +00002000 done:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002001 Py_DECREF(tuple);
2002 Py_XDECREF(dict);
2003 if (result < 0)
2004 return NULL;
2005 else {
2006 Py_RETURN_NONE;
2007 }
Benjamin Peterson92035012008-12-27 16:00:54 +00002008}
2009
2010static PyObject *
Thomas Wouters477c8d52006-05-27 19:21:47 +00002011codec_incrementalencoder(PyObject *self, PyObject *args)
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002012{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002013 const char *encoding, *errors = NULL;
2014 if (!PyArg_ParseTuple(args, "s|s:test_incrementalencoder",
2015 &encoding, &errors))
2016 return NULL;
2017 return PyCodec_IncrementalEncoder(encoding, errors);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002018}
2019
Thomas Wouters477c8d52006-05-27 19:21:47 +00002020static PyObject *
2021codec_incrementaldecoder(PyObject *self, PyObject *args)
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002022{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002023 const char *encoding, *errors = NULL;
2024 if (!PyArg_ParseTuple(args, "s|s:test_incrementaldecoder",
2025 &encoding, &errors))
2026 return NULL;
2027 return PyCodec_IncrementalDecoder(encoding, errors);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002028}
2029
Marc-André Lemburg3e3eacb2002-01-09 16:21:27 +00002030
Tim Peters5b8132f2003-01-31 15:52:05 +00002031/* Simple test of _PyLong_NumBits and _PyLong_Sign. */
Tim Petersbaefd9e2003-01-28 20:37:45 +00002032static PyObject *
2033test_long_numbits(PyObject *self)
2034{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002035 struct triple {
2036 long input;
2037 size_t nbits;
2038 int sign;
2039 } testcases[] = {{0, 0, 0},
2040 {1L, 1, 1},
2041 {-1L, 1, -1},
2042 {2L, 2, 1},
2043 {-2L, 2, -1},
2044 {3L, 2, 1},
2045 {-3L, 2, -1},
2046 {4L, 3, 1},
2047 {-4L, 3, -1},
Serhiy Storchaka95949422013-08-27 19:40:23 +03002048 {0x7fffL, 15, 1}, /* one Python int digit */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002049 {-0x7fffL, 15, -1},
2050 {0xffffL, 16, 1},
2051 {-0xffffL, 16, -1},
2052 {0xfffffffL, 28, 1},
2053 {-0xfffffffL, 28, -1}};
Victor Stinner706768c2014-08-16 01:03:39 +02002054 size_t i;
Tim Petersbaefd9e2003-01-28 20:37:45 +00002055
Victor Stinner63941882011-09-29 00:42:28 +02002056 for (i = 0; i < Py_ARRAY_LENGTH(testcases); ++i) {
Christian Heimes3205e742013-07-26 15:06:48 +02002057 size_t nbits;
2058 int sign;
2059 PyObject *plong;
2060
2061 plong = PyLong_FromLong(testcases[i].input);
Christian Heimesff369a52013-07-26 14:52:18 +02002062 if (plong == NULL)
2063 return NULL;
Christian Heimes3205e742013-07-26 15:06:48 +02002064 nbits = _PyLong_NumBits(plong);
2065 sign = _PyLong_Sign(plong);
Tim Petersbaefd9e2003-01-28 20:37:45 +00002066
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002067 Py_DECREF(plong);
2068 if (nbits != testcases[i].nbits)
2069 return raiseTestError("test_long_numbits",
2070 "wrong result for _PyLong_NumBits");
2071 if (sign != testcases[i].sign)
2072 return raiseTestError("test_long_numbits",
2073 "wrong result for _PyLong_Sign");
2074 }
2075 Py_INCREF(Py_None);
2076 return Py_None;
Tim Petersbaefd9e2003-01-28 20:37:45 +00002077}
2078
Thomas Heller519a0422007-11-15 20:48:54 +00002079/* Example passing NULLs to PyObject_Str(NULL). */
Thomas Woutersa9773292006-04-21 09:43:23 +00002080
2081static PyObject *
2082test_null_strings(PyObject *self)
2083{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002084 PyObject *o1 = PyObject_Str(NULL), *o2 = PyObject_Str(NULL);
2085 PyObject *tuple = PyTuple_Pack(2, o1, o2);
2086 Py_XDECREF(o1);
2087 Py_XDECREF(o2);
2088 return tuple;
Thomas Woutersa9773292006-04-21 09:43:23 +00002089}
2090
Jeremy Hyltonede049b2001-09-26 20:01:13 +00002091static PyObject *
2092raise_exception(PyObject *self, PyObject *args)
2093{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002094 PyObject *exc;
2095 PyObject *exc_args, *v;
2096 int num_args, i;
Jeremy Hyltonede049b2001-09-26 20:01:13 +00002097
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002098 if (!PyArg_ParseTuple(args, "Oi:raise_exception",
2099 &exc, &num_args))
2100 return NULL;
Jeremy Hyltonede049b2001-09-26 20:01:13 +00002101
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002102 exc_args = PyTuple_New(num_args);
2103 if (exc_args == NULL)
2104 return NULL;
2105 for (i = 0; i < num_args; ++i) {
2106 v = PyLong_FromLong(i);
2107 if (v == NULL) {
2108 Py_DECREF(exc_args);
2109 return NULL;
2110 }
2111 PyTuple_SET_ITEM(exc_args, i, v);
2112 }
2113 PyErr_SetObject(exc, exc_args);
2114 Py_DECREF(exc_args);
2115 return NULL;
Jeremy Hyltonede049b2001-09-26 20:01:13 +00002116}
Tim Peters91621db2001-06-12 20:10:01 +00002117
Martin v. Löwisaa2efcb2012-04-19 14:33:43 +02002118static PyObject *
Antoine Pitrou6bc217d2015-06-23 14:31:11 +02002119set_errno(PyObject *self, PyObject *args)
2120{
2121 int new_errno;
2122
2123 if (!PyArg_ParseTuple(args, "i:set_errno", &new_errno))
2124 return NULL;
2125
2126 errno = new_errno;
2127 Py_RETURN_NONE;
2128}
2129
2130static PyObject *
Martin v. Löwisaa2efcb2012-04-19 14:33:43 +02002131test_set_exc_info(PyObject *self, PyObject *args)
2132{
2133 PyObject *orig_exc;
2134 PyObject *new_type, *new_value, *new_tb;
2135 PyObject *type, *value, *tb;
2136 if (!PyArg_ParseTuple(args, "OOO:test_set_exc_info",
2137 &new_type, &new_value, &new_tb))
2138 return NULL;
2139
2140 PyErr_GetExcInfo(&type, &value, &tb);
2141
2142 Py_INCREF(new_type);
2143 Py_INCREF(new_value);
2144 Py_INCREF(new_tb);
2145 PyErr_SetExcInfo(new_type, new_value, new_tb);
2146
2147 orig_exc = PyTuple_Pack(3, type ? type : Py_None, value ? value : Py_None, tb ? tb : Py_None);
2148 Py_XDECREF(type);
2149 Py_XDECREF(value);
2150 Py_XDECREF(tb);
2151 return orig_exc;
2152}
Benjamin Peterson16323982010-02-03 01:13:41 +00002153
2154static int test_run_counter = 0;
Mark Hammond8d98d2c2003-04-19 15:41:53 +00002155
Benjamin Peterson91d58bd2009-12-13 21:30:54 +00002156static PyObject *
2157test_datetime_capi(PyObject *self, PyObject *args) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002158 if (PyDateTimeAPI) {
2159 if (test_run_counter) {
2160 /* Probably regrtest.py -R */
2161 Py_RETURN_NONE;
2162 }
2163 else {
2164 PyErr_SetString(PyExc_AssertionError,
2165 "PyDateTime_CAPI somehow initialized");
2166 return NULL;
2167 }
2168 }
2169 test_run_counter++;
2170 PyDateTime_IMPORT;
2171 if (PyDateTimeAPI)
2172 Py_RETURN_NONE;
2173 else
2174 return NULL;
Benjamin Peterson91d58bd2009-12-13 21:30:54 +00002175}
2176
Benjamin Peterson16323982010-02-03 01:13:41 +00002177
2178#ifdef WITH_THREAD
2179
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002180/* test_thread_state spawns a thread of its own, and that thread releases
2181 * `thread_done` when it's finished. The driver code has to know when the
2182 * thread finishes, because the thread uses a PyObject (the callable) that
2183 * may go away when the driver finishes. The former lack of this explicit
2184 * synchronization caused rare segfaults, so rare that they were seen only
2185 * on a Mac buildbot (although they were possible on any box).
2186 */
2187static PyThread_type_lock thread_done = NULL;
2188
Benjamin Petersona786b022008-08-25 21:05:21 +00002189static int
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002190_make_call(void *callable)
Mark Hammond8d98d2c2003-04-19 15:41:53 +00002191{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002192 PyObject *rc;
2193 int success;
2194 PyGILState_STATE s = PyGILState_Ensure();
Victor Stinner3466bde2016-09-05 18:16:01 -07002195 rc = _PyObject_CallNoArg((PyObject *)callable);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002196 success = (rc != NULL);
2197 Py_XDECREF(rc);
2198 PyGILState_Release(s);
2199 return success;
Mark Hammond8d98d2c2003-04-19 15:41:53 +00002200}
2201
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002202/* Same thing, but releases `thread_done` when it returns. This variant
2203 * should be called only from threads spawned by test_thread_state().
2204 */
2205static void
2206_make_call_from_thread(void *callable)
2207{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002208 _make_call(callable);
2209 PyThread_release_lock(thread_done);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002210}
2211
Mark Hammond8d98d2c2003-04-19 15:41:53 +00002212static PyObject *
2213test_thread_state(PyObject *self, PyObject *args)
2214{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002215 PyObject *fn;
2216 int success = 1;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002217
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002218 if (!PyArg_ParseTuple(args, "O:test_thread_state", &fn))
2219 return NULL;
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002220
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002221 if (!PyCallable_Check(fn)) {
2222 PyErr_Format(PyExc_TypeError, "'%s' object is not callable",
2223 fn->ob_type->tp_name);
2224 return NULL;
2225 }
Benjamin Petersona786b022008-08-25 21:05:21 +00002226
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002227 /* Ensure Python is set up for threading */
2228 PyEval_InitThreads();
2229 thread_done = PyThread_allocate_lock();
2230 if (thread_done == NULL)
2231 return PyErr_NoMemory();
2232 PyThread_acquire_lock(thread_done, 1);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002233
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002234 /* Start a new thread with our callback. */
2235 PyThread_start_new_thread(_make_call_from_thread, fn);
2236 /* Make the callback with the thread lock held by this thread */
2237 success &= _make_call(fn);
2238 /* Do it all again, but this time with the thread-lock released */
2239 Py_BEGIN_ALLOW_THREADS
2240 success &= _make_call(fn);
2241 PyThread_acquire_lock(thread_done, 1); /* wait for thread to finish */
2242 Py_END_ALLOW_THREADS
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002243
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002244 /* And once more with and without a thread
2245 XXX - should use a lock and work out exactly what we are trying
2246 to test <wink>
2247 */
2248 Py_BEGIN_ALLOW_THREADS
2249 PyThread_start_new_thread(_make_call_from_thread, fn);
2250 success &= _make_call(fn);
2251 PyThread_acquire_lock(thread_done, 1); /* wait for thread to finish */
2252 Py_END_ALLOW_THREADS
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002253
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002254 /* Release lock we acquired above. This is required on HP-UX. */
2255 PyThread_release_lock(thread_done);
Thomas Wouters89f507f2006-12-13 04:49:30 +00002256
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002257 PyThread_free_lock(thread_done);
2258 if (!success)
2259 return NULL;
2260 Py_RETURN_NONE;
Mark Hammond8d98d2c2003-04-19 15:41:53 +00002261}
Benjamin Petersona54c9092009-01-13 02:11:23 +00002262
2263/* test Py_AddPendingCalls using threads */
2264static int _pending_callback(void *arg)
2265{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002266 /* we assume the argument is callable object to which we own a reference */
2267 PyObject *callable = (PyObject *)arg;
2268 PyObject *r = PyObject_CallObject(callable, NULL);
2269 Py_DECREF(callable);
2270 Py_XDECREF(r);
2271 return r != NULL ? 0 : -1;
Benjamin Petersona54c9092009-01-13 02:11:23 +00002272}
2273
2274/* The following requests n callbacks to _pending_callback. It can be
2275 * run from any python thread.
2276 */
2277PyObject *pending_threadfunc(PyObject *self, PyObject *arg)
2278{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002279 PyObject *callable;
2280 int r;
2281 if (PyArg_ParseTuple(arg, "O", &callable) == 0)
2282 return NULL;
Benjamin Petersona54c9092009-01-13 02:11:23 +00002283
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002284 /* create the reference for the callbackwhile we hold the lock */
2285 Py_INCREF(callable);
Benjamin Petersona54c9092009-01-13 02:11:23 +00002286
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002287 Py_BEGIN_ALLOW_THREADS
2288 r = Py_AddPendingCall(&_pending_callback, callable);
2289 Py_END_ALLOW_THREADS
Benjamin Petersona54c9092009-01-13 02:11:23 +00002290
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002291 if (r<0) {
2292 Py_DECREF(callable); /* unsuccessful add, destroy the extra reference */
2293 Py_INCREF(Py_False);
2294 return Py_False;
2295 }
2296 Py_INCREF(Py_True);
2297 return Py_True;
Benjamin Petersona54c9092009-01-13 02:11:23 +00002298}
Mark Hammond8d98d2c2003-04-19 15:41:53 +00002299#endif
2300
Neal Norwitzb0d26332007-08-25 00:49:05 +00002301/* Some tests of PyUnicode_FromFormat(). This needs more tests. */
Thomas Wouters477c8d52006-05-27 19:21:47 +00002302static PyObject *
2303test_string_from_format(PyObject *self, PyObject *args)
2304{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002305 PyObject *result;
2306 char *msg;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002307
Alexander Belopolskye239d232010-12-08 23:31:48 +00002308#define CHECK_1_FORMAT(FORMAT, TYPE) \
2309 result = PyUnicode_FromFormat(FORMAT, (TYPE)1); \
2310 if (result == NULL) \
2311 return NULL; \
Victor Stinner2b979bf2011-11-20 19:32:09 +01002312 if (PyUnicode_CompareWithASCIIString(result, "1")) { \
Alexander Belopolskye239d232010-12-08 23:31:48 +00002313 msg = FORMAT " failed at 1"; \
2314 goto Fail; \
2315 } \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002316 Py_DECREF(result)
Thomas Wouters477c8d52006-05-27 19:21:47 +00002317
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002318 CHECK_1_FORMAT("%d", int);
2319 CHECK_1_FORMAT("%ld", long);
2320 /* The z width modifier was added in Python 2.5. */
2321 CHECK_1_FORMAT("%zd", Py_ssize_t);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002322
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002323 /* The u type code was added in Python 2.5. */
2324 CHECK_1_FORMAT("%u", unsigned int);
2325 CHECK_1_FORMAT("%lu", unsigned long);
2326 CHECK_1_FORMAT("%zu", size_t);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002327
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002328 /* "%lld" and "%llu" support added in Python 2.7. */
Benjamin Petersonaf580df2016-09-06 10:46:49 -07002329 CHECK_1_FORMAT("%llu", unsigned long long);
2330 CHECK_1_FORMAT("%lld", long long);
Mark Dickinson6ce4a9a2009-11-16 17:00:11 +00002331
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002332 Py_RETURN_NONE;
Thomas Wouters477c8d52006-05-27 19:21:47 +00002333
2334 Fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002335 Py_XDECREF(result);
2336 return raiseTestError("test_string_from_format", msg);
Thomas Wouters477c8d52006-05-27 19:21:47 +00002337
2338#undef CHECK_1_FORMAT
2339}
2340
Benjamin Peterson8667a9b2010-01-09 21:45:28 +00002341
2342static PyObject *
2343test_unicode_compare_with_ascii(PyObject *self) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002344 PyObject *py_s = PyUnicode_FromStringAndSize("str\0", 4);
2345 int result;
2346 if (py_s == NULL)
2347 return NULL;
2348 result = PyUnicode_CompareWithASCIIString(py_s, "str");
2349 Py_DECREF(py_s);
2350 if (!result) {
2351 PyErr_SetString(TestError, "Python string ending in NULL "
2352 "should not compare equal to c string.");
2353 return NULL;
2354 }
2355 Py_RETURN_NONE;
Victor Stinner3e2b7172010-11-09 09:32:19 +00002356}
Benjamin Peterson8667a9b2010-01-09 21:45:28 +00002357
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002358/* This is here to provide a docstring for test_descr. */
2359static PyObject *
2360test_with_docstring(PyObject *self)
2361{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002362 Py_RETURN_NONE;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00002363}
2364
Mark Dickinson725bfd82009-05-03 20:33:40 +00002365/* Test PyOS_string_to_double. */
2366static PyObject *
2367test_string_to_double(PyObject *self) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002368 double result;
2369 char *msg;
Mark Dickinson725bfd82009-05-03 20:33:40 +00002370
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002371#define CHECK_STRING(STR, expected) \
2372 result = PyOS_string_to_double(STR, NULL, NULL); \
2373 if (result == -1.0 && PyErr_Occurred()) \
2374 return NULL; \
Benjamin Peterson8f4b2472016-09-07 18:09:22 -07002375 if (result != (double)expected) { \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002376 msg = "conversion of " STR " to float failed"; \
2377 goto fail; \
2378 }
Mark Dickinson725bfd82009-05-03 20:33:40 +00002379
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002380#define CHECK_INVALID(STR) \
2381 result = PyOS_string_to_double(STR, NULL, NULL); \
2382 if (result == -1.0 && PyErr_Occurred()) { \
2383 if (PyErr_ExceptionMatches(PyExc_ValueError)) \
2384 PyErr_Clear(); \
2385 else \
2386 return NULL; \
2387 } \
2388 else { \
2389 msg = "conversion of " STR " didn't raise ValueError"; \
2390 goto fail; \
2391 }
Mark Dickinson725bfd82009-05-03 20:33:40 +00002392
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002393 CHECK_STRING("0.1", 0.1);
2394 CHECK_STRING("1.234", 1.234);
2395 CHECK_STRING("-1.35", -1.35);
2396 CHECK_STRING(".1e01", 1.0);
2397 CHECK_STRING("2.e-2", 0.02);
Mark Dickinson725bfd82009-05-03 20:33:40 +00002398
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002399 CHECK_INVALID(" 0.1");
2400 CHECK_INVALID("\t\n-3");
2401 CHECK_INVALID(".123 ");
2402 CHECK_INVALID("3\n");
2403 CHECK_INVALID("123abc");
Mark Dickinson725bfd82009-05-03 20:33:40 +00002404
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002405 Py_RETURN_NONE;
Mark Dickinson725bfd82009-05-03 20:33:40 +00002406 fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002407 return raiseTestError("test_string_to_double", msg);
Mark Dickinson725bfd82009-05-03 20:33:40 +00002408#undef CHECK_STRING
2409#undef CHECK_INVALID
2410}
2411
2412
Benjamin Petersonb173f782009-05-05 22:31:58 +00002413/* Coverage testing of capsule objects. */
2414
2415static const char *capsule_name = "capsule name";
2416static char *capsule_pointer = "capsule pointer";
2417static char *capsule_context = "capsule context";
2418static const char *capsule_error = NULL;
2419static int
2420capsule_destructor_call_count = 0;
2421
2422static void
2423capsule_destructor(PyObject *o) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002424 capsule_destructor_call_count++;
2425 if (PyCapsule_GetContext(o) != capsule_context) {
2426 capsule_error = "context did not match in destructor!";
2427 } else if (PyCapsule_GetDestructor(o) != capsule_destructor) {
2428 capsule_error = "destructor did not match in destructor! (woah!)";
2429 } else if (PyCapsule_GetName(o) != capsule_name) {
2430 capsule_error = "name did not match in destructor!";
2431 } else if (PyCapsule_GetPointer(o, capsule_name) != capsule_pointer) {
2432 capsule_error = "pointer did not match in destructor!";
2433 }
Benjamin Petersonb173f782009-05-05 22:31:58 +00002434}
2435
2436typedef struct {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002437 char *name;
2438 char *module;
2439 char *attribute;
Benjamin Petersonb173f782009-05-05 22:31:58 +00002440} known_capsule;
2441
2442static PyObject *
2443test_capsule(PyObject *self, PyObject *args)
2444{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002445 PyObject *object;
2446 const char *error = NULL;
2447 void *pointer;
2448 void *pointer2;
2449 known_capsule known_capsules[] = {
2450 #define KNOWN_CAPSULE(module, name) { module "." name, module, name }
2451 KNOWN_CAPSULE("_socket", "CAPI"),
2452 KNOWN_CAPSULE("_curses", "_C_API"),
2453 KNOWN_CAPSULE("datetime", "datetime_CAPI"),
2454 { NULL, NULL },
2455 };
2456 known_capsule *known = &known_capsules[0];
Benjamin Petersonb173f782009-05-05 22:31:58 +00002457
2458#define FAIL(x) { error = (x); goto exit; }
2459
2460#define CHECK_DESTRUCTOR \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002461 if (capsule_error) { \
2462 FAIL(capsule_error); \
2463 } \
2464 else if (!capsule_destructor_call_count) { \
2465 FAIL("destructor not called!"); \
2466 } \
2467 capsule_destructor_call_count = 0; \
Benjamin Petersonb173f782009-05-05 22:31:58 +00002468
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002469 object = PyCapsule_New(capsule_pointer, capsule_name, capsule_destructor);
2470 PyCapsule_SetContext(object, capsule_context);
2471 capsule_destructor(object);
2472 CHECK_DESTRUCTOR;
2473 Py_DECREF(object);
2474 CHECK_DESTRUCTOR;
Benjamin Petersonb173f782009-05-05 22:31:58 +00002475
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002476 object = PyCapsule_New(known, "ignored", NULL);
2477 PyCapsule_SetPointer(object, capsule_pointer);
2478 PyCapsule_SetName(object, capsule_name);
2479 PyCapsule_SetDestructor(object, capsule_destructor);
2480 PyCapsule_SetContext(object, capsule_context);
2481 capsule_destructor(object);
2482 CHECK_DESTRUCTOR;
2483 /* intentionally access using the wrong name */
2484 pointer2 = PyCapsule_GetPointer(object, "the wrong name");
2485 if (!PyErr_Occurred()) {
2486 FAIL("PyCapsule_GetPointer should have failed but did not!");
2487 }
2488 PyErr_Clear();
2489 if (pointer2) {
2490 if (pointer2 == capsule_pointer) {
2491 FAIL("PyCapsule_GetPointer should not have"
2492 " returned the internal pointer!");
2493 } else {
2494 FAIL("PyCapsule_GetPointer should have "
2495 "returned NULL pointer but did not!");
2496 }
2497 }
2498 PyCapsule_SetDestructor(object, NULL);
2499 Py_DECREF(object);
2500 if (capsule_destructor_call_count) {
2501 FAIL("destructor called when it should not have been!");
2502 }
Benjamin Petersonb173f782009-05-05 22:31:58 +00002503
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002504 for (known = &known_capsules[0]; known->module != NULL; known++) {
2505 /* yeah, ordinarily I wouldn't do this either,
2506 but it's fine for this test harness.
2507 */
2508 static char buffer[256];
Benjamin Petersonb173f782009-05-05 22:31:58 +00002509#undef FAIL
2510#define FAIL(x) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002511 { \
2512 sprintf(buffer, "%s module: \"%s\" attribute: \"%s\"", \
2513 x, known->module, known->attribute); \
2514 error = buffer; \
2515 goto exit; \
2516 } \
Benjamin Petersonb173f782009-05-05 22:31:58 +00002517
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002518 PyObject *module = PyImport_ImportModule(known->module);
2519 if (module) {
2520 pointer = PyCapsule_Import(known->name, 0);
2521 if (!pointer) {
2522 Py_DECREF(module);
2523 FAIL("PyCapsule_GetPointer returned NULL unexpectedly!");
2524 }
2525 object = PyObject_GetAttrString(module, known->attribute);
2526 if (!object) {
2527 Py_DECREF(module);
2528 return NULL;
2529 }
2530 pointer2 = PyCapsule_GetPointer(object,
2531 "weebles wobble but they don't fall down");
2532 if (!PyErr_Occurred()) {
2533 Py_DECREF(object);
2534 Py_DECREF(module);
2535 FAIL("PyCapsule_GetPointer should have failed but did not!");
2536 }
2537 PyErr_Clear();
2538 if (pointer2) {
2539 Py_DECREF(module);
2540 Py_DECREF(object);
2541 if (pointer2 == pointer) {
2542 FAIL("PyCapsule_GetPointer should not have"
2543 " returned its internal pointer!");
2544 } else {
2545 FAIL("PyCapsule_GetPointer should have"
2546 " returned NULL pointer but did not!");
2547 }
2548 }
2549 Py_DECREF(object);
2550 Py_DECREF(module);
2551 }
2552 else
2553 PyErr_Clear();
2554 }
Benjamin Petersonb173f782009-05-05 22:31:58 +00002555
2556 exit:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002557 if (error) {
2558 return raiseTestError("test_capsule", error);
2559 }
2560 Py_RETURN_NONE;
Benjamin Petersonb173f782009-05-05 22:31:58 +00002561#undef FAIL
2562}
2563
Guido van Rossumddefaf32007-01-14 03:31:43 +00002564#ifdef HAVE_GETTIMEOFDAY
2565/* Profiling of integer performance */
Martin v. Löwis1c951552008-06-13 07:48:19 +00002566static void print_delta(int test, struct timeval *s, struct timeval *e)
Guido van Rossumddefaf32007-01-14 03:31:43 +00002567{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002568 e->tv_sec -= s->tv_sec;
2569 e->tv_usec -= s->tv_usec;
2570 if (e->tv_usec < 0) {
2571 e->tv_sec -=1;
2572 e->tv_usec += 1000000;
2573 }
2574 printf("Test %d: %d.%06ds\n", test, (int)e->tv_sec, (int)e->tv_usec);
Guido van Rossumddefaf32007-01-14 03:31:43 +00002575}
2576
2577static PyObject *
2578profile_int(PyObject *self, PyObject* args)
2579{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002580 int i, k;
2581 struct timeval start, stop;
2582 PyObject *single, **multiple, *op1, *result;
Guido van Rossumddefaf32007-01-14 03:31:43 +00002583
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002584 /* Test 1: Allocate and immediately deallocate
2585 many small integers */
2586 gettimeofday(&start, NULL);
2587 for(k=0; k < 20000; k++)
2588 for(i=0; i < 1000; i++) {
2589 single = PyLong_FromLong(i);
2590 Py_DECREF(single);
2591 }
2592 gettimeofday(&stop, NULL);
2593 print_delta(1, &start, &stop);
Guido van Rossumddefaf32007-01-14 03:31:43 +00002594
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002595 /* Test 2: Allocate and immediately deallocate
2596 many large integers */
2597 gettimeofday(&start, NULL);
2598 for(k=0; k < 20000; k++)
2599 for(i=0; i < 1000; i++) {
2600 single = PyLong_FromLong(i+1000000);
2601 Py_DECREF(single);
2602 }
2603 gettimeofday(&stop, NULL);
2604 print_delta(2, &start, &stop);
Guido van Rossumddefaf32007-01-14 03:31:43 +00002605
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002606 /* Test 3: Allocate a few integers, then release
2607 them all simultaneously. */
2608 multiple = malloc(sizeof(PyObject*) * 1000);
Christian Heimes7e138022013-07-26 15:03:50 +02002609 if (multiple == NULL)
2610 return PyErr_NoMemory();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002611 gettimeofday(&start, NULL);
2612 for(k=0; k < 20000; k++) {
2613 for(i=0; i < 1000; i++) {
2614 multiple[i] = PyLong_FromLong(i+1000000);
2615 }
2616 for(i=0; i < 1000; i++) {
2617 Py_DECREF(multiple[i]);
2618 }
2619 }
2620 gettimeofday(&stop, NULL);
2621 print_delta(3, &start, &stop);
Christian Heimes7e138022013-07-26 15:03:50 +02002622 free(multiple);
Guido van Rossumddefaf32007-01-14 03:31:43 +00002623
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002624 /* Test 4: Allocate many integers, then release
2625 them all simultaneously. */
2626 multiple = malloc(sizeof(PyObject*) * 1000000);
Christian Heimes7e138022013-07-26 15:03:50 +02002627 if (multiple == NULL)
2628 return PyErr_NoMemory();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002629 gettimeofday(&start, NULL);
2630 for(k=0; k < 20; k++) {
2631 for(i=0; i < 1000000; i++) {
2632 multiple[i] = PyLong_FromLong(i+1000000);
2633 }
2634 for(i=0; i < 1000000; i++) {
2635 Py_DECREF(multiple[i]);
2636 }
2637 }
2638 gettimeofday(&stop, NULL);
2639 print_delta(4, &start, &stop);
Christian Heimes7e138022013-07-26 15:03:50 +02002640 free(multiple);
Guido van Rossumddefaf32007-01-14 03:31:43 +00002641
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002642 /* Test 5: Allocate many integers < 32000 */
2643 multiple = malloc(sizeof(PyObject*) * 1000000);
Christian Heimes7e138022013-07-26 15:03:50 +02002644 if (multiple == NULL)
2645 return PyErr_NoMemory();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002646 gettimeofday(&start, NULL);
2647 for(k=0; k < 10; k++) {
2648 for(i=0; i < 1000000; i++) {
2649 multiple[i] = PyLong_FromLong(i+1000);
2650 }
2651 for(i=0; i < 1000000; i++) {
2652 Py_DECREF(multiple[i]);
2653 }
2654 }
2655 gettimeofday(&stop, NULL);
2656 print_delta(5, &start, &stop);
Christian Heimes7e138022013-07-26 15:03:50 +02002657 free(multiple);
Guido van Rossumddefaf32007-01-14 03:31:43 +00002658
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002659 /* Test 6: Perform small int addition */
2660 op1 = PyLong_FromLong(1);
2661 gettimeofday(&start, NULL);
2662 for(i=0; i < 10000000; i++) {
2663 result = PyNumber_Add(op1, op1);
2664 Py_DECREF(result);
2665 }
2666 gettimeofday(&stop, NULL);
2667 Py_DECREF(op1);
2668 print_delta(6, &start, &stop);
Guido van Rossumddefaf32007-01-14 03:31:43 +00002669
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002670 /* Test 7: Perform medium int addition */
2671 op1 = PyLong_FromLong(1000);
Christian Heimes66eda262013-07-26 15:54:07 +02002672 if (op1 == NULL)
2673 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002674 gettimeofday(&start, NULL);
2675 for(i=0; i < 10000000; i++) {
2676 result = PyNumber_Add(op1, op1);
Christian Heimesff369a52013-07-26 14:52:18 +02002677 Py_XDECREF(result);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002678 }
2679 gettimeofday(&stop, NULL);
2680 Py_DECREF(op1);
2681 print_delta(7, &start, &stop);
Guido van Rossumddefaf32007-01-14 03:31:43 +00002682
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002683 Py_INCREF(Py_None);
2684 return Py_None;
Guido van Rossumddefaf32007-01-14 03:31:43 +00002685}
2686#endif
2687
Christian Heimes81ee3ef2008-05-04 22:42:01 +00002688/* To test the format of tracebacks as printed out. */
2689static PyObject *
2690traceback_print(PyObject *self, PyObject *args)
2691{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002692 PyObject *file;
2693 PyObject *traceback;
2694 int result;
2695
2696 if (!PyArg_ParseTuple(args, "OO:traceback_print",
2697 &traceback, &file))
2698 return NULL;
2699
2700 result = PyTraceBack_Print(traceback, file);
2701 if (result < 0)
2702 return NULL;
2703 Py_RETURN_NONE;
Christian Heimes81ee3ef2008-05-04 22:42:01 +00002704}
2705
Benjamin Petersone6528212008-07-15 15:32:09 +00002706/* To test the format of exceptions as printed out. */
2707static PyObject *
2708exception_print(PyObject *self, PyObject *args)
2709{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002710 PyObject *value;
2711 PyObject *tb;
Benjamin Petersone6528212008-07-15 15:32:09 +00002712
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002713 if (!PyArg_ParseTuple(args, "O:exception_print",
2714 &value))
2715 return NULL;
2716 if (!PyExceptionInstance_Check(value)) {
2717 PyErr_Format(PyExc_TypeError, "an exception instance is required");
2718 return NULL;
2719 }
Benjamin Petersone6528212008-07-15 15:32:09 +00002720
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002721 tb = PyException_GetTraceback(value);
2722 PyErr_Display((PyObject *) Py_TYPE(value), value, tb);
2723 Py_XDECREF(tb);
Benjamin Petersone6528212008-07-15 15:32:09 +00002724
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002725 Py_RETURN_NONE;
Benjamin Petersone6528212008-07-15 15:32:09 +00002726}
2727
2728
2729
Benjamin Peterson0067bd62008-08-16 16:11:03 +00002730
2731/* reliably raise a MemoryError */
2732static PyObject *
2733raise_memoryerror(PyObject *self)
2734{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002735 PyErr_NoMemory();
2736 return NULL;
Benjamin Peterson0067bd62008-08-16 16:11:03 +00002737}
2738
Martin v. Löwisc15bdef2009-05-29 14:47:46 +00002739/* Issue 6012 */
2740static PyObject *str1, *str2;
2741static int
2742failing_converter(PyObject *obj, void *arg)
2743{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002744 /* Clone str1, then let the conversion fail. */
2745 assert(str1);
2746 str2 = str1;
2747 Py_INCREF(str2);
2748 return 0;
Martin v. Löwisc15bdef2009-05-29 14:47:46 +00002749}
2750static PyObject*
2751argparsing(PyObject *o, PyObject *args)
2752{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002753 PyObject *res;
2754 str1 = str2 = NULL;
2755 if (!PyArg_ParseTuple(args, "O&O&",
2756 PyUnicode_FSConverter, &str1,
2757 failing_converter, &str2)) {
2758 if (!str2)
2759 /* argument converter not called? */
2760 return NULL;
2761 /* Should be 1 */
Victor Stinner0fcab4a2011-01-04 12:59:15 +00002762 res = PyLong_FromSsize_t(Py_REFCNT(str2));
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002763 Py_DECREF(str2);
2764 PyErr_Clear();
2765 return res;
2766 }
2767 Py_RETURN_NONE;
Martin v. Löwisc15bdef2009-05-29 14:47:46 +00002768}
Benjamin Peterson0067bd62008-08-16 16:11:03 +00002769
Alexandre Vassalotti7b82b402009-07-21 04:30:03 +00002770/* To test that the result of PyCode_NewEmpty has the right members. */
2771static PyObject *
2772code_newempty(PyObject *self, PyObject *args)
2773{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002774 const char *filename;
2775 const char *funcname;
2776 int firstlineno;
Alexandre Vassalotti7b82b402009-07-21 04:30:03 +00002777
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002778 if (!PyArg_ParseTuple(args, "ssi:code_newempty",
2779 &filename, &funcname, &firstlineno))
2780 return NULL;
Alexandre Vassalotti7b82b402009-07-21 04:30:03 +00002781
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002782 return (PyObject *)PyCode_NewEmpty(filename, funcname, firstlineno);
Alexandre Vassalotti7b82b402009-07-21 04:30:03 +00002783}
2784
Georg Brandl1e28a272009-12-28 08:41:01 +00002785/* Test PyErr_NewExceptionWithDoc (also exercise PyErr_NewException).
2786 Run via Lib/test/test_exceptions.py */
2787static PyObject *
2788make_exception_with_doc(PyObject *self, PyObject *args, PyObject *kwargs)
2789{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002790 const char *name;
2791 const char *doc = NULL;
2792 PyObject *base = NULL;
2793 PyObject *dict = NULL;
Georg Brandl1e28a272009-12-28 08:41:01 +00002794
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002795 static char *kwlist[] = {"name", "doc", "base", "dict", NULL};
Georg Brandl1e28a272009-12-28 08:41:01 +00002796
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002797 if (!PyArg_ParseTupleAndKeywords(args, kwargs,
2798 "s|sOO:make_exception_with_doc", kwlist,
2799 &name, &doc, &base, &dict))
2800 return NULL;
Georg Brandl1e28a272009-12-28 08:41:01 +00002801
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002802 return PyErr_NewExceptionWithDoc(name, doc, base, dict);
Georg Brandl1e28a272009-12-28 08:41:01 +00002803}
2804
Antoine Pitrou5bffa792011-02-24 20:50:49 +00002805static PyObject *
2806make_memoryview_from_NULL_pointer(PyObject *self)
2807{
2808 Py_buffer info;
2809 if (PyBuffer_FillInfo(&info, NULL, NULL, 1, 1, PyBUF_FULL_RO) < 0)
2810 return NULL;
2811 return PyMemoryView_FromBuffer(&info);
2812}
Serhiy Storchaka009b8112015-03-18 21:53:15 +02002813
Stefan Krah7213fcc2015-02-01 16:19:23 +01002814static PyObject *
2815test_from_contiguous(PyObject* self, PyObject *noargs)
2816{
2817 int data[9] = {-1,-1,-1,-1,-1,-1,-1,-1,-1};
2818 int init[5] = {0, 1, 2, 3, 4};
2819 Py_ssize_t itemsize = sizeof(int);
2820 Py_ssize_t shape = 5;
2821 Py_ssize_t strides = 2 * itemsize;
2822 Py_buffer view = {
2823 data,
2824 NULL,
2825 5 * itemsize,
2826 itemsize,
2827 1,
2828 1,
2829 NULL,
2830 &shape,
2831 &strides,
2832 NULL,
2833 NULL
2834 };
2835 int *ptr;
2836 int i;
2837
2838 PyBuffer_FromContiguous(&view, init, view.len, 'C');
2839 ptr = view.buf;
2840 for (i = 0; i < 5; i++) {
2841 if (ptr[2*i] != i) {
2842 PyErr_SetString(TestError,
2843 "test_from_contiguous: incorrect result");
2844 return NULL;
2845 }
2846 }
2847
2848 view.buf = &data[8];
2849 view.strides[0] = -2 * itemsize;
2850
2851 PyBuffer_FromContiguous(&view, init, view.len, 'C');
2852 ptr = view.buf;
2853 for (i = 0; i < 5; i++) {
2854 if (*(ptr-2*i) != i) {
2855 PyErr_SetString(TestError,
2856 "test_from_contiguous: incorrect result");
2857 return NULL;
2858 }
2859 }
2860
2861 Py_RETURN_NONE;
2862}
Stefan Krah650c1e82015-02-03 21:43:23 +01002863
Stefan Kraha7559c02015-02-03 22:27:21 +01002864#if (defined(__linux__) || defined(__FreeBSD__)) && defined(__GNUC__)
Stefan Krah650c1e82015-02-03 21:43:23 +01002865extern PyTypeObject _PyBytesIOBuffer_Type;
2866
Stefan Krah5178d912015-02-03 16:57:21 +01002867static PyObject *
2868test_pep3118_obsolete_write_locks(PyObject* self, PyObject *noargs)
2869{
Stefan Krah650c1e82015-02-03 21:43:23 +01002870 PyTypeObject *type = &_PyBytesIOBuffer_Type;
Stefan Krah5178d912015-02-03 16:57:21 +01002871 PyObject *b;
2872 char *dummy[1];
2873 int ret, match;
2874
Stefan Krah650c1e82015-02-03 21:43:23 +01002875 /* PyBuffer_FillInfo() */
Stefan Krah5178d912015-02-03 16:57:21 +01002876 ret = PyBuffer_FillInfo(NULL, NULL, dummy, 1, 0, PyBUF_SIMPLE);
2877 match = PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_BufferError);
2878 PyErr_Clear();
2879 if (ret != -1 || match == 0)
2880 goto error;
2881
Stefan Krah650c1e82015-02-03 21:43:23 +01002882 /* bytesiobuf_getbuffer() */
2883 b = type->tp_alloc(type, 0);
Stefan Krah5178d912015-02-03 16:57:21 +01002884 if (b == NULL) {
2885 return NULL;
2886 }
2887
2888 ret = PyObject_GetBuffer(b, NULL, PyBUF_SIMPLE);
2889 Py_DECREF(b);
2890 match = PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_BufferError);
2891 PyErr_Clear();
2892 if (ret != -1 || match == 0)
2893 goto error;
2894
2895 Py_RETURN_NONE;
2896
2897error:
2898 PyErr_SetString(TestError,
2899 "test_pep3118_obsolete_write_locks: failure");
2900 return NULL;
2901}
Stefan Kraha7559c02015-02-03 22:27:21 +01002902#endif
Antoine Pitrou5bffa792011-02-24 20:50:49 +00002903
Stefan Krah650c1e82015-02-03 21:43:23 +01002904/* This tests functions that historically supported write locks. It is
2905 wrong to call getbuffer() with view==NULL and a compliant getbufferproc
2906 is entitled to segfault in that case. */
2907static PyObject *
2908getbuffer_with_null_view(PyObject* self, PyObject *obj)
2909{
2910 if (PyObject_GetBuffer(obj, NULL, PyBUF_SIMPLE) < 0)
2911 return NULL;
2912
2913 Py_RETURN_NONE;
2914}
2915
Jeffrey Yasskin8e0bdfd2010-05-13 18:31:05 +00002916/* Test that the fatal error from not having a current thread doesn't
2917 cause an infinite loop. Run via Lib/test/test_capi.py */
2918static PyObject *
2919crash_no_current_thread(PyObject *self)
2920{
2921 Py_BEGIN_ALLOW_THREADS
Jeffrey Yasskinea7b7482010-05-17 16:59:23 +00002922 /* Using PyThreadState_Get() directly allows the test to pass in
2923 !pydebug mode. However, the test only actually tests anything
2924 in pydebug mode, since that's where the infinite loop was in
2925 the first place. */
2926 PyThreadState_Get();
Jeffrey Yasskin8e0bdfd2010-05-13 18:31:05 +00002927 Py_END_ALLOW_THREADS
2928 return NULL;
2929}
2930
Antoine Pitrou2f828f22012-01-18 00:21:11 +01002931/* To run some code in a sub-interpreter. */
2932static PyObject *
2933run_in_subinterp(PyObject *self, PyObject *args)
2934{
2935 const char *code;
2936 int r;
2937 PyThreadState *substate, *mainstate;
2938
2939 if (!PyArg_ParseTuple(args, "s:run_in_subinterp",
2940 &code))
2941 return NULL;
2942
2943 mainstate = PyThreadState_Get();
2944
2945 PyThreadState_Swap(NULL);
2946
2947 substate = Py_NewInterpreter();
Brett Cannonb6855682012-02-03 12:08:03 -05002948 if (substate == NULL) {
2949 /* Since no new thread state was created, there is no exception to
2950 propagate; raise a fresh one after swapping in the old thread
2951 state. */
2952 PyThreadState_Swap(mainstate);
2953 PyErr_SetString(PyExc_RuntimeError, "sub-interpreter creation failed");
2954 return NULL;
2955 }
Antoine Pitrou2f828f22012-01-18 00:21:11 +01002956 r = PyRun_SimpleString(code);
2957 Py_EndInterpreter(substate);
2958
2959 PyThreadState_Swap(mainstate);
2960
2961 return PyLong_FromLong(r);
2962}
2963
Victor Stinner3c1b3792014-02-17 00:02:43 +01002964static int
2965check_time_rounding(int round)
2966{
Victor Stinner74474232015-09-02 01:43:56 +02002967 if (round != _PyTime_ROUND_FLOOR
2968 && round != _PyTime_ROUND_CEILING
Victor Stinner7667f582015-09-09 01:02:23 +02002969 && round != _PyTime_ROUND_HALF_EVEN) {
Victor Stinner3c1b3792014-02-17 00:02:43 +01002970 PyErr_SetString(PyExc_ValueError, "invalid rounding");
2971 return -1;
2972 }
2973 return 0;
2974}
2975
Victor Stinner5d272cc2012-03-13 13:35:55 +01002976static PyObject *
2977test_pytime_object_to_time_t(PyObject *self, PyObject *args)
2978{
2979 PyObject *obj;
2980 time_t sec;
Victor Stinner3c1b3792014-02-17 00:02:43 +01002981 int round;
2982 if (!PyArg_ParseTuple(args, "Oi:pytime_object_to_time_t", &obj, &round))
Victor Stinner5d272cc2012-03-13 13:35:55 +01002983 return NULL;
Victor Stinner3c1b3792014-02-17 00:02:43 +01002984 if (check_time_rounding(round) < 0)
2985 return NULL;
2986 if (_PyTime_ObjectToTime_t(obj, &sec, round) == -1)
Victor Stinner5d272cc2012-03-13 13:35:55 +01002987 return NULL;
2988 return _PyLong_FromTime_t(sec);
2989}
2990
2991static PyObject *
2992test_pytime_object_to_timeval(PyObject *self, PyObject *args)
2993{
2994 PyObject *obj;
2995 time_t sec;
2996 long usec;
Victor Stinner3c1b3792014-02-17 00:02:43 +01002997 int round;
2998 if (!PyArg_ParseTuple(args, "Oi:pytime_object_to_timeval", &obj, &round))
Victor Stinner5d272cc2012-03-13 13:35:55 +01002999 return NULL;
Victor Stinner3c1b3792014-02-17 00:02:43 +01003000 if (check_time_rounding(round) < 0)
3001 return NULL;
3002 if (_PyTime_ObjectToTimeval(obj, &sec, &usec, round) == -1)
Victor Stinner5d272cc2012-03-13 13:35:55 +01003003 return NULL;
3004 return Py_BuildValue("Nl", _PyLong_FromTime_t(sec), usec);
3005}
3006
Victor Stinner643cd682012-03-02 22:54:03 +01003007static PyObject *
3008test_pytime_object_to_timespec(PyObject *self, PyObject *args)
3009{
3010 PyObject *obj;
3011 time_t sec;
3012 long nsec;
Victor Stinner3c1b3792014-02-17 00:02:43 +01003013 int round;
3014 if (!PyArg_ParseTuple(args, "Oi:pytime_object_to_timespec", &obj, &round))
Victor Stinner643cd682012-03-02 22:54:03 +01003015 return NULL;
Victor Stinner3c1b3792014-02-17 00:02:43 +01003016 if (check_time_rounding(round) < 0)
3017 return NULL;
3018 if (_PyTime_ObjectToTimespec(obj, &sec, &nsec, round) == -1)
Victor Stinner643cd682012-03-02 22:54:03 +01003019 return NULL;
Victor Stinner5d272cc2012-03-13 13:35:55 +01003020 return Py_BuildValue("Nl", _PyLong_FromTime_t(sec), nsec);
Victor Stinner643cd682012-03-02 22:54:03 +01003021}
3022
Antoine Pitrou796564c2013-07-30 19:59:21 +02003023static void
3024slot_tp_del(PyObject *self)
3025{
3026 _Py_IDENTIFIER(__tp_del__);
3027 PyObject *del, *res;
3028 PyObject *error_type, *error_value, *error_traceback;
3029
3030 /* Temporarily resurrect the object. */
3031 assert(self->ob_refcnt == 0);
3032 self->ob_refcnt = 1;
3033
3034 /* Save the current exception, if any. */
3035 PyErr_Fetch(&error_type, &error_value, &error_traceback);
3036
3037 /* Execute __del__ method, if any. */
3038 del = _PyObject_LookupSpecial(self, &PyId___tp_del__);
3039 if (del != NULL) {
3040 res = PyEval_CallObject(del, NULL);
3041 if (res == NULL)
3042 PyErr_WriteUnraisable(del);
3043 else
3044 Py_DECREF(res);
3045 Py_DECREF(del);
3046 }
3047
3048 /* Restore the saved exception. */
3049 PyErr_Restore(error_type, error_value, error_traceback);
3050
3051 /* Undo the temporary resurrection; can't use DECREF here, it would
3052 * cause a recursive call.
3053 */
3054 assert(self->ob_refcnt > 0);
3055 if (--self->ob_refcnt == 0)
3056 return; /* this is the normal path out */
3057
3058 /* __del__ resurrected it! Make it look like the original Py_DECREF
3059 * never happened.
3060 */
3061 {
3062 Py_ssize_t refcnt = self->ob_refcnt;
3063 _Py_NewReference(self);
3064 self->ob_refcnt = refcnt;
3065 }
3066 assert(!PyType_IS_GC(Py_TYPE(self)) ||
3067 _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED);
3068 /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
3069 * we need to undo that. */
3070 _Py_DEC_REFTOTAL;
3071 /* If Py_TRACE_REFS, _Py_NewReference re-added self to the object
3072 * chain, so no more to do there.
3073 * If COUNT_ALLOCS, the original decref bumped tp_frees, and
3074 * _Py_NewReference bumped tp_allocs: both of those need to be
3075 * undone.
3076 */
3077#ifdef COUNT_ALLOCS
3078 --Py_TYPE(self)->tp_frees;
3079 --Py_TYPE(self)->tp_allocs;
3080#endif
3081}
3082
3083static PyObject *
3084with_tp_del(PyObject *self, PyObject *args)
3085{
3086 PyObject *obj;
3087 PyTypeObject *tp;
3088
3089 if (!PyArg_ParseTuple(args, "O:with_tp_del", &obj))
3090 return NULL;
3091 tp = (PyTypeObject *) obj;
3092 if (!PyType_Check(obj) || !PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE)) {
3093 PyErr_Format(PyExc_TypeError,
3094 "heap type expected, got %R", obj);
3095 return NULL;
3096 }
3097 tp->tp_del = slot_tp_del;
3098 Py_INCREF(obj);
3099 return obj;
3100}
3101
Antoine Pitroub349e4c2014-08-06 19:31:40 -04003102static PyMethodDef ml;
3103
3104static PyObject *
3105create_cfunction(PyObject *self, PyObject *args)
3106{
3107 return PyCFunction_NewEx(&ml, self, NULL);
3108}
3109
3110static PyMethodDef ml = {
3111 "create_cfunction",
3112 create_cfunction,
3113 METH_NOARGS,
3114 NULL
3115};
3116
Benjamin Petersonda5eb5a2013-05-27 14:46:14 -07003117static PyObject *
3118_test_incref(PyObject *ob)
3119{
3120 Py_INCREF(ob);
3121 return ob;
3122}
3123
3124static PyObject *
3125test_xincref_doesnt_leak(PyObject *ob)
3126{
3127 PyObject *obj = PyLong_FromLong(0);
3128 Py_XINCREF(_test_incref(obj));
3129 Py_DECREF(obj);
3130 Py_DECREF(obj);
3131 Py_DECREF(obj);
3132 Py_RETURN_NONE;
3133}
3134
3135static PyObject *
3136test_incref_doesnt_leak(PyObject *ob)
3137{
3138 PyObject *obj = PyLong_FromLong(0);
3139 Py_INCREF(_test_incref(obj));
3140 Py_DECREF(obj);
3141 Py_DECREF(obj);
3142 Py_DECREF(obj);
3143 Py_RETURN_NONE;
3144}
3145
3146static PyObject *
3147test_xdecref_doesnt_leak(PyObject *ob)
3148{
3149 Py_XDECREF(PyLong_FromLong(0));
3150 Py_RETURN_NONE;
3151}
3152
3153static PyObject *
3154test_decref_doesnt_leak(PyObject *ob)
3155{
3156 Py_DECREF(PyLong_FromLong(0));
3157 Py_RETURN_NONE;
3158}
Antoine Pitrou2f828f22012-01-18 00:21:11 +01003159
Victor Stinner0507bf52013-07-07 02:05:46 +02003160static PyObject *
Christian Heimes4efdb412013-07-31 02:36:43 +02003161test_incref_decref_API(PyObject *ob)
3162{
3163 PyObject *obj = PyLong_FromLong(0);
Victor Stinnerfc6a90a2014-10-09 22:15:41 +02003164 Py_IncRef(obj);
Christian Heimes4efdb412013-07-31 02:36:43 +02003165 Py_DecRef(obj);
3166 Py_DecRef(obj);
3167 Py_RETURN_NONE;
3168}
3169
3170static PyObject *
Victor Stinner0507bf52013-07-07 02:05:46 +02003171test_pymem_alloc0(PyObject *self)
3172{
3173 void *ptr;
3174
Victor Stinnerdb067af2014-05-02 22:31:14 +02003175 ptr = PyMem_RawMalloc(0);
3176 if (ptr == NULL) {
3177 PyErr_SetString(PyExc_RuntimeError, "PyMem_RawMalloc(0) returns NULL");
3178 return NULL;
3179 }
3180 PyMem_RawFree(ptr);
3181
3182 ptr = PyMem_RawCalloc(0, 0);
3183 if (ptr == NULL) {
3184 PyErr_SetString(PyExc_RuntimeError, "PyMem_RawCalloc(0, 0) returns NULL");
3185 return NULL;
3186 }
3187 PyMem_RawFree(ptr);
3188
Victor Stinner0507bf52013-07-07 02:05:46 +02003189 ptr = PyMem_Malloc(0);
3190 if (ptr == NULL) {
3191 PyErr_SetString(PyExc_RuntimeError, "PyMem_Malloc(0) returns NULL");
3192 return NULL;
3193 }
3194 PyMem_Free(ptr);
3195
Victor Stinnerdb067af2014-05-02 22:31:14 +02003196 ptr = PyMem_Calloc(0, 0);
3197 if (ptr == NULL) {
3198 PyErr_SetString(PyExc_RuntimeError, "PyMem_Calloc(0, 0) returns NULL");
3199 return NULL;
3200 }
3201 PyMem_Free(ptr);
3202
Victor Stinner0507bf52013-07-07 02:05:46 +02003203 ptr = PyObject_Malloc(0);
3204 if (ptr == NULL) {
3205 PyErr_SetString(PyExc_RuntimeError, "PyObject_Malloc(0) returns NULL");
3206 return NULL;
3207 }
3208 PyObject_Free(ptr);
3209
Victor Stinnerdb067af2014-05-02 22:31:14 +02003210 ptr = PyObject_Calloc(0, 0);
3211 if (ptr == NULL) {
3212 PyErr_SetString(PyExc_RuntimeError, "PyObject_Calloc(0, 0) returns NULL");
3213 return NULL;
3214 }
3215 PyObject_Free(ptr);
3216
Victor Stinner0507bf52013-07-07 02:05:46 +02003217 Py_RETURN_NONE;
3218}
3219
3220typedef struct {
Victor Stinnerd8f0d922014-06-02 21:57:10 +02003221 PyMemAllocatorEx alloc;
Victor Stinner0507bf52013-07-07 02:05:46 +02003222
3223 size_t malloc_size;
Victor Stinnerdb067af2014-05-02 22:31:14 +02003224 size_t calloc_nelem;
3225 size_t calloc_elsize;
Victor Stinner0507bf52013-07-07 02:05:46 +02003226 void *realloc_ptr;
3227 size_t realloc_new_size;
3228 void *free_ptr;
3229} alloc_hook_t;
3230
3231static void* hook_malloc (void* ctx, size_t size)
3232{
3233 alloc_hook_t *hook = (alloc_hook_t *)ctx;
3234 hook->malloc_size = size;
3235 return hook->alloc.malloc(hook->alloc.ctx, size);
3236}
3237
Victor Stinnerdb067af2014-05-02 22:31:14 +02003238static void* hook_calloc (void* ctx, size_t nelem, size_t elsize)
3239{
3240 alloc_hook_t *hook = (alloc_hook_t *)ctx;
3241 hook->calloc_nelem = nelem;
3242 hook->calloc_elsize = elsize;
3243 return hook->alloc.calloc(hook->alloc.ctx, nelem, elsize);
3244}
3245
Victor Stinner0507bf52013-07-07 02:05:46 +02003246static void* hook_realloc (void* ctx, void* ptr, size_t new_size)
3247{
3248 alloc_hook_t *hook = (alloc_hook_t *)ctx;
3249 hook->realloc_ptr = ptr;
3250 hook->realloc_new_size = new_size;
3251 return hook->alloc.realloc(hook->alloc.ctx, ptr, new_size);
3252}
3253
3254static void hook_free (void *ctx, void *ptr)
3255{
3256 alloc_hook_t *hook = (alloc_hook_t *)ctx;
3257 hook->free_ptr = ptr;
3258 hook->alloc.free(hook->alloc.ctx, ptr);
3259}
3260
3261static PyObject *
3262test_setallocators(PyMemAllocatorDomain domain)
3263{
3264 PyObject *res = NULL;
3265 const char *error_msg;
3266 alloc_hook_t hook;
Victor Stinnerd8f0d922014-06-02 21:57:10 +02003267 PyMemAllocatorEx alloc;
Victor Stinnerdb067af2014-05-02 22:31:14 +02003268 size_t size, size2, nelem, elsize;
Victor Stinner0507bf52013-07-07 02:05:46 +02003269 void *ptr, *ptr2;
3270
Victor Stinnerdb067af2014-05-02 22:31:14 +02003271 memset(&hook, 0, sizeof(hook));
Victor Stinner0507bf52013-07-07 02:05:46 +02003272
3273 alloc.ctx = &hook;
3274 alloc.malloc = &hook_malloc;
Victor Stinnerdb067af2014-05-02 22:31:14 +02003275 alloc.calloc = &hook_calloc;
Victor Stinner0507bf52013-07-07 02:05:46 +02003276 alloc.realloc = &hook_realloc;
3277 alloc.free = &hook_free;
3278 PyMem_GetAllocator(domain, &hook.alloc);
3279 PyMem_SetAllocator(domain, &alloc);
3280
3281 size = 42;
3282 switch(domain)
3283 {
3284 case PYMEM_DOMAIN_RAW: ptr = PyMem_RawMalloc(size); break;
3285 case PYMEM_DOMAIN_MEM: ptr = PyMem_Malloc(size); break;
3286 case PYMEM_DOMAIN_OBJ: ptr = PyObject_Malloc(size); break;
3287 default: ptr = NULL; break;
3288 }
3289
3290 if (ptr == NULL) {
3291 error_msg = "malloc failed";
3292 goto fail;
3293 }
3294
3295 if (hook.malloc_size != size) {
3296 error_msg = "malloc invalid size";
3297 goto fail;
3298 }
3299
3300 size2 = 200;
3301 switch(domain)
3302 {
3303 case PYMEM_DOMAIN_RAW: ptr2 = PyMem_RawRealloc(ptr, size2); break;
3304 case PYMEM_DOMAIN_MEM: ptr2 = PyMem_Realloc(ptr, size2); break;
3305 case PYMEM_DOMAIN_OBJ: ptr2 = PyObject_Realloc(ptr, size2); break;
Christian Heimes865d12a2013-08-02 11:10:51 +02003306 default: ptr2 = NULL; break;
Victor Stinner0507bf52013-07-07 02:05:46 +02003307 }
3308
3309 if (ptr2 == NULL) {
3310 error_msg = "realloc failed";
3311 goto fail;
3312 }
3313
3314 if (hook.realloc_ptr != ptr
3315 || hook.realloc_new_size != size2) {
3316 error_msg = "realloc invalid parameters";
3317 goto fail;
3318 }
3319
3320 switch(domain)
3321 {
3322 case PYMEM_DOMAIN_RAW: PyMem_RawFree(ptr2); break;
3323 case PYMEM_DOMAIN_MEM: PyMem_Free(ptr2); break;
3324 case PYMEM_DOMAIN_OBJ: PyObject_Free(ptr2); break;
3325 }
3326
3327 if (hook.free_ptr != ptr2) {
3328 error_msg = "free invalid pointer";
3329 goto fail;
3330 }
3331
Victor Stinnerdb067af2014-05-02 22:31:14 +02003332 nelem = 2;
3333 elsize = 5;
3334 switch(domain)
3335 {
3336 case PYMEM_DOMAIN_RAW: ptr = PyMem_RawCalloc(nelem, elsize); break;
3337 case PYMEM_DOMAIN_MEM: ptr = PyMem_Calloc(nelem, elsize); break;
3338 case PYMEM_DOMAIN_OBJ: ptr = PyObject_Calloc(nelem, elsize); break;
3339 default: ptr = NULL; break;
3340 }
3341
3342 if (ptr == NULL) {
3343 error_msg = "calloc failed";
3344 goto fail;
3345 }
3346
3347 if (hook.calloc_nelem != nelem || hook.calloc_elsize != elsize) {
3348 error_msg = "calloc invalid nelem or elsize";
3349 goto fail;
3350 }
3351
3352 switch(domain)
3353 {
3354 case PYMEM_DOMAIN_RAW: PyMem_RawFree(ptr); break;
3355 case PYMEM_DOMAIN_MEM: PyMem_Free(ptr); break;
3356 case PYMEM_DOMAIN_OBJ: PyObject_Free(ptr); break;
3357 }
3358
Victor Stinner0507bf52013-07-07 02:05:46 +02003359 Py_INCREF(Py_None);
3360 res = Py_None;
3361 goto finally;
3362
3363fail:
3364 PyErr_SetString(PyExc_RuntimeError, error_msg);
3365
3366finally:
3367 PyMem_SetAllocator(domain, &hook.alloc);
3368 return res;
3369}
3370
3371static PyObject *
3372test_pymem_setrawallocators(PyObject *self)
3373{
3374 return test_setallocators(PYMEM_DOMAIN_RAW);
3375}
3376
3377static PyObject *
3378test_pymem_setallocators(PyObject *self)
3379{
3380 return test_setallocators(PYMEM_DOMAIN_MEM);
3381}
3382
3383static PyObject *
3384test_pyobject_setallocators(PyObject *self)
3385{
3386 return test_setallocators(PYMEM_DOMAIN_OBJ);
3387}
3388
Larry Hastings44e2eaa2013-11-23 15:37:55 -08003389PyDoc_STRVAR(docstring_empty,
3390""
3391);
3392
3393PyDoc_STRVAR(docstring_no_signature,
3394"This docstring has no signature."
3395);
3396
3397PyDoc_STRVAR(docstring_with_invalid_signature,
Larry Hastings2623c8c2014-02-08 22:15:29 -08003398"docstring_with_invalid_signature($module, /, boo)\n"
Larry Hastings44e2eaa2013-11-23 15:37:55 -08003399"\n"
3400"This docstring has an invalid signature."
3401);
3402
Larry Hastings2623c8c2014-02-08 22:15:29 -08003403PyDoc_STRVAR(docstring_with_invalid_signature2,
3404"docstring_with_invalid_signature2($module, /, boo)\n"
3405"\n"
3406"--\n"
3407"\n"
3408"This docstring also has an invalid signature."
3409);
3410
Larry Hastings44e2eaa2013-11-23 15:37:55 -08003411PyDoc_STRVAR(docstring_with_signature,
Larry Hastings2623c8c2014-02-08 22:15:29 -08003412"docstring_with_signature($module, /, sig)\n"
3413"--\n"
3414"\n"
Larry Hastings44e2eaa2013-11-23 15:37:55 -08003415"This docstring has a valid signature."
3416);
3417
Zachary Ware8ef887c2015-04-13 18:22:35 -05003418PyDoc_STRVAR(docstring_with_signature_but_no_doc,
3419"docstring_with_signature_but_no_doc($module, /, sig)\n"
3420"--\n"
3421"\n"
3422);
3423
Larry Hastings44e2eaa2013-11-23 15:37:55 -08003424PyDoc_STRVAR(docstring_with_signature_and_extra_newlines,
Larry Hastings2623c8c2014-02-08 22:15:29 -08003425"docstring_with_signature_and_extra_newlines($module, /, parameter)\n"
3426"--\n"
Larry Hastings44e2eaa2013-11-23 15:37:55 -08003427"\n"
3428"\n"
3429"This docstring has a valid signature and some extra newlines."
3430);
3431
Larry Hastings16c51912014-01-07 11:53:01 -08003432PyDoc_STRVAR(docstring_with_signature_with_defaults,
Larry Hastings2623c8c2014-02-08 22:15:29 -08003433"docstring_with_signature_with_defaults(module, s='avocado',\n"
3434" b=b'bytes', d=3.14, i=35, n=None, t=True, f=False,\n"
3435" local=the_number_three, sys=sys.maxsize,\n"
3436" exp=sys.maxsize - 1)\n"
3437"--\n"
Larry Hastings16c51912014-01-07 11:53:01 -08003438"\n"
3439"\n"
3440"\n"
3441"This docstring has a valid signature with parameters,\n"
3442"and the parameters take defaults of varying types."
3443);
3444
Victor Stinner258e4d32013-12-13 02:30:12 +01003445#ifdef WITH_THREAD
Victor Stinnerfdeb6ec2013-12-13 02:01:38 +01003446typedef struct {
3447 PyThread_type_lock start_event;
3448 PyThread_type_lock exit_event;
3449 PyObject *callback;
3450} test_c_thread_t;
3451
3452static void
3453temporary_c_thread(void *data)
3454{
3455 test_c_thread_t *test_c_thread = data;
3456 PyGILState_STATE state;
3457 PyObject *res;
3458
3459 PyThread_release_lock(test_c_thread->start_event);
3460
3461 /* Allocate a Python thread state for this thread */
3462 state = PyGILState_Ensure();
3463
Victor Stinner3466bde2016-09-05 18:16:01 -07003464 res = _PyObject_CallNoArg(test_c_thread->callback);
Victor Stinnerfdeb6ec2013-12-13 02:01:38 +01003465 Py_CLEAR(test_c_thread->callback);
3466
3467 if (res == NULL) {
3468 PyErr_Print();
3469 }
3470 else {
3471 Py_DECREF(res);
3472 }
3473
3474 /* Destroy the Python thread state for this thread */
3475 PyGILState_Release(state);
3476
3477 PyThread_release_lock(test_c_thread->exit_event);
3478
3479 PyThread_exit_thread();
3480}
3481
3482static PyObject *
3483call_in_temporary_c_thread(PyObject *self, PyObject *callback)
3484{
3485 PyObject *res = NULL;
3486 test_c_thread_t test_c_thread;
3487 long thread;
3488
3489 PyEval_InitThreads();
3490
3491 test_c_thread.start_event = PyThread_allocate_lock();
3492 test_c_thread.exit_event = PyThread_allocate_lock();
3493 test_c_thread.callback = NULL;
3494 if (!test_c_thread.start_event || !test_c_thread.exit_event) {
3495 PyErr_SetString(PyExc_RuntimeError, "could not allocate lock");
3496 goto exit;
3497 }
3498
3499 Py_INCREF(callback);
3500 test_c_thread.callback = callback;
3501
3502 PyThread_acquire_lock(test_c_thread.start_event, 1);
3503 PyThread_acquire_lock(test_c_thread.exit_event, 1);
3504
3505 thread = PyThread_start_new_thread(temporary_c_thread, &test_c_thread);
3506 if (thread == -1) {
3507 PyErr_SetString(PyExc_RuntimeError, "unable to start the thread");
3508 PyThread_release_lock(test_c_thread.start_event);
3509 PyThread_release_lock(test_c_thread.exit_event);
3510 goto exit;
3511 }
3512
3513 PyThread_acquire_lock(test_c_thread.start_event, 1);
3514 PyThread_release_lock(test_c_thread.start_event);
3515
3516 Py_BEGIN_ALLOW_THREADS
3517 PyThread_acquire_lock(test_c_thread.exit_event, 1);
3518 PyThread_release_lock(test_c_thread.exit_event);
3519 Py_END_ALLOW_THREADS
3520
3521 Py_INCREF(Py_None);
3522 res = Py_None;
3523
3524exit:
3525 Py_CLEAR(test_c_thread.callback);
3526 if (test_c_thread.start_event)
3527 PyThread_free_lock(test_c_thread.start_event);
3528 if (test_c_thread.exit_event)
3529 PyThread_free_lock(test_c_thread.exit_event);
3530 return res;
3531}
Victor Stinner258e4d32013-12-13 02:30:12 +01003532#endif /* WITH_THREAD */
Victor Stinner13105102013-12-13 02:17:29 +01003533
Victor Stinner56e8c292014-07-21 12:30:22 +02003534static PyObject*
3535test_raise_signal(PyObject* self, PyObject *args)
3536{
3537 int signum, err;
3538
3539 if (PyArg_ParseTuple(args, "i:raise_signal", &signum) < 0)
3540 return NULL;
3541
3542 err = raise(signum);
3543 if (err)
3544 return PyErr_SetFromErrno(PyExc_OSError);
3545
3546 if (PyErr_CheckSignals() < 0)
3547 return NULL;
3548
3549 Py_RETURN_NONE;
3550}
3551
Serhiy Storchakab5181342015-02-06 08:58:56 +02003552/* marshal */
3553
3554static PyObject*
3555pymarshal_write_long_to_file(PyObject* self, PyObject *args)
3556{
3557 long value;
3558 char *filename;
3559 int version;
3560 FILE *fp;
3561
3562 if (!PyArg_ParseTuple(args, "lsi:pymarshal_write_long_to_file",
3563 &value, &filename, &version))
3564 return NULL;
3565
3566 fp = fopen(filename, "wb");
3567 if (fp == NULL) {
3568 PyErr_SetFromErrno(PyExc_OSError);
3569 return NULL;
3570 }
3571
3572 PyMarshal_WriteLongToFile(value, fp, version);
3573
3574 fclose(fp);
3575 if (PyErr_Occurred())
3576 return NULL;
3577 Py_RETURN_NONE;
3578}
3579
3580static PyObject*
3581pymarshal_write_object_to_file(PyObject* self, PyObject *args)
3582{
3583 PyObject *obj;
3584 char *filename;
3585 int version;
3586 FILE *fp;
3587
3588 if (!PyArg_ParseTuple(args, "Osi:pymarshal_write_object_to_file",
3589 &obj, &filename, &version))
3590 return NULL;
3591
3592 fp = fopen(filename, "wb");
3593 if (fp == NULL) {
3594 PyErr_SetFromErrno(PyExc_OSError);
3595 return NULL;
3596 }
3597
3598 PyMarshal_WriteObjectToFile(obj, fp, version);
3599
3600 fclose(fp);
3601 if (PyErr_Occurred())
3602 return NULL;
3603 Py_RETURN_NONE;
3604}
3605
3606static PyObject*
3607pymarshal_read_short_from_file(PyObject* self, PyObject *args)
3608{
3609 int value;
3610 long pos;
3611 char *filename;
3612 FILE *fp;
3613
3614 if (!PyArg_ParseTuple(args, "s:pymarshal_read_short_from_file", &filename))
3615 return NULL;
3616
3617 fp = fopen(filename, "rb");
3618 if (fp == NULL) {
3619 PyErr_SetFromErrno(PyExc_OSError);
3620 return NULL;
3621 }
3622
3623 value = PyMarshal_ReadShortFromFile(fp);
3624 pos = ftell(fp);
3625
3626 fclose(fp);
3627 if (PyErr_Occurred())
3628 return NULL;
3629 return Py_BuildValue("il", value, pos);
3630}
3631
3632static PyObject*
3633pymarshal_read_long_from_file(PyObject* self, PyObject *args)
3634{
3635 long value, pos;
3636 char *filename;
3637 FILE *fp;
3638
3639 if (!PyArg_ParseTuple(args, "s:pymarshal_read_long_from_file", &filename))
3640 return NULL;
3641
3642 fp = fopen(filename, "rb");
3643 if (fp == NULL) {
3644 PyErr_SetFromErrno(PyExc_OSError);
3645 return NULL;
3646 }
3647
3648 value = PyMarshal_ReadLongFromFile(fp);
3649 pos = ftell(fp);
3650
3651 fclose(fp);
3652 if (PyErr_Occurred())
3653 return NULL;
3654 return Py_BuildValue("ll", value, pos);
3655}
3656
3657static PyObject*
3658pymarshal_read_last_object_from_file(PyObject* self, PyObject *args)
3659{
3660 PyObject *obj;
3661 long pos;
3662 char *filename;
3663 FILE *fp;
3664
3665 if (!PyArg_ParseTuple(args, "s:pymarshal_read_last_object_from_file", &filename))
3666 return NULL;
3667
3668 fp = fopen(filename, "rb");
3669 if (fp == NULL) {
3670 PyErr_SetFromErrno(PyExc_OSError);
3671 return NULL;
3672 }
3673
3674 obj = PyMarshal_ReadLastObjectFromFile(fp);
3675 pos = ftell(fp);
3676
3677 fclose(fp);
3678 return Py_BuildValue("Nl", obj, pos);
3679}
3680
3681static PyObject*
3682pymarshal_read_object_from_file(PyObject* self, PyObject *args)
3683{
3684 PyObject *obj;
3685 long pos;
3686 char *filename;
3687 FILE *fp;
3688
3689 if (!PyArg_ParseTuple(args, "s:pymarshal_read_object_from_file", &filename))
3690 return NULL;
3691
3692 fp = fopen(filename, "rb");
3693 if (fp == NULL) {
3694 PyErr_SetFromErrno(PyExc_OSError);
3695 return NULL;
3696 }
3697
3698 obj = PyMarshal_ReadObjectFromFile(fp);
3699 pos = ftell(fp);
3700
3701 fclose(fp);
3702 return Py_BuildValue("Nl", obj, pos);
3703}
3704
Victor Stinnerefde1462015-03-21 15:04:43 +01003705static PyObject*
3706return_null_without_error(PyObject *self, PyObject *args)
3707{
3708 /* invalid call: return NULL without setting an error,
3709 * _Py_CheckFunctionResult() must detect such bug at runtime. */
3710 PyErr_Clear();
3711 return NULL;
3712}
3713
3714static PyObject*
3715return_result_with_error(PyObject *self, PyObject *args)
3716{
3717 /* invalid call: return a result with an error set,
3718 * _Py_CheckFunctionResult() must detect such bug at runtime. */
3719 PyErr_SetNone(PyExc_ValueError);
3720 Py_RETURN_NONE;
3721}
3722
Victor Stinner992c43f2015-03-27 17:12:45 +01003723static PyObject *
Victor Stinner13019fd2015-04-03 13:10:54 +02003724test_pytime_fromseconds(PyObject *self, PyObject *args)
3725{
3726 int seconds;
3727 _PyTime_t ts;
3728
3729 if (!PyArg_ParseTuple(args, "i", &seconds))
3730 return NULL;
3731 ts = _PyTime_FromSeconds(seconds);
3732 return _PyTime_AsNanosecondsObject(ts);
3733}
3734
3735static PyObject *
Victor Stinner992c43f2015-03-27 17:12:45 +01003736test_pytime_fromsecondsobject(PyObject *self, PyObject *args)
3737{
3738 PyObject *obj;
3739 int round;
3740 _PyTime_t ts;
3741
3742 if (!PyArg_ParseTuple(args, "Oi", &obj, &round))
3743 return NULL;
3744 if (check_time_rounding(round) < 0)
3745 return NULL;
3746 if (_PyTime_FromSecondsObject(&ts, obj, round) == -1)
3747 return NULL;
3748 return _PyTime_AsNanosecondsObject(ts);
3749}
3750
Victor Stinner4bfb4602015-03-27 22:27:24 +01003751static PyObject *
3752test_pytime_assecondsdouble(PyObject *self, PyObject *args)
3753{
Benjamin Petersonaf580df2016-09-06 10:46:49 -07003754 long long ns;
Victor Stinner4bfb4602015-03-27 22:27:24 +01003755 _PyTime_t ts;
3756 double d;
3757
3758 if (!PyArg_ParseTuple(args, "L", &ns))
3759 return NULL;
3760 ts = _PyTime_FromNanoseconds(ns);
3761 d = _PyTime_AsSecondsDouble(ts);
3762 return PyFloat_FromDouble(d);
3763}
3764
Victor Stinner95e9cef2015-03-28 01:26:47 +01003765static PyObject *
3766test_PyTime_AsTimeval(PyObject *self, PyObject *args)
3767{
Benjamin Petersonaf580df2016-09-06 10:46:49 -07003768 long long ns;
Victor Stinner95e9cef2015-03-28 01:26:47 +01003769 int round;
3770 _PyTime_t t;
3771 struct timeval tv;
3772 PyObject *seconds;
3773
3774 if (!PyArg_ParseTuple(args, "Li", &ns, &round))
3775 return NULL;
3776 if (check_time_rounding(round) < 0)
3777 return NULL;
3778 t = _PyTime_FromNanoseconds(ns);
Victor Stinnerea9c0dd2015-03-30 02:51:13 +02003779 if (_PyTime_AsTimeval(t, &tv, round) < 0)
Victor Stinner95e9cef2015-03-28 01:26:47 +01003780 return NULL;
Victor Stinner95e9cef2015-03-28 01:26:47 +01003781
Benjamin Petersonaf580df2016-09-06 10:46:49 -07003782 seconds = PyLong_FromLong((long long)tv.tv_sec);
Victor Stinner95e9cef2015-03-28 01:26:47 +01003783 if (seconds == NULL)
3784 return NULL;
3785 return Py_BuildValue("Nl", seconds, tv.tv_usec);
3786}
3787
Victor Stinner34dc0f42015-03-27 18:19:03 +01003788#ifdef HAVE_CLOCK_GETTIME
3789static PyObject *
3790test_PyTime_AsTimespec(PyObject *self, PyObject *args)
3791{
Benjamin Petersonaf580df2016-09-06 10:46:49 -07003792 long long ns;
Victor Stinner34dc0f42015-03-27 18:19:03 +01003793 _PyTime_t t;
3794 struct timespec ts;
3795
3796 if (!PyArg_ParseTuple(args, "L", &ns))
3797 return NULL;
3798 t = _PyTime_FromNanoseconds(ns);
3799 if (_PyTime_AsTimespec(t, &ts) == -1)
3800 return NULL;
3801 return Py_BuildValue("Nl", _PyLong_FromTime_t(ts.tv_sec), ts.tv_nsec);
3802}
3803#endif
3804
Victor Stinner62d1c702015-04-01 17:47:07 +02003805static PyObject *
3806test_PyTime_AsMilliseconds(PyObject *self, PyObject *args)
3807{
Benjamin Petersonaf580df2016-09-06 10:46:49 -07003808 long long ns;
Victor Stinner62d1c702015-04-01 17:47:07 +02003809 int round;
3810 _PyTime_t t, ms;
3811
3812 if (!PyArg_ParseTuple(args, "Li", &ns, &round))
3813 return NULL;
3814 if (check_time_rounding(round) < 0)
3815 return NULL;
3816 t = _PyTime_FromNanoseconds(ns);
3817 ms = _PyTime_AsMilliseconds(t, round);
3818 /* This conversion rely on the fact that _PyTime_t is a number of
3819 nanoseconds */
3820 return _PyTime_AsNanosecondsObject(ms);
3821}
3822
3823static PyObject *
3824test_PyTime_AsMicroseconds(PyObject *self, PyObject *args)
3825{
Benjamin Petersonaf580df2016-09-06 10:46:49 -07003826 long long ns;
Victor Stinner62d1c702015-04-01 17:47:07 +02003827 int round;
3828 _PyTime_t t, ms;
3829
3830 if (!PyArg_ParseTuple(args, "Li", &ns, &round))
3831 return NULL;
3832 if (check_time_rounding(round) < 0)
3833 return NULL;
3834 t = _PyTime_FromNanoseconds(ns);
3835 ms = _PyTime_AsMicroseconds(t, round);
3836 /* This conversion rely on the fact that _PyTime_t is a number of
3837 nanoseconds */
3838 return _PyTime_AsNanosecondsObject(ms);
3839}
3840
Victor Stinner50856d52015-10-13 00:11:21 +02003841static PyObject*
3842get_recursion_depth(PyObject *self, PyObject *args)
3843{
3844 PyThreadState *tstate = PyThreadState_GET();
3845
Raymond Hettinger15f44ab2016-08-30 10:47:49 -07003846 /* subtract one to ignore the frame of the get_recursion_depth() call */
Victor Stinner50856d52015-10-13 00:11:21 +02003847 return PyLong_FromLong(tstate->recursion_depth - 1);
3848}
3849
Victor Stinner34be807c2016-03-14 12:04:26 +01003850static PyObject*
3851pymem_buffer_overflow(PyObject *self, PyObject *args)
3852{
3853 char *buffer;
3854
3855 /* Deliberate buffer overflow to check that PyMem_Free() detects
3856 the overflow when debug hooks are installed. */
3857 buffer = PyMem_Malloc(16);
3858 buffer[16] = 'x';
3859 PyMem_Free(buffer);
3860
3861 Py_RETURN_NONE;
3862}
3863
3864static PyObject*
3865pymem_api_misuse(PyObject *self, PyObject *args)
3866{
3867 char *buffer;
3868
3869 /* Deliberate misusage of Python allocators:
3870 allococate with PyMem but release with PyMem_Raw. */
3871 buffer = PyMem_Malloc(16);
3872 PyMem_RawFree(buffer);
3873
3874 Py_RETURN_NONE;
3875}
3876
Victor Stinnerc4aec362016-03-14 22:26:53 +01003877static PyObject*
Victor Stinnerad524372016-03-16 12:12:53 +01003878pymem_malloc_without_gil(PyObject *self, PyObject *args)
3879{
3880 char *buffer;
3881
3882 /* Deliberate bug to test debug hooks on Python memory allocators:
3883 call PyMem_Malloc() without holding the GIL */
3884 Py_BEGIN_ALLOW_THREADS
3885 buffer = PyMem_Malloc(10);
3886 Py_END_ALLOW_THREADS
3887
3888 PyMem_Free(buffer);
3889
3890 Py_RETURN_NONE;
3891}
3892
3893static PyObject*
Victor Stinnerc4aec362016-03-14 22:26:53 +01003894pyobject_malloc_without_gil(PyObject *self, PyObject *args)
3895{
3896 char *buffer;
3897
Victor Stinnerad524372016-03-16 12:12:53 +01003898 /* Deliberate bug to test debug hooks on Python memory allocators:
3899 call PyObject_Malloc() without holding the GIL */
Victor Stinnerc4aec362016-03-14 22:26:53 +01003900 Py_BEGIN_ALLOW_THREADS
3901 buffer = PyObject_Malloc(10);
3902 Py_END_ALLOW_THREADS
3903
3904 PyObject_Free(buffer);
3905
3906 Py_RETURN_NONE;
3907}
3908
Victor Stinner10b73e12016-03-22 13:39:05 +01003909static PyObject *
3910tracemalloc_track(PyObject *self, PyObject *args)
3911{
3912 unsigned int domain;
3913 PyObject *ptr_obj;
3914 void *ptr;
3915 Py_ssize_t size;
3916 int release_gil = 0;
3917 int res;
3918
3919 if (!PyArg_ParseTuple(args, "IOn|i", &domain, &ptr_obj, &size, &release_gil))
3920 return NULL;
3921 ptr = PyLong_AsVoidPtr(ptr_obj);
3922 if (PyErr_Occurred())
3923 return NULL;
3924
3925 if (release_gil) {
3926 Py_BEGIN_ALLOW_THREADS
Benjamin Petersonca470632016-09-06 13:47:26 -07003927 res = _PyTraceMalloc_Track(domain, (uintptr_t)ptr, size);
Victor Stinner10b73e12016-03-22 13:39:05 +01003928 Py_END_ALLOW_THREADS
3929 }
3930 else {
Benjamin Petersonca470632016-09-06 13:47:26 -07003931 res = _PyTraceMalloc_Track(domain, (uintptr_t)ptr, size);
Victor Stinner10b73e12016-03-22 13:39:05 +01003932 }
3933
3934 if (res < 0) {
3935 PyErr_SetString(PyExc_RuntimeError, "_PyTraceMalloc_Track error");
3936 return NULL;
3937 }
3938
3939 Py_RETURN_NONE;
3940}
3941
3942static PyObject *
3943tracemalloc_untrack(PyObject *self, PyObject *args)
3944{
3945 unsigned int domain;
3946 PyObject *ptr_obj;
3947 void *ptr;
3948 int res;
3949
3950 if (!PyArg_ParseTuple(args, "IO", &domain, &ptr_obj))
3951 return NULL;
3952 ptr = PyLong_AsVoidPtr(ptr_obj);
3953 if (PyErr_Occurred())
3954 return NULL;
3955
Benjamin Petersonca470632016-09-06 13:47:26 -07003956 res = _PyTraceMalloc_Untrack(domain, (uintptr_t)ptr);
Victor Stinner10b73e12016-03-22 13:39:05 +01003957 if (res < 0) {
3958 PyErr_SetString(PyExc_RuntimeError, "_PyTraceMalloc_Track error");
3959 return NULL;
3960 }
3961
3962 Py_RETURN_NONE;
3963}
3964
3965static PyObject *
3966tracemalloc_get_traceback(PyObject *self, PyObject *args)
3967{
3968 unsigned int domain;
3969 PyObject *ptr_obj;
3970 void *ptr;
3971
3972 if (!PyArg_ParseTuple(args, "IO", &domain, &ptr_obj))
3973 return NULL;
3974 ptr = PyLong_AsVoidPtr(ptr_obj);
3975 if (PyErr_Occurred())
3976 return NULL;
3977
Benjamin Petersonca470632016-09-06 13:47:26 -07003978 return _PyTraceMalloc_GetTraceback(domain, (uintptr_t)ptr);
Victor Stinner10b73e12016-03-22 13:39:05 +01003979}
3980
Victor Stinner3b6a6b42016-09-08 12:51:24 -07003981static PyObject *
3982dict_get_version(PyObject *self, PyObject *args)
3983{
3984 PyDictObject *dict;
3985 uint64_t version;
3986
3987 if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &dict))
3988 return NULL;
3989
3990 version = dict->ma_version_tag;
3991
3992 Py_BUILD_ASSERT(sizeof(unsigned PY_LONG_LONG) >= sizeof(version));
3993 return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)version);
3994}
3995
Victor Stinnerfdeb6ec2013-12-13 02:01:38 +01003996
Tim Peters9ea17ac2001-02-02 05:57:15 +00003997static PyMethodDef TestMethods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003998 {"raise_exception", raise_exception, METH_VARARGS},
3999 {"raise_memoryerror", (PyCFunction)raise_memoryerror, METH_NOARGS},
Antoine Pitrou6bc217d2015-06-23 14:31:11 +02004000 {"set_errno", set_errno, METH_VARARGS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004001 {"test_config", (PyCFunction)test_config, METH_NOARGS},
Victor Stinner01076552013-10-29 19:39:52 +01004002 {"test_sizeof_c_types", (PyCFunction)test_sizeof_c_types, METH_NOARGS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004003 {"test_datetime_capi", test_datetime_capi, METH_NOARGS},
4004 {"test_list_api", (PyCFunction)test_list_api, METH_NOARGS},
4005 {"test_dict_iteration", (PyCFunction)test_dict_iteration,METH_NOARGS},
4006 {"test_lazy_hash_inheritance", (PyCFunction)test_lazy_hash_inheritance,METH_NOARGS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004007 {"test_long_api", (PyCFunction)test_long_api, METH_NOARGS},
Benjamin Petersonda5eb5a2013-05-27 14:46:14 -07004008 {"test_xincref_doesnt_leak",(PyCFunction)test_xincref_doesnt_leak, METH_NOARGS},
4009 {"test_incref_doesnt_leak", (PyCFunction)test_incref_doesnt_leak, METH_NOARGS},
4010 {"test_xdecref_doesnt_leak",(PyCFunction)test_xdecref_doesnt_leak, METH_NOARGS},
4011 {"test_decref_doesnt_leak", (PyCFunction)test_decref_doesnt_leak, METH_NOARGS},
Christian Heimes4efdb412013-07-31 02:36:43 +02004012 {"test_incref_decref_API", (PyCFunction)test_incref_decref_API, METH_NOARGS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004013 {"test_long_and_overflow", (PyCFunction)test_long_and_overflow,
4014 METH_NOARGS},
Nadeem Vawda3d5881e2011-09-07 21:40:26 +02004015 {"test_long_as_double", (PyCFunction)test_long_as_double,METH_NOARGS},
4016 {"test_long_as_size_t", (PyCFunction)test_long_as_size_t,METH_NOARGS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004017 {"test_long_numbits", (PyCFunction)test_long_numbits, METH_NOARGS},
4018 {"test_k_code", (PyCFunction)test_k_code, METH_NOARGS},
4019 {"test_empty_argparse", (PyCFunction)test_empty_argparse,METH_NOARGS},
Larry Hastings8f904da2012-06-22 03:56:29 -07004020 {"parse_tuple_and_keywords", parse_tuple_and_keywords, METH_VARARGS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004021 {"test_null_strings", (PyCFunction)test_null_strings, METH_NOARGS},
4022 {"test_string_from_format", (PyCFunction)test_string_from_format, METH_NOARGS},
4023 {"test_with_docstring", (PyCFunction)test_with_docstring, METH_NOARGS,
4024 PyDoc_STR("This is a pretty normal docstring.")},
4025 {"test_string_to_double", (PyCFunction)test_string_to_double, METH_NOARGS},
4026 {"test_unicode_compare_with_ascii", (PyCFunction)test_unicode_compare_with_ascii, METH_NOARGS},
4027 {"test_capsule", (PyCFunction)test_capsule, METH_NOARGS},
Stefan Krah7213fcc2015-02-01 16:19:23 +01004028 {"test_from_contiguous", (PyCFunction)test_from_contiguous, METH_NOARGS},
Stefan Kraha7559c02015-02-03 22:27:21 +01004029#if (defined(__linux__) || defined(__FreeBSD__)) && defined(__GNUC__)
Stefan Krah5178d912015-02-03 16:57:21 +01004030 {"test_pep3118_obsolete_write_locks", (PyCFunction)test_pep3118_obsolete_write_locks, METH_NOARGS},
Stefan Kraha7559c02015-02-03 22:27:21 +01004031#endif
Stefan Krah650c1e82015-02-03 21:43:23 +01004032 {"getbuffer_with_null_view", getbuffer_with_null_view, METH_O},
Serhiy Storchaka13e602e2016-05-20 22:31:14 +03004033 {"test_buildvalue_N", test_buildvalue_N, METH_NOARGS},
Serhiy Storchakace412872016-05-08 23:36:44 +03004034 {"get_args", get_args, METH_VARARGS},
4035 {"get_kwargs", (PyCFunction)get_kwargs, METH_VARARGS|METH_KEYWORDS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004036 {"getargs_tuple", getargs_tuple, METH_VARARGS},
4037 {"getargs_keywords", (PyCFunction)getargs_keywords,
4038 METH_VARARGS|METH_KEYWORDS},
Larry Hastings83a9f482012-03-20 20:06:16 +00004039 {"getargs_keyword_only", (PyCFunction)getargs_keyword_only,
4040 METH_VARARGS|METH_KEYWORDS},
Serhiy Storchakaf41b82f2016-06-09 16:30:29 +03004041 {"getargs_positional_only_and_keywords",
4042 (PyCFunction)getargs_positional_only_and_keywords,
4043 METH_VARARGS|METH_KEYWORDS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004044 {"getargs_b", getargs_b, METH_VARARGS},
4045 {"getargs_B", getargs_B, METH_VARARGS},
4046 {"getargs_h", getargs_h, METH_VARARGS},
4047 {"getargs_H", getargs_H, METH_VARARGS},
4048 {"getargs_I", getargs_I, METH_VARARGS},
4049 {"getargs_k", getargs_k, METH_VARARGS},
4050 {"getargs_i", getargs_i, METH_VARARGS},
4051 {"getargs_l", getargs_l, METH_VARARGS},
4052 {"getargs_n", getargs_n, METH_VARARGS},
Larry Hastingsfaf91e72012-05-05 16:54:29 -07004053 {"getargs_p", getargs_p, METH_VARARGS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004054 {"getargs_L", getargs_L, METH_VARARGS},
4055 {"getargs_K", getargs_K, METH_VARARGS},
4056 {"test_longlong_api", test_longlong_api, METH_NOARGS},
4057 {"test_long_long_and_overflow",
4058 (PyCFunction)test_long_long_and_overflow, METH_NOARGS},
4059 {"test_L_code", (PyCFunction)test_L_code, METH_NOARGS},
Serhiy Storchakaf95455d2016-05-16 10:11:47 +03004060 {"getargs_f", getargs_f, METH_VARARGS},
4061 {"getargs_d", getargs_d, METH_VARARGS},
4062 {"getargs_D", getargs_D, METH_VARARGS},
4063 {"getargs_S", getargs_S, METH_VARARGS},
4064 {"getargs_Y", getargs_Y, METH_VARARGS},
4065 {"getargs_U", getargs_U, METH_VARARGS},
Eli Bendersky906b88f2011-07-29 07:05:08 +03004066 {"getargs_c", getargs_c, METH_VARARGS},
Serhiy Storchakac8241fd2016-01-28 19:49:54 +02004067 {"getargs_C", getargs_C, METH_VARARGS},
Victor Stinner06e49dd2010-06-13 18:21:50 +00004068 {"getargs_s", getargs_s, METH_VARARGS},
4069 {"getargs_s_star", getargs_s_star, METH_VARARGS},
4070 {"getargs_s_hash", getargs_s_hash, METH_VARARGS},
4071 {"getargs_z", getargs_z, METH_VARARGS},
4072 {"getargs_z_star", getargs_z_star, METH_VARARGS},
4073 {"getargs_z_hash", getargs_z_hash, METH_VARARGS},
4074 {"getargs_y", getargs_y, METH_VARARGS},
4075 {"getargs_y_star", getargs_y_star, METH_VARARGS},
4076 {"getargs_y_hash", getargs_y_hash, METH_VARARGS},
4077 {"getargs_u", getargs_u, METH_VARARGS},
4078 {"getargs_u_hash", getargs_u_hash, METH_VARARGS},
4079 {"getargs_Z", getargs_Z, METH_VARARGS},
4080 {"getargs_Z_hash", getargs_Z_hash, METH_VARARGS},
Victor Stinner25e8ec42010-06-25 00:02:38 +00004081 {"getargs_w_star", getargs_w_star, METH_VARARGS},
Serhiy Storchakac8241fd2016-01-28 19:49:54 +02004082 {"getargs_es", getargs_es, METH_VARARGS},
4083 {"getargs_et", getargs_et, METH_VARARGS},
4084 {"getargs_es_hash", getargs_es_hash, METH_VARARGS},
4085 {"getargs_et_hash", getargs_et_hash, METH_VARARGS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004086 {"codec_incrementalencoder",
Victor Stinner1c24bd02010-10-02 11:03:13 +00004087 (PyCFunction)codec_incrementalencoder, METH_VARARGS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004088 {"codec_incrementaldecoder",
Victor Stinner1c24bd02010-10-02 11:03:13 +00004089 (PyCFunction)codec_incrementaldecoder, METH_VARARGS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004090 {"test_s_code", (PyCFunction)test_s_code, METH_NOARGS},
4091 {"test_u_code", (PyCFunction)test_u_code, METH_NOARGS},
4092 {"test_Z_code", (PyCFunction)test_Z_code, METH_NOARGS},
4093 {"test_widechar", (PyCFunction)test_widechar, METH_NOARGS},
Victor Stinner42bf7752011-11-21 22:52:58 +01004094 {"unicode_aswidechar", unicode_aswidechar, METH_VARARGS},
4095 {"unicode_aswidecharstring",unicode_aswidecharstring, METH_VARARGS},
Serhiy Storchakacc164232016-10-02 21:29:26 +03004096 {"unicode_asucs4", unicode_asucs4, METH_VARARGS},
Serhiy Storchaka9c0e1f82016-10-08 22:45:38 +03004097 {"unicode_copycharacters", unicode_copycharacters, METH_VARARGS},
Victor Stinner42bf7752011-11-21 22:52:58 +01004098 {"unicode_encodedecimal", unicode_encodedecimal, METH_VARARGS},
4099 {"unicode_transformdecimaltoascii", unicode_transformdecimaltoascii, METH_VARARGS},
Stefan Krahe6996ed2012-11-02 14:44:20 +01004100 {"unicode_legacy_string", unicode_legacy_string, METH_VARARGS},
Mark Hammond8d98d2c2003-04-19 15:41:53 +00004101#ifdef WITH_THREAD
Victor Stinner1c24bd02010-10-02 11:03:13 +00004102 {"_test_thread_state", test_thread_state, METH_VARARGS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004103 {"_pending_threadfunc", pending_threadfunc, METH_VARARGS},
Mark Hammond8d98d2c2003-04-19 15:41:53 +00004104#endif
Guido van Rossumddefaf32007-01-14 03:31:43 +00004105#ifdef HAVE_GETTIMEOFDAY
Victor Stinner1c24bd02010-10-02 11:03:13 +00004106 {"profile_int", profile_int, METH_NOARGS},
Guido van Rossumddefaf32007-01-14 03:31:43 +00004107#endif
Victor Stinner1c24bd02010-10-02 11:03:13 +00004108 {"traceback_print", traceback_print, METH_VARARGS},
4109 {"exception_print", exception_print, METH_VARARGS},
Martin v. Löwisaa2efcb2012-04-19 14:33:43 +02004110 {"set_exc_info", test_set_exc_info, METH_VARARGS},
Victor Stinner1c24bd02010-10-02 11:03:13 +00004111 {"argparsing", argparsing, METH_VARARGS},
4112 {"code_newempty", code_newempty, METH_VARARGS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004113 {"make_exception_with_doc", (PyCFunction)make_exception_with_doc,
4114 METH_VARARGS | METH_KEYWORDS},
Antoine Pitrou5bffa792011-02-24 20:50:49 +00004115 {"make_memoryview_from_NULL_pointer", (PyCFunction)make_memoryview_from_NULL_pointer,
4116 METH_NOARGS},
Jeffrey Yasskin8e0bdfd2010-05-13 18:31:05 +00004117 {"crash_no_current_thread", (PyCFunction)crash_no_current_thread, METH_NOARGS},
Antoine Pitrou2f828f22012-01-18 00:21:11 +01004118 {"run_in_subinterp", run_in_subinterp, METH_VARARGS},
Victor Stinner5d272cc2012-03-13 13:35:55 +01004119 {"pytime_object_to_time_t", test_pytime_object_to_time_t, METH_VARARGS},
4120 {"pytime_object_to_timeval", test_pytime_object_to_timeval, METH_VARARGS},
Victor Stinner643cd682012-03-02 22:54:03 +01004121 {"pytime_object_to_timespec", test_pytime_object_to_timespec, METH_VARARGS},
Antoine Pitrou796564c2013-07-30 19:59:21 +02004122 {"with_tp_del", with_tp_del, METH_VARARGS},
Antoine Pitroub349e4c2014-08-06 19:31:40 -04004123 {"create_cfunction", create_cfunction, METH_NOARGS},
Victor Stinner0507bf52013-07-07 02:05:46 +02004124 {"test_pymem_alloc0",
Victor Stinner797bcb52014-06-02 21:29:07 +02004125 (PyCFunction)test_pymem_alloc0, METH_NOARGS},
4126 {"test_pymem_setrawallocators",
Victor Stinner0507bf52013-07-07 02:05:46 +02004127 (PyCFunction)test_pymem_setrawallocators, METH_NOARGS},
4128 {"test_pymem_setallocators",
4129 (PyCFunction)test_pymem_setallocators, METH_NOARGS},
4130 {"test_pyobject_setallocators",
4131 (PyCFunction)test_pyobject_setallocators, METH_NOARGS},
Larry Hastings44e2eaa2013-11-23 15:37:55 -08004132 {"no_docstring",
4133 (PyCFunction)test_with_docstring, METH_NOARGS},
4134 {"docstring_empty",
4135 (PyCFunction)test_with_docstring, METH_NOARGS,
4136 docstring_empty},
4137 {"docstring_no_signature",
4138 (PyCFunction)test_with_docstring, METH_NOARGS,
4139 docstring_no_signature},
4140 {"docstring_with_invalid_signature",
4141 (PyCFunction)test_with_docstring, METH_NOARGS,
4142 docstring_with_invalid_signature},
Larry Hastings2623c8c2014-02-08 22:15:29 -08004143 {"docstring_with_invalid_signature2",
4144 (PyCFunction)test_with_docstring, METH_NOARGS,
4145 docstring_with_invalid_signature2},
Larry Hastings44e2eaa2013-11-23 15:37:55 -08004146 {"docstring_with_signature",
4147 (PyCFunction)test_with_docstring, METH_NOARGS,
4148 docstring_with_signature},
Zachary Ware8ef887c2015-04-13 18:22:35 -05004149 {"docstring_with_signature_but_no_doc",
4150 (PyCFunction)test_with_docstring, METH_NOARGS,
4151 docstring_with_signature_but_no_doc},
Larry Hastings44e2eaa2013-11-23 15:37:55 -08004152 {"docstring_with_signature_and_extra_newlines",
4153 (PyCFunction)test_with_docstring, METH_NOARGS,
4154 docstring_with_signature_and_extra_newlines},
Larry Hastings16c51912014-01-07 11:53:01 -08004155 {"docstring_with_signature_with_defaults",
4156 (PyCFunction)test_with_docstring, METH_NOARGS,
4157 docstring_with_signature_with_defaults},
Victor Stinner56e8c292014-07-21 12:30:22 +02004158 {"raise_signal",
4159 (PyCFunction)test_raise_signal, METH_VARARGS},
Victor Stinner258e4d32013-12-13 02:30:12 +01004160#ifdef WITH_THREAD
Victor Stinnerfdeb6ec2013-12-13 02:01:38 +01004161 {"call_in_temporary_c_thread", call_in_temporary_c_thread, METH_O,
4162 PyDoc_STR("set_error_class(error_class) -> None")},
Victor Stinner258e4d32013-12-13 02:30:12 +01004163#endif
Serhiy Storchakab5181342015-02-06 08:58:56 +02004164 {"pymarshal_write_long_to_file",
4165 pymarshal_write_long_to_file, METH_VARARGS},
4166 {"pymarshal_write_object_to_file",
4167 pymarshal_write_object_to_file, METH_VARARGS},
4168 {"pymarshal_read_short_from_file",
4169 pymarshal_read_short_from_file, METH_VARARGS},
4170 {"pymarshal_read_long_from_file",
4171 pymarshal_read_long_from_file, METH_VARARGS},
4172 {"pymarshal_read_last_object_from_file",
4173 pymarshal_read_last_object_from_file, METH_VARARGS},
4174 {"pymarshal_read_object_from_file",
4175 pymarshal_read_object_from_file, METH_VARARGS},
Victor Stinnerefde1462015-03-21 15:04:43 +01004176 {"return_null_without_error",
4177 return_null_without_error, METH_NOARGS},
4178 {"return_result_with_error",
4179 return_result_with_error, METH_NOARGS},
Victor Stinner13019fd2015-04-03 13:10:54 +02004180 {"PyTime_FromSeconds", test_pytime_fromseconds, METH_VARARGS},
Victor Stinner4bfb4602015-03-27 22:27:24 +01004181 {"PyTime_FromSecondsObject", test_pytime_fromsecondsobject, METH_VARARGS},
4182 {"PyTime_AsSecondsDouble", test_pytime_assecondsdouble, METH_VARARGS},
Victor Stinner95e9cef2015-03-28 01:26:47 +01004183 {"PyTime_AsTimeval", test_PyTime_AsTimeval, METH_VARARGS},
Victor Stinner34dc0f42015-03-27 18:19:03 +01004184#ifdef HAVE_CLOCK_GETTIME
4185 {"PyTime_AsTimespec", test_PyTime_AsTimespec, METH_VARARGS},
4186#endif
Victor Stinner62d1c702015-04-01 17:47:07 +02004187 {"PyTime_AsMilliseconds", test_PyTime_AsMilliseconds, METH_VARARGS},
4188 {"PyTime_AsMicroseconds", test_PyTime_AsMicroseconds, METH_VARARGS},
Victor Stinner50856d52015-10-13 00:11:21 +02004189 {"get_recursion_depth", get_recursion_depth, METH_NOARGS},
Victor Stinner34be807c2016-03-14 12:04:26 +01004190 {"pymem_buffer_overflow", pymem_buffer_overflow, METH_NOARGS},
4191 {"pymem_api_misuse", pymem_api_misuse, METH_NOARGS},
Victor Stinnerad524372016-03-16 12:12:53 +01004192 {"pymem_malloc_without_gil", pymem_malloc_without_gil, METH_NOARGS},
Victor Stinnerc4aec362016-03-14 22:26:53 +01004193 {"pyobject_malloc_without_gil", pyobject_malloc_without_gil, METH_NOARGS},
Victor Stinner10b73e12016-03-22 13:39:05 +01004194 {"tracemalloc_track", tracemalloc_track, METH_VARARGS},
4195 {"tracemalloc_untrack", tracemalloc_untrack, METH_VARARGS},
4196 {"tracemalloc_get_traceback", tracemalloc_get_traceback, METH_VARARGS},
Victor Stinner3b6a6b42016-09-08 12:51:24 -07004197 {"dict_get_version", dict_get_version, METH_VARARGS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004198 {NULL, NULL} /* sentinel */
Tim Peters9ea17ac2001-02-02 05:57:15 +00004199};
4200
Thomas Hellera4ea6032003-04-17 18:55:45 +00004201#define AddSym(d, n, f, v) {PyObject *o = f(v); PyDict_SetItemString(d, n, o); Py_DECREF(o);}
4202
Thomas Wouters89f507f2006-12-13 04:49:30 +00004203typedef struct {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004204 char bool_member;
4205 char byte_member;
4206 unsigned char ubyte_member;
4207 short short_member;
4208 unsigned short ushort_member;
4209 int int_member;
4210 unsigned int uint_member;
4211 long long_member;
4212 unsigned long ulong_member;
4213 Py_ssize_t pyssizet_member;
4214 float float_member;
4215 double double_member;
4216 char inplace_member[6];
Benjamin Petersonaf580df2016-09-06 10:46:49 -07004217 long long longlong_member;
4218 unsigned long long ulonglong_member;
Thomas Wouters89f507f2006-12-13 04:49:30 +00004219} all_structmembers;
4220
4221typedef struct {
4222 PyObject_HEAD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004223 all_structmembers structmembers;
Thomas Wouters89f507f2006-12-13 04:49:30 +00004224} test_structmembers;
4225
4226static struct PyMemberDef test_members[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004227 {"T_BOOL", T_BOOL, offsetof(test_structmembers, structmembers.bool_member), 0, NULL},
4228 {"T_BYTE", T_BYTE, offsetof(test_structmembers, structmembers.byte_member), 0, NULL},
4229 {"T_UBYTE", T_UBYTE, offsetof(test_structmembers, structmembers.ubyte_member), 0, NULL},
4230 {"T_SHORT", T_SHORT, offsetof(test_structmembers, structmembers.short_member), 0, NULL},
4231 {"T_USHORT", T_USHORT, offsetof(test_structmembers, structmembers.ushort_member), 0, NULL},
4232 {"T_INT", T_INT, offsetof(test_structmembers, structmembers.int_member), 0, NULL},
4233 {"T_UINT", T_UINT, offsetof(test_structmembers, structmembers.uint_member), 0, NULL},
4234 {"T_LONG", T_LONG, offsetof(test_structmembers, structmembers.long_member), 0, NULL},
4235 {"T_ULONG", T_ULONG, offsetof(test_structmembers, structmembers.ulong_member), 0, NULL},
4236 {"T_PYSSIZET", T_PYSSIZET, offsetof(test_structmembers, structmembers.pyssizet_member), 0, NULL},
4237 {"T_FLOAT", T_FLOAT, offsetof(test_structmembers, structmembers.float_member), 0, NULL},
4238 {"T_DOUBLE", T_DOUBLE, offsetof(test_structmembers, structmembers.double_member), 0, NULL},
4239 {"T_STRING_INPLACE", T_STRING_INPLACE, offsetof(test_structmembers, structmembers.inplace_member), 0, NULL},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004240 {"T_LONGLONG", T_LONGLONG, offsetof(test_structmembers, structmembers.longlong_member), 0, NULL},
4241 {"T_ULONGLONG", T_ULONGLONG, offsetof(test_structmembers, structmembers.ulonglong_member), 0, NULL},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004242 {NULL}
Thomas Wouters89f507f2006-12-13 04:49:30 +00004243};
4244
4245
Christian Heimes1af737c2008-01-23 08:24:23 +00004246static PyObject *
4247test_structmembers_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4248{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004249 static char *keywords[] = {
4250 "T_BOOL", "T_BYTE", "T_UBYTE", "T_SHORT", "T_USHORT",
4251 "T_INT", "T_UINT", "T_LONG", "T_ULONG", "T_PYSSIZET",
4252 "T_FLOAT", "T_DOUBLE", "T_STRING_INPLACE",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004253 "T_LONGLONG", "T_ULONGLONG",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004254 NULL};
Benjamin Petersoned4aa832016-09-05 17:44:18 -07004255 static const char fmt[] = "|bbBhHiIlknfds#LK";
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004256 test_structmembers *ob;
4257 const char *s = NULL;
4258 Py_ssize_t string_len = 0;
4259 ob = PyObject_New(test_structmembers, type);
4260 if (ob == NULL)
4261 return NULL;
4262 memset(&ob->structmembers, 0, sizeof(all_structmembers));
4263 if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,
4264 &ob->structmembers.bool_member,
4265 &ob->structmembers.byte_member,
4266 &ob->structmembers.ubyte_member,
4267 &ob->structmembers.short_member,
4268 &ob->structmembers.ushort_member,
4269 &ob->structmembers.int_member,
4270 &ob->structmembers.uint_member,
4271 &ob->structmembers.long_member,
4272 &ob->structmembers.ulong_member,
4273 &ob->structmembers.pyssizet_member,
4274 &ob->structmembers.float_member,
4275 &ob->structmembers.double_member,
4276 &s, &string_len
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004277 , &ob->structmembers.longlong_member,
4278 &ob->structmembers.ulonglong_member
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004279 )) {
4280 Py_DECREF(ob);
4281 return NULL;
4282 }
4283 if (s != NULL) {
4284 if (string_len > 5) {
4285 Py_DECREF(ob);
4286 PyErr_SetString(PyExc_ValueError, "string too long");
4287 return NULL;
4288 }
4289 strcpy(ob->structmembers.inplace_member, s);
4290 }
4291 else {
4292 strcpy(ob->structmembers.inplace_member, "");
4293 }
4294 return (PyObject *)ob;
Thomas Wouters89f507f2006-12-13 04:49:30 +00004295}
4296
Christian Heimes1af737c2008-01-23 08:24:23 +00004297static void
4298test_structmembers_free(PyObject *ob)
4299{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004300 PyObject_FREE(ob);
Thomas Wouters89f507f2006-12-13 04:49:30 +00004301}
4302
4303static PyTypeObject test_structmembersType = {
Martin v. Löwis9f2e3462007-07-21 17:22:18 +00004304 PyVarObject_HEAD_INIT(NULL, 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004305 "test_structmembersType",
4306 sizeof(test_structmembers), /* tp_basicsize */
4307 0, /* tp_itemsize */
4308 test_structmembers_free, /* destructor tp_dealloc */
4309 0, /* tp_print */
4310 0, /* tp_getattr */
4311 0, /* tp_setattr */
4312 0, /* tp_reserved */
4313 0, /* tp_repr */
4314 0, /* tp_as_number */
4315 0, /* tp_as_sequence */
4316 0, /* tp_as_mapping */
4317 0, /* tp_hash */
4318 0, /* tp_call */
4319 0, /* tp_str */
4320 PyObject_GenericGetAttr, /* tp_getattro */
4321 PyObject_GenericSetAttr, /* tp_setattro */
4322 0, /* tp_as_buffer */
4323 0, /* tp_flags */
4324 "Type containing all structmember types",
4325 0, /* traverseproc tp_traverse */
4326 0, /* tp_clear */
4327 0, /* tp_richcompare */
4328 0, /* tp_weaklistoffset */
4329 0, /* tp_iter */
4330 0, /* tp_iternext */
4331 0, /* tp_methods */
4332 test_members, /* tp_members */
4333 0,
4334 0,
4335 0,
4336 0,
4337 0,
4338 0,
4339 0,
4340 0,
4341 test_structmembers_new, /* tp_new */
Thomas Wouters89f507f2006-12-13 04:49:30 +00004342};
4343
4344
Benjamin Petersond51374e2014-04-09 23:55:56 -04004345typedef struct {
4346 PyObject_HEAD
4347} matmulObject;
4348
4349static PyObject *
4350matmulType_matmul(PyObject *self, PyObject *other)
4351{
4352 return Py_BuildValue("(sOO)", "matmul", self, other);
4353}
4354
4355static PyObject *
4356matmulType_imatmul(PyObject *self, PyObject *other)
4357{
4358 return Py_BuildValue("(sOO)", "imatmul", self, other);
4359}
4360
4361static void
4362matmulType_dealloc(PyObject *self)
4363{
Zachary Ware420dc562014-04-23 13:51:27 -05004364 Py_TYPE(self)->tp_free(self);
Benjamin Petersond51374e2014-04-09 23:55:56 -04004365}
4366
4367static PyNumberMethods matmulType_as_number = {
4368 0, /* nb_add */
4369 0, /* nb_subtract */
4370 0, /* nb_multiply */
4371 0, /* nb_remainde r*/
4372 0, /* nb_divmod */
4373 0, /* nb_power */
4374 0, /* nb_negative */
4375 0, /* tp_positive */
4376 0, /* tp_absolute */
4377 0, /* tp_bool */
4378 0, /* nb_invert */
4379 0, /* nb_lshift */
4380 0, /* nb_rshift */
4381 0, /* nb_and */
4382 0, /* nb_xor */
4383 0, /* nb_or */
4384 0, /* nb_int */
4385 0, /* nb_reserved */
4386 0, /* nb_float */
4387 0, /* nb_inplace_add */
4388 0, /* nb_inplace_subtract */
4389 0, /* nb_inplace_multiply */
4390 0, /* nb_inplace_remainder */
4391 0, /* nb_inplace_power */
4392 0, /* nb_inplace_lshift */
4393 0, /* nb_inplace_rshift */
4394 0, /* nb_inplace_and */
4395 0, /* nb_inplace_xor */
4396 0, /* nb_inplace_or */
4397 0, /* nb_floor_divide */
4398 0, /* nb_true_divide */
4399 0, /* nb_inplace_floor_divide */
4400 0, /* nb_inplace_true_divide */
4401 0, /* nb_index */
4402 matmulType_matmul, /* nb_matrix_multiply */
4403 matmulType_imatmul /* nb_matrix_inplace_multiply */
4404};
4405
4406static PyTypeObject matmulType = {
4407 PyVarObject_HEAD_INIT(NULL, 0)
4408 "matmulType",
4409 sizeof(matmulObject), /* tp_basicsize */
4410 0, /* tp_itemsize */
4411 matmulType_dealloc, /* destructor tp_dealloc */
4412 0, /* tp_print */
4413 0, /* tp_getattr */
4414 0, /* tp_setattr */
4415 0, /* tp_reserved */
4416 0, /* tp_repr */
4417 &matmulType_as_number, /* tp_as_number */
4418 0, /* tp_as_sequence */
4419 0, /* tp_as_mapping */
4420 0, /* tp_hash */
4421 0, /* tp_call */
4422 0, /* tp_str */
4423 PyObject_GenericGetAttr, /* tp_getattro */
4424 PyObject_GenericSetAttr, /* tp_setattro */
4425 0, /* tp_as_buffer */
4426 0, /* tp_flags */
4427 "C level type with matrix operations defined",
4428 0, /* traverseproc tp_traverse */
4429 0, /* tp_clear */
4430 0, /* tp_richcompare */
4431 0, /* tp_weaklistoffset */
4432 0, /* tp_iter */
4433 0, /* tp_iternext */
4434 0, /* tp_methods */
4435 0, /* tp_members */
4436 0,
4437 0,
4438 0,
4439 0,
4440 0,
4441 0,
4442 0,
4443 0,
4444 PyType_GenericNew, /* tp_new */
4445 PyObject_Del, /* tp_free */
4446};
4447
Martin v. Löwis1a214512008-06-11 05:26:20 +00004448
Yury Selivanov75445082015-05-11 22:57:16 -04004449typedef struct {
4450 PyObject_HEAD
4451 PyObject *ao_iterator;
4452} awaitObject;
4453
4454
4455static PyObject *
4456awaitObject_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
4457{
4458 PyObject *v;
4459 awaitObject *ao;
4460
4461 if (!PyArg_UnpackTuple(args, "awaitObject", 1, 1, &v))
4462 return NULL;
4463
4464 ao = (awaitObject *)type->tp_alloc(type, 0);
4465 if (ao == NULL) {
4466 return NULL;
4467 }
4468
4469 Py_INCREF(v);
4470 ao->ao_iterator = v;
4471
4472 return (PyObject *)ao;
4473}
4474
4475
4476static void
4477awaitObject_dealloc(awaitObject *ao)
4478{
4479 Py_CLEAR(ao->ao_iterator);
4480 Py_TYPE(ao)->tp_free(ao);
4481}
4482
4483
4484static PyObject *
4485awaitObject_await(awaitObject *ao)
4486{
4487 Py_INCREF(ao->ao_iterator);
4488 return ao->ao_iterator;
4489}
4490
4491static PyAsyncMethods awaitType_as_async = {
Yury Selivanov6ef05902015-05-28 11:21:31 -04004492 (unaryfunc)awaitObject_await, /* am_await */
Yury Selivanov75445082015-05-11 22:57:16 -04004493 0, /* am_aiter */
4494 0 /* am_anext */
4495};
4496
4497
4498static PyTypeObject awaitType = {
4499 PyVarObject_HEAD_INIT(NULL, 0)
4500 "awaitType",
4501 sizeof(awaitObject), /* tp_basicsize */
4502 0, /* tp_itemsize */
4503 (destructor)awaitObject_dealloc, /* destructor tp_dealloc */
4504 0, /* tp_print */
4505 0, /* tp_getattr */
4506 0, /* tp_setattr */
4507 &awaitType_as_async, /* tp_as_async */
4508 0, /* tp_repr */
4509 0, /* tp_as_number */
4510 0, /* tp_as_sequence */
4511 0, /* tp_as_mapping */
4512 0, /* tp_hash */
4513 0, /* tp_call */
4514 0, /* tp_str */
4515 PyObject_GenericGetAttr, /* tp_getattro */
4516 PyObject_GenericSetAttr, /* tp_setattro */
4517 0, /* tp_as_buffer */
4518 0, /* tp_flags */
4519 "C level type with tp_as_async",
4520 0, /* traverseproc tp_traverse */
4521 0, /* tp_clear */
4522 0, /* tp_richcompare */
4523 0, /* tp_weaklistoffset */
4524 0, /* tp_iter */
4525 0, /* tp_iternext */
4526 0, /* tp_methods */
4527 0, /* tp_members */
4528 0,
4529 0,
4530 0,
4531 0,
4532 0,
4533 0,
4534 0,
4535 0,
4536 awaitObject_new, /* tp_new */
4537 PyObject_Del, /* tp_free */
4538};
4539
4540
Martin v. Löwis1a214512008-06-11 05:26:20 +00004541static struct PyModuleDef _testcapimodule = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004542 PyModuleDef_HEAD_INIT,
4543 "_testcapi",
4544 NULL,
4545 -1,
4546 TestMethods,
4547 NULL,
4548 NULL,
4549 NULL,
4550 NULL
Martin v. Löwis1a214512008-06-11 05:26:20 +00004551};
4552
Nick Coghland5cacbb2015-05-23 22:24:10 +10004553/* Per PEP 489, this module will not be converted to multi-phase initialization
4554 */
4555
Mark Hammond62b1ab12002-07-23 06:31:15 +00004556PyMODINIT_FUNC
Martin v. Löwis1a214512008-06-11 05:26:20 +00004557PyInit__testcapi(void)
Tim Peters9ea17ac2001-02-02 05:57:15 +00004558{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004559 PyObject *m;
Tim Peters9ea17ac2001-02-02 05:57:15 +00004560
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004561 m = PyModule_Create(&_testcapimodule);
4562 if (m == NULL)
4563 return NULL;
Tim Peters9ea17ac2001-02-02 05:57:15 +00004564
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004565 Py_TYPE(&_HashInheritanceTester_Type)=&PyType_Type;
Hirokazu Yamamoto8ebab5d2008-12-31 06:05:46 +00004566
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004567 Py_TYPE(&test_structmembersType)=&PyType_Type;
4568 Py_INCREF(&test_structmembersType);
4569 /* don't use a name starting with "test", since we don't want
4570 test_capi to automatically call this */
4571 PyModule_AddObject(m, "_test_structmembersType", (PyObject *)&test_structmembersType);
Benjamin Petersond51374e2014-04-09 23:55:56 -04004572 if (PyType_Ready(&matmulType) < 0)
4573 return NULL;
4574 Py_INCREF(&matmulType);
4575 PyModule_AddObject(m, "matmulType", (PyObject *)&matmulType);
Thomas Wouters89f507f2006-12-13 04:49:30 +00004576
Yury Selivanov75445082015-05-11 22:57:16 -04004577 if (PyType_Ready(&awaitType) < 0)
4578 return NULL;
4579 Py_INCREF(&awaitType);
4580 PyModule_AddObject(m, "awaitType", (PyObject *)&awaitType);
4581
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004582 PyModule_AddObject(m, "CHAR_MAX", PyLong_FromLong(CHAR_MAX));
4583 PyModule_AddObject(m, "CHAR_MIN", PyLong_FromLong(CHAR_MIN));
4584 PyModule_AddObject(m, "UCHAR_MAX", PyLong_FromLong(UCHAR_MAX));
4585 PyModule_AddObject(m, "SHRT_MAX", PyLong_FromLong(SHRT_MAX));
4586 PyModule_AddObject(m, "SHRT_MIN", PyLong_FromLong(SHRT_MIN));
4587 PyModule_AddObject(m, "USHRT_MAX", PyLong_FromLong(USHRT_MAX));
4588 PyModule_AddObject(m, "INT_MAX", PyLong_FromLong(INT_MAX));
4589 PyModule_AddObject(m, "INT_MIN", PyLong_FromLong(INT_MIN));
4590 PyModule_AddObject(m, "UINT_MAX", PyLong_FromUnsignedLong(UINT_MAX));
4591 PyModule_AddObject(m, "LONG_MAX", PyLong_FromLong(LONG_MAX));
4592 PyModule_AddObject(m, "LONG_MIN", PyLong_FromLong(LONG_MIN));
4593 PyModule_AddObject(m, "ULONG_MAX", PyLong_FromUnsignedLong(ULONG_MAX));
4594 PyModule_AddObject(m, "FLT_MAX", PyFloat_FromDouble(FLT_MAX));
4595 PyModule_AddObject(m, "FLT_MIN", PyFloat_FromDouble(FLT_MIN));
4596 PyModule_AddObject(m, "DBL_MAX", PyFloat_FromDouble(DBL_MAX));
4597 PyModule_AddObject(m, "DBL_MIN", PyFloat_FromDouble(DBL_MIN));
4598 PyModule_AddObject(m, "LLONG_MAX", PyLong_FromLongLong(PY_LLONG_MAX));
4599 PyModule_AddObject(m, "LLONG_MIN", PyLong_FromLongLong(PY_LLONG_MIN));
4600 PyModule_AddObject(m, "ULLONG_MAX", PyLong_FromUnsignedLongLong(PY_ULLONG_MAX));
4601 PyModule_AddObject(m, "PY_SSIZE_T_MAX", PyLong_FromSsize_t(PY_SSIZE_T_MAX));
4602 PyModule_AddObject(m, "PY_SSIZE_T_MIN", PyLong_FromSsize_t(PY_SSIZE_T_MIN));
4603 PyModule_AddObject(m, "SIZEOF_PYGC_HEAD", PyLong_FromSsize_t(sizeof(PyGC_Head)));
Victor Stinner4237d342015-09-10 10:10:39 +02004604 PyModule_AddObject(m, "SIZEOF_TIME_T", PyLong_FromSsize_t(sizeof(time_t)));
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004605 Py_INCREF(&PyInstanceMethod_Type);
4606 PyModule_AddObject(m, "instancemethod", (PyObject *)&PyInstanceMethod_Type);
Thomas Hellera4ea6032003-04-17 18:55:45 +00004607
Larry Hastings2a727912014-01-16 11:32:01 -08004608 PyModule_AddIntConstant(m, "the_number_three", 3);
4609
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004610 TestError = PyErr_NewException("_testcapi.error", NULL, NULL);
4611 Py_INCREF(TestError);
4612 PyModule_AddObject(m, "error", TestError);
4613 return m;
Tim Peters9ea17ac2001-02-02 05:57:15 +00004614}