1 /*
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
8 #define PY_SSIZE_T_CLEAN
9
10 #include "Python.h"
11 #include <float.h>
12 #include "structmember.h"
13 #include "datetime.h"
14 #include "marshal.h"
15 #include <signal.h>
16
17 #ifdef MS_WINDOWS
18 # include <winsock2.h> /* struct timeval */
19 #endif
20
21 #ifdef HAVE_SYS_WAIT_H
22 #include <sys/wait.h> /* For W_STOPCODE */
23 #endif
24
25 #include "pythread.h"
26 static PyObject *TestError; /* set to exception object in init */
27
28 /* Raise TestError with test_name + ": " + msg, and return NULL. */
29
30 static PyObject *
raiseTestError(const char * test_name,const char * msg)31 raiseTestError(const char* test_name, const char* msg)
32 {
33 PyErr_Format(TestError, "%s: %s", test_name, msg);
34 return NULL;
35 }
36
37 /* Test #defines from pyconfig.h (particularly the SIZEOF_* defines).
38
39 The ones derived from autoconf on the UNIX-like OSes can be relied
40 upon (in the absence of sloppy cross-compiling), but the Windows
41 platforms have these hardcoded. Better safe than sorry.
42 */
43 static PyObject*
sizeof_error(const char * fatname,const char * typname,int expected,int got)44 sizeof_error(const char* fatname, const char* typname,
45 int expected, int got)
46 {
47 PyErr_Format(TestError,
48 "%s #define == %d but sizeof(%s) == %d",
49 fatname, expected, typname, got);
50 return (PyObject*)NULL;
51 }
52
53 static PyObject*
test_config(PyObject * self)54 test_config(PyObject *self)
55 {
56 #define CHECK_SIZEOF(FATNAME, TYPE) \
57 if (FATNAME != sizeof(TYPE)) \
58 return sizeof_error(#FATNAME, #TYPE, FATNAME, sizeof(TYPE))
59
60 CHECK_SIZEOF(SIZEOF_SHORT, short);
61 CHECK_SIZEOF(SIZEOF_INT, int);
62 CHECK_SIZEOF(SIZEOF_LONG, long);
63 CHECK_SIZEOF(SIZEOF_VOID_P, void*);
64 CHECK_SIZEOF(SIZEOF_TIME_T, time_t);
65 CHECK_SIZEOF(SIZEOF_LONG_LONG, long long);
66
67 #undef CHECK_SIZEOF
68
69 Py_RETURN_NONE;
70 }
71
72 static PyObject*
test_sizeof_c_types(PyObject * self)73 test_sizeof_c_types(PyObject *self)
74 {
75 #if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))
76 #pragma GCC diagnostic push
77 #pragma GCC diagnostic ignored "-Wtype-limits"
78 #endif
79 #define CHECK_SIZEOF(TYPE, EXPECTED) \
80 if (EXPECTED != sizeof(TYPE)) { \
81 PyErr_Format(TestError, \
82 "sizeof(%s) = %u instead of %u", \
83 #TYPE, sizeof(TYPE), EXPECTED); \
84 return (PyObject*)NULL; \
85 }
86 #define IS_SIGNED(TYPE) (((TYPE)-1) < (TYPE)0)
87 #define CHECK_SIGNNESS(TYPE, SIGNED) \
88 if (IS_SIGNED(TYPE) != SIGNED) { \
89 PyErr_Format(TestError, \
90 "%s signness is, instead of %i", \
91 #TYPE, IS_SIGNED(TYPE), SIGNED); \
92 return (PyObject*)NULL; \
93 }
94
95 /* integer types */
96 CHECK_SIZEOF(Py_UCS1, 1);
97 CHECK_SIZEOF(Py_UCS2, 2);
98 CHECK_SIZEOF(Py_UCS4, 4);
99 CHECK_SIGNNESS(Py_UCS1, 0);
100 CHECK_SIGNNESS(Py_UCS2, 0);
101 CHECK_SIGNNESS(Py_UCS4, 0);
102 CHECK_SIZEOF(int32_t, 4);
103 CHECK_SIGNNESS(int32_t, 1);
104 CHECK_SIZEOF(uint32_t, 4);
105 CHECK_SIGNNESS(uint32_t, 0);
106 CHECK_SIZEOF(int64_t, 8);
107 CHECK_SIGNNESS(int64_t, 1);
108 CHECK_SIZEOF(uint64_t, 8);
109 CHECK_SIGNNESS(uint64_t, 0);
110
111 /* pointer/size types */
112 CHECK_SIZEOF(size_t, sizeof(void *));
113 CHECK_SIGNNESS(size_t, 0);
114 CHECK_SIZEOF(Py_ssize_t, sizeof(void *));
115 CHECK_SIGNNESS(Py_ssize_t, 1);
116
117 CHECK_SIZEOF(uintptr_t, sizeof(void *));
118 CHECK_SIGNNESS(uintptr_t, 0);
119 CHECK_SIZEOF(intptr_t, sizeof(void *));
120 CHECK_SIGNNESS(intptr_t, 1);
121
122 Py_RETURN_NONE;
123
124 #undef IS_SIGNED
125 #undef CHECK_SIGNESS
126 #undef CHECK_SIZEOF
127 #if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))
128 #pragma GCC diagnostic pop
129 #endif
130 }
131
132
133 static PyObject*
test_list_api(PyObject * self)134 test_list_api(PyObject *self)
135 {
136 PyObject* list;
137 int i;
138
139 /* SF bug 132008: PyList_Reverse segfaults */
140 #define NLIST 30
141 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);
170 #undef NLIST
171
172 Py_RETURN_NONE;
173 }
174
175 static int
test_dict_inner(int count)176 test_dict_inner(int count)
177 {
178 Py_ssize_t pos = 0, iterations = 0;
179 int i;
180 PyObject *dict = PyDict_New();
181 PyObject *v, *k;
182
183 if (dict == NULL)
184 return -1;
185
186 for (i = 0; i < count; i++) {
187 v = PyLong_FromLong(i);
188 if (v == NULL) {
189 return -1;
190 }
191 if (PyDict_SetItem(dict, v, v) < 0) {
192 Py_DECREF(v);
193 return -1;
194 }
195 Py_DECREF(v);
196 }
197
198 while (PyDict_Next(dict, &pos, &k, &v)) {
199 PyObject *o;
200 iterations++;
201
202 i = PyLong_AS_LONG(v) + 1;
203 o = PyLong_FromLong(i);
204 if (o == NULL)
205 return -1;
206 if (PyDict_SetItem(dict, k, o) < 0) {
207 Py_DECREF(o);
208 return -1;
209 }
210 Py_DECREF(o);
211 }
212
213 Py_DECREF(dict);
214
215 if (iterations != count) {
216 PyErr_SetString(
217 TestError,
218 "test_dict_iteration: dict iteration went wrong ");
219 return -1;
220 } else {
221 return 0;
222 }
223 }
224
225 static PyObject*
test_dict_iteration(PyObject * self)226 test_dict_iteration(PyObject* self)
227 {
228 int i;
229
230 for (i = 0; i < 200; i++) {
231 if (test_dict_inner(i) < 0) {
232 return NULL;
233 }
234 }
235
236 Py_RETURN_NONE;
237 }
238
239 static PyObject*
dict_getitem_knownhash(PyObject * self,PyObject * args)240 dict_getitem_knownhash(PyObject *self, PyObject *args)
241 {
242 PyObject *mp, *key, *result;
243 Py_ssize_t hash;
244
245 if (!PyArg_ParseTuple(args, "OOn:dict_getitem_knownhash",
246 &mp, &key, &hash)) {
247 return NULL;
248 }
249
250 result = _PyDict_GetItem_KnownHash(mp, key, (Py_hash_t)hash);
251 if (result == NULL && !PyErr_Occurred()) {
252 _PyErr_SetKeyError(key);
253 return NULL;
254 }
255
256 Py_XINCREF(result);
257 return result;
258 }
259
260 static PyObject*
dict_hassplittable(PyObject * self,PyObject * arg)261 dict_hassplittable(PyObject *self, PyObject *arg)
262 {
263 if (!PyDict_Check(arg)) {
264 PyErr_Format(PyExc_TypeError,
265 "dict_hassplittable() argument must be dict, not '%s'",
266 arg->ob_type->tp_name);
267 return NULL;
268 }
269
270 return PyBool_FromLong(_PyDict_HasSplitTable((PyDictObject*)arg));
271 }
272
273 /* Issue #4701: Check that PyObject_Hash implicitly calls
274 * PyType_Ready if it hasn't already been called
275 */
276 static PyTypeObject _HashInheritanceTester_Type = {
277 PyVarObject_HEAD_INIT(NULL, 0)
278 "hashinheritancetester", /* Name of this type */
279 sizeof(PyObject), /* Basic object size */
280 0, /* Item size for varobject */
281 (destructor)PyObject_Del, /* tp_dealloc */
282 0, /* tp_print */
283 0, /* tp_getattr */
284 0, /* tp_setattr */
285 0, /* tp_reserved */
286 0, /* tp_repr */
287 0, /* tp_as_number */
288 0, /* tp_as_sequence */
289 0, /* tp_as_mapping */
290 0, /* tp_hash */
291 0, /* tp_call */
292 0, /* tp_str */
293 PyObject_GenericGetAttr, /* tp_getattro */
294 0, /* tp_setattro */
295 0, /* tp_as_buffer */
296 Py_TPFLAGS_DEFAULT, /* tp_flags */
297 0, /* tp_doc */
298 0, /* tp_traverse */
299 0, /* tp_clear */
300 0, /* tp_richcompare */
301 0, /* tp_weaklistoffset */
302 0, /* tp_iter */
303 0, /* tp_iternext */
304 0, /* tp_methods */
305 0, /* tp_members */
306 0, /* tp_getset */
307 0, /* tp_base */
308 0, /* tp_dict */
309 0, /* tp_descr_get */
310 0, /* tp_descr_set */
311 0, /* tp_dictoffset */
312 0, /* tp_init */
313 0, /* tp_alloc */
314 PyType_GenericNew, /* tp_new */
315 };
316
317 static PyObject*
test_lazy_hash_inheritance(PyObject * self)318 test_lazy_hash_inheritance(PyObject* self)
319 {
320 PyTypeObject *type;
321 PyObject *obj;
322 Py_hash_t hash;
323
324 type = &_HashInheritanceTester_Type;
325
326 if (type->tp_dict != NULL)
327 /* The type has already been initialized. This probably means
328 -R is being used. */
329 Py_RETURN_NONE;
330
331
332 obj = PyObject_New(PyObject, type);
333 if (obj == NULL) {
334 PyErr_Clear();
335 PyErr_SetString(
336 TestError,
337 "test_lazy_hash_inheritance: failed to create object");
338 return NULL;
339 }
340
341 if (type->tp_dict != NULL) {
342 PyErr_SetString(
343 TestError,
344 "test_lazy_hash_inheritance: type initialised too soon");
345 Py_DECREF(obj);
346 return NULL;
347 }
348
349 hash = PyObject_Hash(obj);
350 if ((hash == -1) && PyErr_Occurred()) {
351 PyErr_Clear();
352 PyErr_SetString(
353 TestError,
354 "test_lazy_hash_inheritance: could not hash object");
355 Py_DECREF(obj);
356 return NULL;
357 }
358
359 if (type->tp_dict == NULL) {
360 PyErr_SetString(
361 TestError,
362 "test_lazy_hash_inheritance: type not initialised by hash()");
363 Py_DECREF(obj);
364 return NULL;
365 }
366
367 if (type->tp_hash != PyType_Type.tp_hash) {
368 PyErr_SetString(
369 TestError,
370 "test_lazy_hash_inheritance: unexpected hash function");
371 Py_DECREF(obj);
372 return NULL;
373 }
374
375 Py_DECREF(obj);
376
377 Py_RETURN_NONE;
378 }
379
380
381 /* Tests of PyLong_{As, From}{Unsigned,}Long(), and
382 PyLong_{As, From}{Unsigned,}LongLong().
383
384 Note that the meat of the test is contained in testcapi_long.h.
385 This is revolting, but delicate code duplication is worse: "almost
386 exactly the same" code is needed to test long long, but the ubiquitous
387 dependence on type names makes it impossible to use a parameterized
388 function. A giant macro would be even worse than this. A C++ template
389 would be perfect.
390
391 The "report an error" functions are deliberately not part of the #include
392 file: if the test fails, you can set a breakpoint in the appropriate
393 error function directly, and crawl back from there in the debugger.
394 */
395
396 #define UNBIND(X) Py_DECREF(X); (X) = NULL
397
398 static PyObject *
raise_test_long_error(const char * msg)399 raise_test_long_error(const char* msg)
400 {
401 return raiseTestError("test_long_api", msg);
402 }
403
404 #define TESTNAME test_long_api_inner
405 #define TYPENAME long
406 #define F_S_TO_PY PyLong_FromLong
407 #define F_PY_TO_S PyLong_AsLong
408 #define F_U_TO_PY PyLong_FromUnsignedLong
409 #define F_PY_TO_U PyLong_AsUnsignedLong
410
411 #include "testcapi_long.h"
412
413 static PyObject *
test_long_api(PyObject * self)414 test_long_api(PyObject* self)
415 {
416 return TESTNAME(raise_test_long_error);
417 }
418
419 #undef TESTNAME
420 #undef TYPENAME
421 #undef F_S_TO_PY
422 #undef F_PY_TO_S
423 #undef F_U_TO_PY
424 #undef F_PY_TO_U
425
426 static PyObject *
raise_test_longlong_error(const char * msg)427 raise_test_longlong_error(const char* msg)
428 {
429 return raiseTestError("test_longlong_api", msg);
430 }
431
432 #define TESTNAME test_longlong_api_inner
433 #define TYPENAME long long
434 #define F_S_TO_PY PyLong_FromLongLong
435 #define F_PY_TO_S PyLong_AsLongLong
436 #define F_U_TO_PY PyLong_FromUnsignedLongLong
437 #define F_PY_TO_U PyLong_AsUnsignedLongLong
438
439 #include "testcapi_long.h"
440
441 static PyObject *
test_longlong_api(PyObject * self,PyObject * args)442 test_longlong_api(PyObject* self, PyObject *args)
443 {
444 return TESTNAME(raise_test_longlong_error);
445 }
446
447 #undef TESTNAME
448 #undef TYPENAME
449 #undef F_S_TO_PY
450 #undef F_PY_TO_S
451 #undef F_U_TO_PY
452 #undef F_PY_TO_U
453
454 /* Test the PyLong_AsLongAndOverflow API. General conversion to PY_LONG
455 is tested by test_long_api_inner. This test will concentrate on proper
456 handling of overflow.
457 */
458
459 static PyObject *
test_long_and_overflow(PyObject * self)460 test_long_and_overflow(PyObject *self)
461 {
462 PyObject *num, *one, *temp;
463 long value;
464 int overflow;
465
466 /* Test that overflow is set properly for a large value. */
467 /* num is a number larger than LONG_MAX even on 64-bit platforms */
468 num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
469 if (num == NULL)
470 return NULL;
471 overflow = 1234;
472 value = PyLong_AsLongAndOverflow(num, &overflow);
473 Py_DECREF(num);
474 if (value == -1 && PyErr_Occurred())
475 return NULL;
476 if (value != -1)
477 return raiseTestError("test_long_and_overflow",
478 "return value was not set to -1");
479 if (overflow != 1)
480 return raiseTestError("test_long_and_overflow",
481 "overflow was not set to 1");
482
483 /* Same again, with num = LONG_MAX + 1 */
484 num = PyLong_FromLong(LONG_MAX);
485 if (num == NULL)
486 return NULL;
487 one = PyLong_FromLong(1L);
488 if (one == NULL) {
489 Py_DECREF(num);
490 return NULL;
491 }
492 temp = PyNumber_Add(num, one);
493 Py_DECREF(one);
494 Py_DECREF(num);
495 num = temp;
496 if (num == NULL)
497 return NULL;
498 overflow = 0;
499 value = PyLong_AsLongAndOverflow(num, &overflow);
500 Py_DECREF(num);
501 if (value == -1 && PyErr_Occurred())
502 return NULL;
503 if (value != -1)
504 return raiseTestError("test_long_and_overflow",
505 "return value was not set to -1");
506 if (overflow != 1)
507 return raiseTestError("test_long_and_overflow",
508 "overflow was not set to 1");
509
510 /* Test that overflow is set properly for a large negative value. */
511 /* num is a number smaller than LONG_MIN even on 64-bit platforms */
512 num = PyLong_FromString("-FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
513 if (num == NULL)
514 return NULL;
515 overflow = 1234;
516 value = PyLong_AsLongAndOverflow(num, &overflow);
517 Py_DECREF(num);
518 if (value == -1 && PyErr_Occurred())
519 return NULL;
520 if (value != -1)
521 return raiseTestError("test_long_and_overflow",
522 "return value was not set to -1");
523 if (overflow != -1)
524 return raiseTestError("test_long_and_overflow",
525 "overflow was not set to -1");
526
527 /* Same again, with num = LONG_MIN - 1 */
528 num = PyLong_FromLong(LONG_MIN);
529 if (num == NULL)
530 return NULL;
531 one = PyLong_FromLong(1L);
532 if (one == NULL) {
533 Py_DECREF(num);
534 return NULL;
535 }
536 temp = PyNumber_Subtract(num, one);
537 Py_DECREF(one);
538 Py_DECREF(num);
539 num = temp;
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 != -1)
548 return raiseTestError("test_long_and_overflow",
549 "return value was not set to -1");
550 if (overflow != -1)
551 return raiseTestError("test_long_and_overflow",
552 "overflow was not set to -1");
553
554 /* Test that overflow is cleared properly for small values. */
555 num = PyLong_FromString("FF", NULL, 16);
556 if (num == NULL)
557 return NULL;
558 overflow = 1234;
559 value = PyLong_AsLongAndOverflow(num, &overflow);
560 Py_DECREF(num);
561 if (value == -1 && PyErr_Occurred())
562 return NULL;
563 if (value != 0xFF)
564 return raiseTestError("test_long_and_overflow",
565 "expected return value 0xFF");
566 if (overflow != 0)
567 return raiseTestError("test_long_and_overflow",
568 "overflow was not cleared");
569
570 num = PyLong_FromString("-FF", NULL, 16);
571 if (num == NULL)
572 return NULL;
573 overflow = 0;
574 value = PyLong_AsLongAndOverflow(num, &overflow);
575 Py_DECREF(num);
576 if (value == -1 && PyErr_Occurred())
577 return NULL;
578 if (value != -0xFF)
579 return raiseTestError("test_long_and_overflow",
580 "expected return value 0xFF");
581 if (overflow != 0)
582 return raiseTestError("test_long_and_overflow",
583 "overflow was set incorrectly");
584
585 num = PyLong_FromLong(LONG_MAX);
586 if (num == NULL)
587 return NULL;
588 overflow = 1234;
589 value = PyLong_AsLongAndOverflow(num, &overflow);
590 Py_DECREF(num);
591 if (value == -1 && PyErr_Occurred())
592 return NULL;
593 if (value != LONG_MAX)
594 return raiseTestError("test_long_and_overflow",
595 "expected return value LONG_MAX");
596 if (overflow != 0)
597 return raiseTestError("test_long_and_overflow",
598 "overflow was not cleared");
599
600 num = PyLong_FromLong(LONG_MIN);
601 if (num == NULL)
602 return NULL;
603 overflow = 0;
604 value = PyLong_AsLongAndOverflow(num, &overflow);
605 Py_DECREF(num);
606 if (value == -1 && PyErr_Occurred())
607 return NULL;
608 if (value != LONG_MIN)
609 return raiseTestError("test_long_and_overflow",
610 "expected return value LONG_MIN");
611 if (overflow != 0)
612 return raiseTestError("test_long_and_overflow",
613 "overflow was not cleared");
614
615 Py_RETURN_NONE;
616 }
617
618 /* Test the PyLong_AsLongLongAndOverflow API. General conversion to
619 long long is tested by test_long_api_inner. This test will
620 concentrate on proper handling of overflow.
621 */
622
623 static PyObject *
test_long_long_and_overflow(PyObject * self)624 test_long_long_and_overflow(PyObject *self)
625 {
626 PyObject *num, *one, *temp;
627 long long value;
628 int overflow;
629
630 /* Test that overflow is set properly for a large value. */
631 /* num is a number larger than PY_LLONG_MAX on a typical machine. */
632 num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
633 if (num == NULL)
634 return NULL;
635 overflow = 1234;
636 value = PyLong_AsLongLongAndOverflow(num, &overflow);
637 Py_DECREF(num);
638 if (value == -1 && PyErr_Occurred())
639 return NULL;
640 if (value != -1)
641 return raiseTestError("test_long_long_and_overflow",
642 "return value was not set to -1");
643 if (overflow != 1)
644 return raiseTestError("test_long_long_and_overflow",
645 "overflow was not set to 1");
646
647 /* Same again, with num = PY_LLONG_MAX + 1 */
648 num = PyLong_FromLongLong(PY_LLONG_MAX);
649 if (num == NULL)
650 return NULL;
651 one = PyLong_FromLong(1L);
652 if (one == NULL) {
653 Py_DECREF(num);
654 return NULL;
655 }
656 temp = PyNumber_Add(num, one);
657 Py_DECREF(one);
658 Py_DECREF(num);
659 num = temp;
660 if (num == NULL)
661 return NULL;
662 overflow = 0;
663 value = PyLong_AsLongLongAndOverflow(num, &overflow);
664 Py_DECREF(num);
665 if (value == -1 && PyErr_Occurred())
666 return NULL;
667 if (value != -1)
668 return raiseTestError("test_long_long_and_overflow",
669 "return value was not set to -1");
670 if (overflow != 1)
671 return raiseTestError("test_long_long_and_overflow",
672 "overflow was not set to 1");
673
674 /* Test that overflow is set properly for a large negative value. */
675 /* num is a number smaller than PY_LLONG_MIN on a typical platform */
676 num = PyLong_FromString("-FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
677 if (num == NULL)
678 return NULL;
679 overflow = 1234;
680 value = PyLong_AsLongLongAndOverflow(num, &overflow);
681 Py_DECREF(num);
682 if (value == -1 && PyErr_Occurred())
683 return NULL;
684 if (value != -1)
685 return raiseTestError("test_long_long_and_overflow",
686 "return value was not set to -1");
687 if (overflow != -1)
688 return raiseTestError("test_long_long_and_overflow",
689 "overflow was not set to -1");
690
691 /* Same again, with num = PY_LLONG_MIN - 1 */
692 num = PyLong_FromLongLong(PY_LLONG_MIN);
693 if (num == NULL)
694 return NULL;
695 one = PyLong_FromLong(1L);
696 if (one == NULL) {
697 Py_DECREF(num);
698 return NULL;
699 }
700 temp = PyNumber_Subtract(num, one);
701 Py_DECREF(one);
702 Py_DECREF(num);
703 num = temp;
704 if (num == NULL)
705 return NULL;
706 overflow = 0;
707 value = PyLong_AsLongLongAndOverflow(num, &overflow);
708 Py_DECREF(num);
709 if (value == -1 && PyErr_Occurred())
710 return NULL;
711 if (value != -1)
712 return raiseTestError("test_long_long_and_overflow",
713 "return value was not set to -1");
714 if (overflow != -1)
715 return raiseTestError("test_long_long_and_overflow",
716 "overflow was not set to -1");
717
718 /* Test that overflow is cleared properly for small values. */
719 num = PyLong_FromString("FF", NULL, 16);
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 != 0xFF)
728 return raiseTestError("test_long_long_and_overflow",
729 "expected return value 0xFF");
730 if (overflow != 0)
731 return raiseTestError("test_long_long_and_overflow",
732 "overflow was not cleared");
733
734 num = PyLong_FromString("-FF", NULL, 16);
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 != -0xFF)
743 return raiseTestError("test_long_long_and_overflow",
744 "expected return value 0xFF");
745 if (overflow != 0)
746 return raiseTestError("test_long_long_and_overflow",
747 "overflow was set incorrectly");
748
749 num = PyLong_FromLongLong(PY_LLONG_MAX);
750 if (num == NULL)
751 return NULL;
752 overflow = 1234;
753 value = PyLong_AsLongLongAndOverflow(num, &overflow);
754 Py_DECREF(num);
755 if (value == -1 && PyErr_Occurred())
756 return NULL;
757 if (value != PY_LLONG_MAX)
758 return raiseTestError("test_long_long_and_overflow",
759 "expected return value PY_LLONG_MAX");
760 if (overflow != 0)
761 return raiseTestError("test_long_long_and_overflow",
762 "overflow was not cleared");
763
764 num = PyLong_FromLongLong(PY_LLONG_MIN);
765 if (num == NULL)
766 return NULL;
767 overflow = 0;
768 value = PyLong_AsLongLongAndOverflow(num, &overflow);
769 Py_DECREF(num);
770 if (value == -1 && PyErr_Occurred())
771 return NULL;
772 if (value != PY_LLONG_MIN)
773 return raiseTestError("test_long_long_and_overflow",
774 "expected return value PY_LLONG_MIN");
775 if (overflow != 0)
776 return raiseTestError("test_long_long_and_overflow",
777 "overflow was not cleared");
778
779 Py_RETURN_NONE;
780 }
781
782 /* Test the PyLong_As{Size,Ssize}_t API. At present this just tests that
783 non-integer arguments are handled correctly. It should be extended to
784 test overflow handling.
785 */
786
787 static PyObject *
test_long_as_size_t(PyObject * self)788 test_long_as_size_t(PyObject *self)
789 {
790 size_t out_u;
791 Py_ssize_t out_s;
792
793 Py_INCREF(Py_None);
794
795 out_u = PyLong_AsSize_t(Py_None);
796 if (out_u != (size_t)-1 || !PyErr_Occurred())
797 return raiseTestError("test_long_as_size_t",
798 "PyLong_AsSize_t(None) didn't complain");
799 if (!PyErr_ExceptionMatches(PyExc_TypeError))
800 return raiseTestError("test_long_as_size_t",
801 "PyLong_AsSize_t(None) raised "
802 "something other than TypeError");
803 PyErr_Clear();
804
805 out_s = PyLong_AsSsize_t(Py_None);
806 if (out_s != (Py_ssize_t)-1 || !PyErr_Occurred())
807 return raiseTestError("test_long_as_size_t",
808 "PyLong_AsSsize_t(None) didn't complain");
809 if (!PyErr_ExceptionMatches(PyExc_TypeError))
810 return raiseTestError("test_long_as_size_t",
811 "PyLong_AsSsize_t(None) raised "
812 "something other than TypeError");
813 PyErr_Clear();
814
815 /* Py_INCREF(Py_None) omitted - we already have a reference to it. */
816 return Py_None;
817 }
818
819 /* Test the PyLong_AsDouble API. At present this just tests that
820 non-integer arguments are handled correctly.
821 */
822
823 static PyObject *
test_long_as_double(PyObject * self)824 test_long_as_double(PyObject *self)
825 {
826 double out;
827
828 Py_INCREF(Py_None);
829
830 out = PyLong_AsDouble(Py_None);
831 if (out != -1.0 || !PyErr_Occurred())
832 return raiseTestError("test_long_as_double",
833 "PyLong_AsDouble(None) didn't complain");
834 if (!PyErr_ExceptionMatches(PyExc_TypeError))
835 return raiseTestError("test_long_as_double",
836 "PyLong_AsDouble(None) raised "
837 "something other than TypeError");
838 PyErr_Clear();
839
840 /* Py_INCREF(Py_None) omitted - we already have a reference to it. */
841 return Py_None;
842 }
843
844 /* Test the L code for PyArg_ParseTuple. This should deliver a long long
845 for both long and int arguments. The test may leak a little memory if
846 it fails.
847 */
848 static PyObject *
test_L_code(PyObject * self)849 test_L_code(PyObject *self)
850 {
851 PyObject *tuple, *num;
852 long long value;
853
854 tuple = PyTuple_New(1);
855 if (tuple == NULL)
856 return NULL;
857
858 num = PyLong_FromLong(42);
859 if (num == NULL)
860 return NULL;
861
862 PyTuple_SET_ITEM(tuple, 0, num);
863
864 value = -1;
865 if (!PyArg_ParseTuple(tuple, "L:test_L_code", &value)) {
866 return NULL;
867 }
868 if (value != 42)
869 return raiseTestError("test_L_code",
870 "L code returned wrong value for long 42");
871
872 Py_DECREF(num);
873 num = PyLong_FromLong(42);
874 if (num == NULL)
875 return NULL;
876
877 PyTuple_SET_ITEM(tuple, 0, num);
878
879 value = -1;
880 if (!PyArg_ParseTuple(tuple, "L:test_L_code", &value)) {
881 return NULL;
882 }
883 if (value != 42)
884 return raiseTestError("test_L_code",
885 "L code returned wrong value for int 42");
886
887 Py_DECREF(tuple);
888 Py_RETURN_NONE;
889 }
890
891 static PyObject *
return_none(void * unused)892 return_none(void *unused)
893 {
894 Py_RETURN_NONE;
895 }
896
897 static PyObject *
raise_error(void * unused)898 raise_error(void *unused)
899 {
900 PyErr_SetNone(PyExc_ValueError);
901 return NULL;
902 }
903
904 static int
test_buildvalue_N_error(const char * fmt)905 test_buildvalue_N_error(const char *fmt)
906 {
907 PyObject *arg, *res;
908
909 arg = PyList_New(0);
910 if (arg == NULL) {
911 return -1;
912 }
913
914 Py_INCREF(arg);
915 res = Py_BuildValue(fmt, return_none, NULL, arg);
916 if (res == NULL) {
917 return -1;
918 }
919 Py_DECREF(res);
920 if (Py_REFCNT(arg) != 1) {
921 PyErr_Format(TestError, "test_buildvalue_N: "
922 "arg was not decrefed in successful "
923 "Py_BuildValue(\"%s\")", fmt);
924 return -1;
925 }
926
927 Py_INCREF(arg);
928 res = Py_BuildValue(fmt, raise_error, NULL, arg);
929 if (res != NULL || !PyErr_Occurred()) {
930 PyErr_Format(TestError, "test_buildvalue_N: "
931 "Py_BuildValue(\"%s\") didn't complain", fmt);
932 return -1;
933 }
934 PyErr_Clear();
935 if (Py_REFCNT(arg) != 1) {
936 PyErr_Format(TestError, "test_buildvalue_N: "
937 "arg was not decrefed in failed "
938 "Py_BuildValue(\"%s\")", fmt);
939 return -1;
940 }
941 Py_DECREF(arg);
942 return 0;
943 }
944
945 static PyObject *
test_buildvalue_N(PyObject * self,PyObject * Py_UNUSED (ignored))946 test_buildvalue_N(PyObject *self, PyObject *Py_UNUSED(ignored))
947 {
948 PyObject *arg, *res;
949
950 arg = PyList_New(0);
951 if (arg == NULL) {
952 return NULL;
953 }
954 Py_INCREF(arg);
955 res = Py_BuildValue("N", arg);
956 if (res == NULL) {
957 return NULL;
958 }
959 if (res != arg) {
960 return raiseTestError("test_buildvalue_N",
961 "Py_BuildValue(\"N\") returned wrong result");
962 }
963 if (Py_REFCNT(arg) != 2) {
964 return raiseTestError("test_buildvalue_N",
965 "arg was not decrefed in Py_BuildValue(\"N\")");
966 }
967 Py_DECREF(res);
968 Py_DECREF(arg);
969
970 if (test_buildvalue_N_error("O&N") < 0)
971 return NULL;
972 if (test_buildvalue_N_error("(O&N)") < 0)
973 return NULL;
974 if (test_buildvalue_N_error("[O&N]") < 0)
975 return NULL;
976 if (test_buildvalue_N_error("{O&N}") < 0)
977 return NULL;
978 if (test_buildvalue_N_error("{()O&(())N}") < 0)
979 return NULL;
980
981 Py_RETURN_NONE;
982 }
983
984
985 static PyObject *
get_args(PyObject * self,PyObject * args)986 get_args(PyObject *self, PyObject *args)
987 {
988 if (args == NULL) {
989 args = Py_None;
990 }
991 Py_INCREF(args);
992 return args;
993 }
994
995 static PyObject *
get_kwargs(PyObject * self,PyObject * args,PyObject * kwargs)996 get_kwargs(PyObject *self, PyObject *args, PyObject *kwargs)
997 {
998 if (kwargs == NULL) {
999 kwargs = Py_None;
1000 }
1001 Py_INCREF(kwargs);
1002 return kwargs;
1003 }
1004
1005 /* Test tuple argument processing */
1006 static PyObject *
getargs_tuple(PyObject * self,PyObject * args)1007 getargs_tuple(PyObject *self, PyObject *args)
1008 {
1009 int a, b, c;
1010 if (!PyArg_ParseTuple(args, "i(ii)", &a, &b, &c))
1011 return NULL;
1012 return Py_BuildValue("iii", a, b, c);
1013 }
1014
1015 /* test PyArg_ParseTupleAndKeywords */
1016 static PyObject *
getargs_keywords(PyObject * self,PyObject * args,PyObject * kwargs)1017 getargs_keywords(PyObject *self, PyObject *args, PyObject *kwargs)
1018 {
1019 static char *keywords[] = {"arg1","arg2","arg3","arg4","arg5", NULL};
1020 static const char fmt[] = "(ii)i|(i(ii))(iii)i";
1021 int int_args[10]={-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
1022
1023 if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,
1024 &int_args[0], &int_args[1], &int_args[2], &int_args[3], &int_args[4],
1025 &int_args[5], &int_args[6], &int_args[7], &int_args[8], &int_args[9]))
1026 return NULL;
1027 return Py_BuildValue("iiiiiiiiii",
1028 int_args[0], int_args[1], int_args[2], int_args[3], int_args[4],
1029 int_args[5], int_args[6], int_args[7], int_args[8], int_args[9]);
1030 }
1031
1032 /* test PyArg_ParseTupleAndKeywords keyword-only arguments */
1033 static PyObject *
getargs_keyword_only(PyObject * self,PyObject * args,PyObject * kwargs)1034 getargs_keyword_only(PyObject *self, PyObject *args, PyObject *kwargs)
1035 {
1036 static char *keywords[] = {"required", "optional", "keyword_only", NULL};
1037 int required = -1;
1038 int optional = -1;
1039 int keyword_only = -1;
1040
1041 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|i$i", keywords,
1042 &required, &optional, &keyword_only))
1043 return NULL;
1044 return Py_BuildValue("iii", required, optional, keyword_only);
1045 }
1046
1047 /* test PyArg_ParseTupleAndKeywords positional-only arguments */
1048 static PyObject *
getargs_positional_only_and_keywords(PyObject * self,PyObject * args,PyObject * kwargs)1049 getargs_positional_only_and_keywords(PyObject *self, PyObject *args, PyObject *kwargs)
1050 {
1051 static char *keywords[] = {"", "", "keyword", NULL};
1052 int required = -1;
1053 int optional = -1;
1054 int keyword = -1;
1055
1056 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|ii", keywords,
1057 &required, &optional, &keyword))
1058 return NULL;
1059 return Py_BuildValue("iii", required, optional, keyword);
1060 }
1061
1062 /* Functions to call PyArg_ParseTuple with integer format codes,
1063 and return the result.
1064 */
1065 static PyObject *
getargs_b(PyObject * self,PyObject * args)1066 getargs_b(PyObject *self, PyObject *args)
1067 {
1068 unsigned char value;
1069 if (!PyArg_ParseTuple(args, "b", &value))
1070 return NULL;
1071 return PyLong_FromUnsignedLong((unsigned long)value);
1072 }
1073
1074 static PyObject *
getargs_B(PyObject * self,PyObject * args)1075 getargs_B(PyObject *self, PyObject *args)
1076 {
1077 unsigned char value;
1078 if (!PyArg_ParseTuple(args, "B", &value))
1079 return NULL;
1080 return PyLong_FromUnsignedLong((unsigned long)value);
1081 }
1082
1083 static PyObject *
getargs_h(PyObject * self,PyObject * args)1084 getargs_h(PyObject *self, PyObject *args)
1085 {
1086 short value;
1087 if (!PyArg_ParseTuple(args, "h", &value))
1088 return NULL;
1089 return PyLong_FromLong((long)value);
1090 }
1091
1092 static PyObject *
getargs_H(PyObject * self,PyObject * args)1093 getargs_H(PyObject *self, PyObject *args)
1094 {
1095 unsigned short value;
1096 if (!PyArg_ParseTuple(args, "H", &value))
1097 return NULL;
1098 return PyLong_FromUnsignedLong((unsigned long)value);
1099 }
1100
1101 static PyObject *
getargs_I(PyObject * self,PyObject * args)1102 getargs_I(PyObject *self, PyObject *args)
1103 {
1104 unsigned int value;
1105 if (!PyArg_ParseTuple(args, "I", &value))
1106 return NULL;
1107 return PyLong_FromUnsignedLong((unsigned long)value);
1108 }
1109
1110 static PyObject *
getargs_k(PyObject * self,PyObject * args)1111 getargs_k(PyObject *self, PyObject *args)
1112 {
1113 unsigned long value;
1114 if (!PyArg_ParseTuple(args, "k", &value))
1115 return NULL;
1116 return PyLong_FromUnsignedLong(value);
1117 }
1118
1119 static PyObject *
getargs_i(PyObject * self,PyObject * args)1120 getargs_i(PyObject *self, PyObject *args)
1121 {
1122 int value;
1123 if (!PyArg_ParseTuple(args, "i", &value))
1124 return NULL;
1125 return PyLong_FromLong((long)value);
1126 }
1127
1128 static PyObject *
getargs_l(PyObject * self,PyObject * args)1129 getargs_l(PyObject *self, PyObject *args)
1130 {
1131 long value;
1132 if (!PyArg_ParseTuple(args, "l", &value))
1133 return NULL;
1134 return PyLong_FromLong(value);
1135 }
1136
1137 static PyObject *
getargs_n(PyObject * self,PyObject * args)1138 getargs_n(PyObject *self, PyObject *args)
1139 {
1140 Py_ssize_t value;
1141 if (!PyArg_ParseTuple(args, "n", &value))
1142 return NULL;
1143 return PyLong_FromSsize_t(value);
1144 }
1145
1146 static PyObject *
getargs_p(PyObject * self,PyObject * args)1147 getargs_p(PyObject *self, PyObject *args)
1148 {
1149 int value;
1150 if (!PyArg_ParseTuple(args, "p", &value))
1151 return NULL;
1152 return PyLong_FromLong(value);
1153 }
1154
1155 static PyObject *
getargs_L(PyObject * self,PyObject * args)1156 getargs_L(PyObject *self, PyObject *args)
1157 {
1158 long long value;
1159 if (!PyArg_ParseTuple(args, "L", &value))
1160 return NULL;
1161 return PyLong_FromLongLong(value);
1162 }
1163
1164 static PyObject *
getargs_K(PyObject * self,PyObject * args)1165 getargs_K(PyObject *self, PyObject *args)
1166 {
1167 unsigned long long value;
1168 if (!PyArg_ParseTuple(args, "K", &value))
1169 return NULL;
1170 return PyLong_FromUnsignedLongLong(value);
1171 }
1172
1173 /* This function not only tests the 'k' getargs code, but also the
1174 PyLong_AsUnsignedLongMask() function. */
1175 static PyObject *
test_k_code(PyObject * self)1176 test_k_code(PyObject *self)
1177 {
1178 PyObject *tuple, *num;
1179 unsigned long value;
1180
1181 tuple = PyTuple_New(1);
1182 if (tuple == NULL)
1183 return NULL;
1184
1185 /* a number larger than ULONG_MAX even on 64-bit platforms */
1186 num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
1187 if (num == NULL)
1188 return NULL;
1189
1190 value = PyLong_AsUnsignedLongMask(num);
1191 if (value != ULONG_MAX)
1192 return raiseTestError("test_k_code",
1193 "PyLong_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
1194
1195 PyTuple_SET_ITEM(tuple, 0, num);
1196
1197 value = 0;
1198 if (!PyArg_ParseTuple(tuple, "k:test_k_code", &value)) {
1199 return NULL;
1200 }
1201 if (value != ULONG_MAX)
1202 return raiseTestError("test_k_code",
1203 "k code returned wrong value for long 0xFFF...FFF");
1204
1205 Py_DECREF(num);
1206 num = PyLong_FromString("-FFFFFFFF000000000000000042", NULL, 16);
1207 if (num == NULL)
1208 return NULL;
1209
1210 value = PyLong_AsUnsignedLongMask(num);
1211 if (value != (unsigned long)-0x42)
1212 return raiseTestError("test_k_code",
1213 "PyLong_AsUnsignedLongMask() returned wrong "
1214 "value for long -0xFFF..000042");
1215
1216 PyTuple_SET_ITEM(tuple, 0, num);
1217
1218 value = 0;
1219 if (!PyArg_ParseTuple(tuple, "k:test_k_code", &value)) {
1220 return NULL;
1221 }
1222 if (value != (unsigned long)-0x42)
1223 return raiseTestError("test_k_code",
1224 "k code returned wrong value for long -0xFFF..000042");
1225
1226 Py_DECREF(tuple);
1227 Py_RETURN_NONE;
1228 }
1229
1230 static PyObject *
getargs_f(PyObject * self,PyObject * args)1231 getargs_f(PyObject *self, PyObject *args)
1232 {
1233 float f;
1234 if (!PyArg_ParseTuple(args, "f", &f))
1235 return NULL;
1236 return PyFloat_FromDouble(f);
1237 }
1238
1239 static PyObject *
getargs_d(PyObject * self,PyObject * args)1240 getargs_d(PyObject *self, PyObject *args)
1241 {
1242 double d;
1243 if (!PyArg_ParseTuple(args, "d", &d))
1244 return NULL;
1245 return PyFloat_FromDouble(d);
1246 }
1247
1248 static PyObject *
getargs_D(PyObject * self,PyObject * args)1249 getargs_D(PyObject *self, PyObject *args)
1250 {
1251 Py_complex cval;
1252 if (!PyArg_ParseTuple(args, "D", &cval))
1253 return NULL;
1254 return PyComplex_FromCComplex(cval);
1255 }
1256
1257 static PyObject *
getargs_S(PyObject * self,PyObject * args)1258 getargs_S(PyObject *self, PyObject *args)
1259 {
1260 PyObject *obj;
1261 if (!PyArg_ParseTuple(args, "S", &obj))
1262 return NULL;
1263 Py_INCREF(obj);
1264 return obj;
1265 }
1266
1267 static PyObject *
getargs_Y(PyObject * self,PyObject * args)1268 getargs_Y(PyObject *self, PyObject *args)
1269 {
1270 PyObject *obj;
1271 if (!PyArg_ParseTuple(args, "Y", &obj))
1272 return NULL;
1273 Py_INCREF(obj);
1274 return obj;
1275 }
1276
1277 static PyObject *
getargs_U(PyObject * self,PyObject * args)1278 getargs_U(PyObject *self, PyObject *args)
1279 {
1280 PyObject *obj;
1281 if (!PyArg_ParseTuple(args, "U", &obj))
1282 return NULL;
1283 Py_INCREF(obj);
1284 return obj;
1285 }
1286
1287 static PyObject *
getargs_c(PyObject * self,PyObject * args)1288 getargs_c(PyObject *self, PyObject *args)
1289 {
1290 char c;
1291 if (!PyArg_ParseTuple(args, "c", &c))
1292 return NULL;
1293 return PyLong_FromLong((unsigned char)c);
1294 }
1295
1296 static PyObject *
getargs_C(PyObject * self,PyObject * args)1297 getargs_C(PyObject *self, PyObject *args)
1298 {
1299 int c;
1300 if (!PyArg_ParseTuple(args, "C", &c))
1301 return NULL;
1302 return PyLong_FromLong(c);
1303 }
1304
1305 static PyObject *
getargs_s(PyObject * self,PyObject * args)1306 getargs_s(PyObject *self, PyObject *args)
1307 {
1308 char *str;
1309 if (!PyArg_ParseTuple(args, "s", &str))
1310 return NULL;
1311 return PyBytes_FromString(str);
1312 }
1313
1314 static PyObject *
getargs_s_star(PyObject * self,PyObject * args)1315 getargs_s_star(PyObject *self, PyObject *args)
1316 {
1317 Py_buffer buffer;
1318 PyObject *bytes;
1319 if (!PyArg_ParseTuple(args, "s*", &buffer))
1320 return NULL;
1321 bytes = PyBytes_FromStringAndSize(buffer.buf, buffer.len);
1322 PyBuffer_Release(&buffer);
1323 return bytes;
1324 }
1325
1326 static PyObject *
getargs_s_hash(PyObject * self,PyObject * args)1327 getargs_s_hash(PyObject *self, PyObject *args)
1328 {
1329 char *str;
1330 Py_ssize_t size;
1331 if (!PyArg_ParseTuple(args, "s#", &str, &size))
1332 return NULL;
1333 return PyBytes_FromStringAndSize(str, size);
1334 }
1335
1336 static PyObject *
getargs_z(PyObject * self,PyObject * args)1337 getargs_z(PyObject *self, PyObject *args)
1338 {
1339 char *str;
1340 if (!PyArg_ParseTuple(args, "z", &str))
1341 return NULL;
1342 if (str != NULL)
1343 return PyBytes_FromString(str);
1344 else
1345 Py_RETURN_NONE;
1346 }
1347
1348 static PyObject *
getargs_z_star(PyObject * self,PyObject * args)1349 getargs_z_star(PyObject *self, PyObject *args)
1350 {
1351 Py_buffer buffer;
1352 PyObject *bytes;
1353 if (!PyArg_ParseTuple(args, "z*", &buffer))
1354 return NULL;
1355 if (buffer.buf != NULL)
1356 bytes = PyBytes_FromStringAndSize(buffer.buf, buffer.len);
1357 else {
1358 Py_INCREF(Py_None);
1359 bytes = Py_None;
1360 }
1361 PyBuffer_Release(&buffer);
1362 return bytes;
1363 }
1364
1365 static PyObject *
getargs_z_hash(PyObject * self,PyObject * args)1366 getargs_z_hash(PyObject *self, PyObject *args)
1367 {
1368 char *str;
1369 Py_ssize_t size;
1370 if (!PyArg_ParseTuple(args, "z#", &str, &size))
1371 return NULL;
1372 if (str != NULL)
1373 return PyBytes_FromStringAndSize(str, size);
1374 else
1375 Py_RETURN_NONE;
1376 }
1377
1378 static PyObject *
getargs_y(PyObject * self,PyObject * args)1379 getargs_y(PyObject *self, PyObject *args)
1380 {
1381 char *str;
1382 if (!PyArg_ParseTuple(args, "y", &str))
1383 return NULL;
1384 return PyBytes_FromString(str);
1385 }
1386
1387 static PyObject *
getargs_y_star(PyObject * self,PyObject * args)1388 getargs_y_star(PyObject *self, PyObject *args)
1389 {
1390 Py_buffer buffer;
1391 PyObject *bytes;
1392 if (!PyArg_ParseTuple(args, "y*", &buffer))
1393 return NULL;
1394 bytes = PyBytes_FromStringAndSize(buffer.buf, buffer.len);
1395 PyBuffer_Release(&buffer);
1396 return bytes;
1397 }
1398
1399 static PyObject *
getargs_y_hash(PyObject * self,PyObject * args)1400 getargs_y_hash(PyObject *self, PyObject *args)
1401 {
1402 char *str;
1403 Py_ssize_t size;
1404 if (!PyArg_ParseTuple(args, "y#", &str, &size))
1405 return NULL;
1406 return PyBytes_FromStringAndSize(str, size);
1407 }
1408
1409 static PyObject *
getargs_u(PyObject * self,PyObject * args)1410 getargs_u(PyObject *self, PyObject *args)
1411 {
1412 Py_UNICODE *str;
1413 if (!PyArg_ParseTuple(args, "u", &str))
1414 return NULL;
1415 return PyUnicode_FromWideChar(str, -1);
1416 }
1417
1418 static PyObject *
getargs_u_hash(PyObject * self,PyObject * args)1419 getargs_u_hash(PyObject *self, PyObject *args)
1420 {
1421 Py_UNICODE *str;
1422 Py_ssize_t size;
1423 if (!PyArg_ParseTuple(args, "u#", &str, &size))
1424 return NULL;
1425 return PyUnicode_FromWideChar(str, size);
1426 }
1427
1428 static PyObject *
getargs_Z(PyObject * self,PyObject * args)1429 getargs_Z(PyObject *self, PyObject *args)
1430 {
1431 Py_UNICODE *str;
1432 if (!PyArg_ParseTuple(args, "Z", &str))
1433 return NULL;
1434 if (str != NULL) {
1435 return PyUnicode_FromWideChar(str, -1);
1436 } else
1437 Py_RETURN_NONE;
1438 }
1439
1440 static PyObject *
getargs_Z_hash(PyObject * self,PyObject * args)1441 getargs_Z_hash(PyObject *self, PyObject *args)
1442 {
1443 Py_UNICODE *str;
1444 Py_ssize_t size;
1445 if (!PyArg_ParseTuple(args, "Z#", &str, &size))
1446 return NULL;
1447 if (str != NULL)
1448 return PyUnicode_FromWideChar(str, size);
1449 else
1450 Py_RETURN_NONE;
1451 }
1452
1453 static PyObject *
getargs_es(PyObject * self,PyObject * args)1454 getargs_es(PyObject *self, PyObject *args)
1455 {
1456 PyObject *arg, *result;
1457 const char *encoding = NULL;
1458 char *str;
1459
1460 if (!PyArg_ParseTuple(args, "O|s", &arg, &encoding))
1461 return NULL;
1462 if (!PyArg_Parse(arg, "es", encoding, &str))
1463 return NULL;
1464 result = PyBytes_FromString(str);
1465 PyMem_Free(str);
1466 return result;
1467 }
1468
1469 static PyObject *
getargs_et(PyObject * self,PyObject * args)1470 getargs_et(PyObject *self, PyObject *args)
1471 {
1472 PyObject *arg, *result;
1473 const char *encoding = NULL;
1474 char *str;
1475
1476 if (!PyArg_ParseTuple(args, "O|s", &arg, &encoding))
1477 return NULL;
1478 if (!PyArg_Parse(arg, "et", encoding, &str))
1479 return NULL;
1480 result = PyBytes_FromString(str);
1481 PyMem_Free(str);
1482 return result;
1483 }
1484
1485 static PyObject *
getargs_es_hash(PyObject * self,PyObject * args)1486 getargs_es_hash(PyObject *self, PyObject *args)
1487 {
1488 PyObject *arg, *result;
1489 const char *encoding = NULL;
1490 PyByteArrayObject *buffer = NULL;
1491 char *str = NULL;
1492 Py_ssize_t size;
1493
1494 if (!PyArg_ParseTuple(args, "O|sY", &arg, &encoding, &buffer))
1495 return NULL;
1496 if (buffer != NULL) {
1497 str = PyByteArray_AS_STRING(buffer);
1498 size = PyByteArray_GET_SIZE(buffer);
1499 }
1500 if (!PyArg_Parse(arg, "es#", encoding, &str, &size))
1501 return NULL;
1502 result = PyBytes_FromStringAndSize(str, size);
1503 if (buffer == NULL)
1504 PyMem_Free(str);
1505 return result;
1506 }
1507
1508 static PyObject *
getargs_et_hash(PyObject * self,PyObject * args)1509 getargs_et_hash(PyObject *self, PyObject *args)
1510 {
1511 PyObject *arg, *result;
1512 const char *encoding = NULL;
1513 PyByteArrayObject *buffer = NULL;
1514 char *str = NULL;
1515 Py_ssize_t size;
1516
1517 if (!PyArg_ParseTuple(args, "O|sY", &arg, &encoding, &buffer))
1518 return NULL;
1519 if (buffer != NULL) {
1520 str = PyByteArray_AS_STRING(buffer);
1521 size = PyByteArray_GET_SIZE(buffer);
1522 }
1523 if (!PyArg_Parse(arg, "et#", encoding, &str, &size))
1524 return NULL;
1525 result = PyBytes_FromStringAndSize(str, size);
1526 if (buffer == NULL)
1527 PyMem_Free(str);
1528 return result;
1529 }
1530
1531 /* Test the s and z codes for PyArg_ParseTuple.
1532 */
1533 static PyObject *
test_s_code(PyObject * self)1534 test_s_code(PyObject *self)
1535 {
1536 /* Unicode strings should be accepted */
1537 PyObject *tuple, *obj;
1538 char *value;
1539
1540 tuple = PyTuple_New(1);
1541 if (tuple == NULL)
1542 return NULL;
1543
1544 obj = PyUnicode_Decode("t\xeate", strlen("t\xeate"),
1545 "latin-1", NULL);
1546 if (obj == NULL)
1547 return NULL;
1548
1549 PyTuple_SET_ITEM(tuple, 0, obj);
1550
1551 /* These two blocks used to raise a TypeError:
1552 * "argument must be string without null bytes, not str"
1553 */
1554 if (!PyArg_ParseTuple(tuple, "s:test_s_code1", &value)) {
1555 return NULL;
1556 }
1557
1558 if (!PyArg_ParseTuple(tuple, "z:test_s_code2", &value)) {
1559 return NULL;
1560 }
1561
1562 Py_DECREF(tuple);
1563 Py_RETURN_NONE;
1564 }
1565
1566 static PyObject *
parse_tuple_and_keywords(PyObject * self,PyObject * args)1567 parse_tuple_and_keywords(PyObject *self, PyObject *args)
1568 {
1569 PyObject *sub_args;
1570 PyObject *sub_kwargs;
1571 const char *sub_format;
1572 PyObject *sub_keywords;
1573
1574 Py_ssize_t i, size;
1575 char *keywords[8 + 1]; /* space for NULL at end */
1576 PyObject *o;
1577 PyObject *converted[8];
1578
1579 int result;
1580 PyObject *return_value = NULL;
1581
1582 double buffers[8][4]; /* double ensures alignment where necessary */
1583
1584 if (!PyArg_ParseTuple(args, "OOsO:parse_tuple_and_keywords",
1585 &sub_args, &sub_kwargs,
1586 &sub_format, &sub_keywords))
1587 return NULL;
1588
1589 if (!(PyList_CheckExact(sub_keywords) || PyTuple_CheckExact(sub_keywords))) {
1590 PyErr_SetString(PyExc_ValueError,
1591 "parse_tuple_and_keywords: sub_keywords must be either list or tuple");
1592 return NULL;
1593 }
1594
1595 memset(buffers, 0, sizeof(buffers));
1596 memset(converted, 0, sizeof(converted));
1597 memset(keywords, 0, sizeof(keywords));
1598
1599 size = PySequence_Fast_GET_SIZE(sub_keywords);
1600 if (size > 8) {
1601 PyErr_SetString(PyExc_ValueError,
1602 "parse_tuple_and_keywords: too many keywords in sub_keywords");
1603 goto exit;
1604 }
1605
1606 for (i = 0; i < size; i++) {
1607 o = PySequence_Fast_GET_ITEM(sub_keywords, i);
1608 if (!PyUnicode_FSConverter(o, (void *)(converted + i))) {
1609 PyErr_Format(PyExc_ValueError,
1610 "parse_tuple_and_keywords: could not convert keywords[%zd] to narrow string", i);
1611 goto exit;
1612 }
1613 keywords[i] = PyBytes_AS_STRING(converted[i]);
1614 }
1615
1616 result = PyArg_ParseTupleAndKeywords(sub_args, sub_kwargs,
1617 sub_format, keywords,
1618 buffers + 0, buffers + 1, buffers + 2, buffers + 3,
1619 buffers + 4, buffers + 5, buffers + 6, buffers + 7);
1620
1621 if (result) {
1622 return_value = Py_None;
1623 Py_INCREF(Py_None);
1624 }
1625
1626 exit:
1627 size = sizeof(converted) / sizeof(converted[0]);
1628 for (i = 0; i < size; i++) {
1629 Py_XDECREF(converted[i]);
1630 }
1631 return return_value;
1632 }
1633
1634 static volatile int x;
1635
1636 /* Test the u and u# codes for PyArg_ParseTuple. May leak memory in case
1637 of an error.
1638 */
1639 static PyObject *
test_u_code(PyObject * self)1640 test_u_code(PyObject *self)
1641 {
1642 PyObject *tuple, *obj;
1643 Py_UNICODE *value;
1644 Py_ssize_t len;
1645
1646 /* issue4122: Undefined reference to _Py_ascii_whitespace on Windows */
1647 /* Just use the macro and check that it compiles */
1648 x = Py_UNICODE_ISSPACE(25);
1649
1650 tuple = PyTuple_New(1);
1651 if (tuple == NULL)
1652 return NULL;
1653
1654 obj = PyUnicode_Decode("test", strlen("test"),
1655 "ascii", NULL);
1656 if (obj == NULL)
1657 return NULL;
1658
1659 PyTuple_SET_ITEM(tuple, 0, obj);
1660
1661 value = 0;
1662 if (!PyArg_ParseTuple(tuple, "u:test_u_code", &value)) {
1663 return NULL;
1664 }
1665 if (value != PyUnicode_AS_UNICODE(obj))
1666 return raiseTestError("test_u_code",
1667 "u code returned wrong value for u'test'");
1668 value = 0;
1669 if (!PyArg_ParseTuple(tuple, "u#:test_u_code", &value, &len)) {
1670 return NULL;
1671 }
1672 if (value != PyUnicode_AS_UNICODE(obj) ||
1673 len != PyUnicode_GET_SIZE(obj))
1674 return raiseTestError("test_u_code",
1675 "u# code returned wrong values for u'test'");
1676
1677 Py_DECREF(tuple);
1678 Py_RETURN_NONE;
1679 }
1680
1681 /* Test Z and Z# codes for PyArg_ParseTuple */
1682 static PyObject *
test_Z_code(PyObject * self)1683 test_Z_code(PyObject *self)
1684 {
1685 PyObject *tuple, *obj;
1686 const Py_UNICODE *value1, *value2;
1687 Py_ssize_t len1, len2;
1688
1689 tuple = PyTuple_New(2);
1690 if (tuple == NULL)
1691 return NULL;
1692
1693 obj = PyUnicode_FromString("test");
1694 PyTuple_SET_ITEM(tuple, 0, obj);
1695 Py_INCREF(Py_None);
1696 PyTuple_SET_ITEM(tuple, 1, Py_None);
1697
1698 /* swap values on purpose */
1699 value1 = NULL;
1700 value2 = PyUnicode_AS_UNICODE(obj);
1701
1702 /* Test Z for both values */
1703 if (!PyArg_ParseTuple(tuple, "ZZ:test_Z_code", &value1, &value2)) {
1704 return NULL;
1705 }
1706 if (value1 != PyUnicode_AS_UNICODE(obj))
1707 return raiseTestError("test_Z_code",
1708 "Z code returned wrong value for 'test'");
1709 if (value2 != NULL)
1710 return raiseTestError("test_Z_code",
1711 "Z code returned wrong value for None");
1712
1713 value1 = NULL;
1714 value2 = PyUnicode_AS_UNICODE(obj);
1715 len1 = -1;
1716 len2 = -1;
1717
1718 /* Test Z# for both values */
1719 if (!PyArg_ParseTuple(tuple, "Z#Z#:test_Z_code", &value1, &len1,
1720 &value2, &len2))
1721 {
1722 return NULL;
1723 }
1724 if (value1 != PyUnicode_AS_UNICODE(obj) ||
1725 len1 != PyUnicode_GET_SIZE(obj))
1726 return raiseTestError("test_Z_code",
1727 "Z# code returned wrong values for 'test'");
1728 if (value2 != NULL ||
1729 len2 != 0)
1730 return raiseTestError("test_Z_code",
1731 "Z# code returned wrong values for None'");
1732
1733 Py_DECREF(tuple);
1734 Py_RETURN_NONE;
1735 }
1736
1737 static PyObject *
test_widechar(PyObject * self)1738 test_widechar(PyObject *self)
1739 {
1740 #if defined(SIZEOF_WCHAR_T) && (SIZEOF_WCHAR_T == 4)
1741 const wchar_t wtext[2] = {(wchar_t)0x10ABCDu};
1742 size_t wtextlen = 1;
1743 const wchar_t invalid[1] = {(wchar_t)0x110000u};
1744 #else
1745 const wchar_t wtext[3] = {(wchar_t)0xDBEAu, (wchar_t)0xDFCDu};
1746 size_t wtextlen = 2;
1747 #endif
1748 PyObject *wide, *utf8;
1749
1750 wide = PyUnicode_FromWideChar(wtext, wtextlen);
1751 if (wide == NULL)
1752 return NULL;
1753
1754 utf8 = PyUnicode_FromString("\xf4\x8a\xaf\x8d");
1755 if (utf8 == NULL) {
1756 Py_DECREF(wide);
1757 return NULL;
1758 }
1759
1760 if (PyUnicode_GET_LENGTH(wide) != PyUnicode_GET_LENGTH(utf8)) {
1761 Py_DECREF(wide);
1762 Py_DECREF(utf8);
1763 return raiseTestError("test_widechar",
1764 "wide string and utf8 string "
1765 "have different length");
1766 }
1767 if (PyUnicode_Compare(wide, utf8)) {
1768 Py_DECREF(wide);
1769 Py_DECREF(utf8);
1770 if (PyErr_Occurred())
1771 return NULL;
1772 return raiseTestError("test_widechar",
1773 "wide string and utf8 string "
1774 "are different");
1775 }
1776
1777 Py_DECREF(wide);
1778 Py_DECREF(utf8);
1779
1780 #if defined(SIZEOF_WCHAR_T) && (SIZEOF_WCHAR_T == 4)
1781 wide = PyUnicode_FromWideChar(invalid, 1);
1782 if (wide == NULL)
1783 PyErr_Clear();
1784 else
1785 return raiseTestError("test_widechar",
1786 "PyUnicode_FromWideChar(L\"\\U00110000\", 1) didn't fail");
1787
1788 wide = PyUnicode_FromUnicode(invalid, 1);
1789 if (wide == NULL)
1790 PyErr_Clear();
1791 else
1792 return raiseTestError("test_widechar",
1793 "PyUnicode_FromUnicode(L\"\\U00110000\", 1) didn't fail");
1794
1795 wide = PyUnicode_FromUnicode(NULL, 1);
1796 if (wide == NULL)
1797 return NULL;
1798 PyUnicode_AS_UNICODE(wide)[0] = invalid[0];
1799 if (_PyUnicode_Ready(wide) < 0) {
1800 Py_DECREF(wide);
1801 PyErr_Clear();
1802 }
1803 else {
1804 Py_DECREF(wide);
1805 return raiseTestError("test_widechar",
1806 "PyUnicode_Ready() didn't fail");
1807 }
1808 #endif
1809
1810 Py_RETURN_NONE;
1811 }
1812
1813 static PyObject *
unicode_aswidechar(PyObject * self,PyObject * args)1814 unicode_aswidechar(PyObject *self, PyObject *args)
1815 {
1816 PyObject *unicode, *result;
1817 Py_ssize_t buflen, size;
1818 wchar_t *buffer;
1819
1820 if (!PyArg_ParseTuple(args, "Un", &unicode, &buflen))
1821 return NULL;
1822 buffer = PyMem_New(wchar_t, buflen);
1823 if (buffer == NULL)
1824 return PyErr_NoMemory();
1825
1826 size = PyUnicode_AsWideChar(unicode, buffer, buflen);
1827 if (size == -1) {
1828 PyMem_Free(buffer);
1829 return NULL;
1830 }
1831
1832 if (size < buflen)
1833 buflen = size + 1;
1834 else
1835 buflen = size;
1836 result = PyUnicode_FromWideChar(buffer, buflen);
1837 PyMem_Free(buffer);
1838 if (result == NULL)
1839 return NULL;
1840
1841 return Py_BuildValue("(Nn)", result, size);
1842 }
1843
1844 static PyObject *
unicode_aswidecharstring(PyObject * self,PyObject * args)1845 unicode_aswidecharstring(PyObject *self, PyObject *args)
1846 {
1847 PyObject *unicode, *result;
1848 Py_ssize_t size;
1849 wchar_t *buffer;
1850
1851 if (!PyArg_ParseTuple(args, "U", &unicode))
1852 return NULL;
1853
1854 buffer = PyUnicode_AsWideCharString(unicode, &size);
1855 if (buffer == NULL)
1856 return NULL;
1857
1858 result = PyUnicode_FromWideChar(buffer, size + 1);
1859 PyMem_Free(buffer);
1860 if (result == NULL)
1861 return NULL;
1862 return Py_BuildValue("(Nn)", result, size);
1863 }
1864
1865 static PyObject *
unicode_asucs4(PyObject * self,PyObject * args)1866 unicode_asucs4(PyObject *self, PyObject *args)
1867 {
1868 PyObject *unicode, *result;
1869 Py_UCS4 *buffer;
1870 int copy_null;
1871 Py_ssize_t str_len, buf_len;
1872
1873 if (!PyArg_ParseTuple(args, "Unp:unicode_asucs4", &unicode, &str_len, ©_null)) {
1874 return NULL;
1875 }
1876
1877 buf_len = str_len + 1;
1878 buffer = PyMem_NEW(Py_UCS4, buf_len);
1879 if (buffer == NULL) {
1880 return PyErr_NoMemory();
1881 }
1882 memset(buffer, 0, sizeof(Py_UCS4)*buf_len);
1883 buffer[str_len] = 0xffffU;
1884
1885 if (!PyUnicode_AsUCS4(unicode, buffer, buf_len, copy_null)) {
1886 PyMem_FREE(buffer);
1887 return NULL;
1888 }
1889
1890 result = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, buffer, buf_len);
1891 PyMem_FREE(buffer);
1892 return result;
1893 }
1894
1895 static PyObject *
unicode_findchar(PyObject * self,PyObject * args)1896 unicode_findchar(PyObject *self, PyObject *args)
1897 {
1898 PyObject *str;
1899 int direction;
1900 unsigned int ch;
1901 Py_ssize_t result;
1902 Py_ssize_t start, end;
1903
1904 if (!PyArg_ParseTuple(args, "UInni:unicode_findchar", &str, &ch,
1905 &start, &end, &direction)) {
1906 return NULL;
1907 }
1908
1909 result = PyUnicode_FindChar(str, (Py_UCS4)ch, start, end, direction);
1910 if (result == -2)
1911 return NULL;
1912 else
1913 return PyLong_FromSsize_t(result);
1914 }
1915
1916 static PyObject *
unicode_copycharacters(PyObject * self,PyObject * args)1917 unicode_copycharacters(PyObject *self, PyObject *args)
1918 {
1919 PyObject *from, *to, *to_copy;
1920 Py_ssize_t from_start, to_start, how_many, copied;
1921
1922 if (!PyArg_ParseTuple(args, "UnOnn:unicode_copycharacters", &to, &to_start,
1923 &from, &from_start, &how_many)) {
1924 return NULL;
1925 }
1926
1927 if (!(to_copy = PyUnicode_New(PyUnicode_GET_LENGTH(to),
1928 PyUnicode_MAX_CHAR_VALUE(to)))) {
1929 return NULL;
1930 }
1931 if (PyUnicode_Fill(to_copy, 0, PyUnicode_GET_LENGTH(to_copy), 0U) < 0) {
1932 Py_DECREF(to_copy);
1933 return NULL;
1934 }
1935
1936 if ((copied = PyUnicode_CopyCharacters(to_copy, to_start, from,
1937 from_start, how_many)) < 0) {
1938 Py_DECREF(to_copy);
1939 return NULL;
1940 }
1941
1942 return Py_BuildValue("(Nn)", to_copy, copied);
1943 }
1944
1945 static PyObject *
unicode_encodedecimal(PyObject * self,PyObject * args)1946 unicode_encodedecimal(PyObject *self, PyObject *args)
1947 {
1948 Py_UNICODE *unicode;
1949 Py_ssize_t length;
1950 char *errors = NULL;
1951 PyObject *decimal;
1952 Py_ssize_t decimal_length, new_length;
1953 int res;
1954
1955 if (!PyArg_ParseTuple(args, "u#|s", &unicode, &length, &errors))
1956 return NULL;
1957
1958 decimal_length = length * 7; /* len('€') */
1959 decimal = PyBytes_FromStringAndSize(NULL, decimal_length);
1960 if (decimal == NULL)
1961 return NULL;
1962
1963 res = PyUnicode_EncodeDecimal(unicode, length,
1964 PyBytes_AS_STRING(decimal),
1965 errors);
1966 if (res < 0) {
1967 Py_DECREF(decimal);
1968 return NULL;
1969 }
1970
1971 new_length = strlen(PyBytes_AS_STRING(decimal));
1972 assert(new_length <= decimal_length);
1973 res = _PyBytes_Resize(&decimal, new_length);
1974 if (res < 0)
1975 return NULL;
1976
1977 return decimal;
1978 }
1979
1980 static PyObject *
unicode_transformdecimaltoascii(PyObject * self,PyObject * args)1981 unicode_transformdecimaltoascii(PyObject *self, PyObject *args)
1982 {
1983 Py_UNICODE *unicode;
1984 Py_ssize_t length;
1985 if (!PyArg_ParseTuple(args, "u#|s", &unicode, &length))
1986 return NULL;
1987 return PyUnicode_TransformDecimalToASCII(unicode, length);
1988 }
1989
1990 static PyObject *
unicode_legacy_string(PyObject * self,PyObject * args)1991 unicode_legacy_string(PyObject *self, PyObject *args)
1992 {
1993 Py_UNICODE *data;
1994 Py_ssize_t len;
1995 PyObject *u;
1996
1997 if (!PyArg_ParseTuple(args, "u#", &data, &len))
1998 return NULL;
1999
2000 u = PyUnicode_FromUnicode(NULL, len);
2001 if (u == NULL)
2002 return NULL;
2003
2004 memcpy(PyUnicode_AS_UNICODE(u), data, len * sizeof(Py_UNICODE));
2005
2006 if (len > 0) { /* The empty string is always ready. */
2007 assert(!PyUnicode_IS_READY(u));
2008 }
2009
2010 return u;
2011 }
2012
2013 static PyObject *
getargs_w_star(PyObject * self,PyObject * args)2014 getargs_w_star(PyObject *self, PyObject *args)
2015 {
2016 Py_buffer buffer;
2017 PyObject *result;
2018 char *str;
2019
2020 if (!PyArg_ParseTuple(args, "w*:getargs_w_star", &buffer))
2021 return NULL;
2022
2023 if (2 <= buffer.len) {
2024 str = buffer.buf;
2025 str[0] = '[';
2026 str[buffer.len-1] = ']';
2027 }
2028
2029 result = PyBytes_FromStringAndSize(buffer.buf, buffer.len);
2030 PyBuffer_Release(&buffer);
2031 return result;
2032 }
2033
2034
2035 static PyObject *
test_empty_argparse(PyObject * self)2036 test_empty_argparse(PyObject *self)
2037 {
2038 /* Test that formats can begin with '|'. See issue #4720. */
2039 PyObject *tuple, *dict = NULL;
2040 static char *kwlist[] = {NULL};
2041 int result;
2042 tuple = PyTuple_New(0);
2043 if (!tuple)
2044 return NULL;
2045 if (!(result = PyArg_ParseTuple(tuple, "|:test_empty_argparse"))) {
2046 goto done;
2047 }
2048 dict = PyDict_New();
2049 if (!dict)
2050 goto done;
2051 result = PyArg_ParseTupleAndKeywords(tuple, dict, "|:test_empty_argparse", kwlist);
2052 done:
2053 Py_DECREF(tuple);
2054 Py_XDECREF(dict);
2055 if (!result) {
2056 return NULL;
2057 }
2058 else {
2059 Py_RETURN_NONE;
2060 }
2061 }
2062
2063 static PyObject *
codec_incrementalencoder(PyObject * self,PyObject * args)2064 codec_incrementalencoder(PyObject *self, PyObject *args)
2065 {
2066 const char *encoding, *errors = NULL;
2067 if (!PyArg_ParseTuple(args, "s|s:test_incrementalencoder",
2068 &encoding, &errors))
2069 return NULL;
2070 return PyCodec_IncrementalEncoder(encoding, errors);
2071 }
2072
2073 static PyObject *
codec_incrementaldecoder(PyObject * self,PyObject * args)2074 codec_incrementaldecoder(PyObject *self, PyObject *args)
2075 {
2076 const char *encoding, *errors = NULL;
2077 if (!PyArg_ParseTuple(args, "s|s:test_incrementaldecoder",
2078 &encoding, &errors))
2079 return NULL;
2080 return PyCodec_IncrementalDecoder(encoding, errors);
2081 }
2082
2083
2084 /* Simple test of _PyLong_NumBits and _PyLong_Sign. */
2085 static PyObject *
test_long_numbits(PyObject * self)2086 test_long_numbits(PyObject *self)
2087 {
2088 struct triple {
2089 long input;
2090 size_t nbits;
2091 int sign;
2092 } testcases[] = {{0, 0, 0},
2093 {1L, 1, 1},
2094 {-1L, 1, -1},
2095 {2L, 2, 1},
2096 {-2L, 2, -1},
2097 {3L, 2, 1},
2098 {-3L, 2, -1},
2099 {4L, 3, 1},
2100 {-4L, 3, -1},
2101 {0x7fffL, 15, 1}, /* one Python int digit */
2102 {-0x7fffL, 15, -1},
2103 {0xffffL, 16, 1},
2104 {-0xffffL, 16, -1},
2105 {0xfffffffL, 28, 1},
2106 {-0xfffffffL, 28, -1}};
2107 size_t i;
2108
2109 for (i = 0; i < Py_ARRAY_LENGTH(testcases); ++i) {
2110 size_t nbits;
2111 int sign;
2112 PyObject *plong;
2113
2114 plong = PyLong_FromLong(testcases[i].input);
2115 if (plong == NULL)
2116 return NULL;
2117 nbits = _PyLong_NumBits(plong);
2118 sign = _PyLong_Sign(plong);
2119
2120 Py_DECREF(plong);
2121 if (nbits != testcases[i].nbits)
2122 return raiseTestError("test_long_numbits",
2123 "wrong result for _PyLong_NumBits");
2124 if (sign != testcases[i].sign)
2125 return raiseTestError("test_long_numbits",
2126 "wrong result for _PyLong_Sign");
2127 }
2128 Py_RETURN_NONE;
2129 }
2130
2131 /* Example passing NULLs to PyObject_Str(NULL). */
2132
2133 static PyObject *
test_null_strings(PyObject * self)2134 test_null_strings(PyObject *self)
2135 {
2136 PyObject *o1 = PyObject_Str(NULL), *o2 = PyObject_Str(NULL);
2137 PyObject *tuple = PyTuple_Pack(2, o1, o2);
2138 Py_XDECREF(o1);
2139 Py_XDECREF(o2);
2140 return tuple;
2141 }
2142
2143 static PyObject *
raise_exception(PyObject * self,PyObject * args)2144 raise_exception(PyObject *self, PyObject *args)
2145 {
2146 PyObject *exc;
2147 PyObject *exc_args, *v;
2148 int num_args, i;
2149
2150 if (!PyArg_ParseTuple(args, "Oi:raise_exception",
2151 &exc, &num_args))
2152 return NULL;
2153
2154 exc_args = PyTuple_New(num_args);
2155 if (exc_args == NULL)
2156 return NULL;
2157 for (i = 0; i < num_args; ++i) {
2158 v = PyLong_FromLong(i);
2159 if (v == NULL) {
2160 Py_DECREF(exc_args);
2161 return NULL;
2162 }
2163 PyTuple_SET_ITEM(exc_args, i, v);
2164 }
2165 PyErr_SetObject(exc, exc_args);
2166 Py_DECREF(exc_args);
2167 return NULL;
2168 }
2169
2170 static PyObject *
set_errno(PyObject * self,PyObject * args)2171 set_errno(PyObject *self, PyObject *args)
2172 {
2173 int new_errno;
2174
2175 if (!PyArg_ParseTuple(args, "i:set_errno", &new_errno))
2176 return NULL;
2177
2178 errno = new_errno;
2179 Py_RETURN_NONE;
2180 }
2181
2182 static PyObject *
test_set_exc_info(PyObject * self,PyObject * args)2183 test_set_exc_info(PyObject *self, PyObject *args)
2184 {
2185 PyObject *orig_exc;
2186 PyObject *new_type, *new_value, *new_tb;
2187 PyObject *type, *value, *tb;
2188 if (!PyArg_ParseTuple(args, "OOO:test_set_exc_info",
2189 &new_type, &new_value, &new_tb))
2190 return NULL;
2191
2192 PyErr_GetExcInfo(&type, &value, &tb);
2193
2194 Py_INCREF(new_type);
2195 Py_INCREF(new_value);
2196 Py_INCREF(new_tb);
2197 PyErr_SetExcInfo(new_type, new_value, new_tb);
2198
2199 orig_exc = PyTuple_Pack(3, type ? type : Py_None, value ? value : Py_None, tb ? tb : Py_None);
2200 Py_XDECREF(type);
2201 Py_XDECREF(value);
2202 Py_XDECREF(tb);
2203 return orig_exc;
2204 }
2205
2206 static int test_run_counter = 0;
2207
2208 static PyObject *
test_datetime_capi(PyObject * self,PyObject * args)2209 test_datetime_capi(PyObject *self, PyObject *args) {
2210 if (PyDateTimeAPI) {
2211 if (test_run_counter) {
2212 /* Probably regrtest.py -R */
2213 Py_RETURN_NONE;
2214 }
2215 else {
2216 PyErr_SetString(PyExc_AssertionError,
2217 "PyDateTime_CAPI somehow initialized");
2218 return NULL;
2219 }
2220 }
2221 test_run_counter++;
2222 PyDateTime_IMPORT;
2223
2224 if (PyDateTimeAPI)
2225 Py_RETURN_NONE;
2226 else
2227 return NULL;
2228 }
2229
2230 /* Functions exposing the C API type checking for testing */
2231 #define MAKE_DATETIME_CHECK_FUNC(check_method, exact_method) \
2232 PyObject *obj; \
2233 int exact = 0; \
2234 if (!PyArg_ParseTuple(args, "O|p", &obj, &exact)) { \
2235 return NULL; \
2236 } \
2237 int rv = exact?exact_method(obj):check_method(obj); \
2238 if (rv) { \
2239 Py_RETURN_TRUE; \
2240 } else { \
2241 Py_RETURN_FALSE; \
2242 }
2243
2244 static PyObject *
datetime_check_date(PyObject * self,PyObject * args)2245 datetime_check_date(PyObject *self, PyObject *args) {
2246 MAKE_DATETIME_CHECK_FUNC(PyDate_Check, PyDate_CheckExact)
2247 }
2248
2249 static PyObject *
datetime_check_time(PyObject * self,PyObject * args)2250 datetime_check_time(PyObject *self, PyObject *args) {
2251 MAKE_DATETIME_CHECK_FUNC(PyTime_Check, PyTime_CheckExact)
2252 }
2253
2254 static PyObject *
datetime_check_datetime(PyObject * self,PyObject * args)2255 datetime_check_datetime(PyObject *self, PyObject *args) {
2256 MAKE_DATETIME_CHECK_FUNC(PyDateTime_Check, PyDateTime_CheckExact)
2257 }
2258
2259 static PyObject *
datetime_check_delta(PyObject * self,PyObject * args)2260 datetime_check_delta(PyObject *self, PyObject *args) {
2261 MAKE_DATETIME_CHECK_FUNC(PyDelta_Check, PyDelta_CheckExact)
2262 }
2263
2264 static PyObject *
datetime_check_tzinfo(PyObject * self,PyObject * args)2265 datetime_check_tzinfo(PyObject *self, PyObject *args) {
2266 MAKE_DATETIME_CHECK_FUNC(PyTZInfo_Check, PyTZInfo_CheckExact)
2267 }
2268
2269
2270 /* Makes three variations on timezone representing UTC-5:
2271 1. timezone with offset and name from PyDateTimeAPI
2272 2. timezone with offset and name from PyTimeZone_FromOffsetAndName
2273 3. timezone with offset (no name) from PyTimeZone_FromOffset
2274 */
2275 static PyObject *
make_timezones_capi(PyObject * self,PyObject * args)2276 make_timezones_capi(PyObject *self, PyObject *args) {
2277 PyObject *offset = PyDelta_FromDSU(0, -18000, 0);
2278 PyObject *name = PyUnicode_FromString("EST");
2279
2280 PyObject *est_zone_capi = PyDateTimeAPI->TimeZone_FromTimeZone(offset, name);
2281 PyObject *est_zone_macro = PyTimeZone_FromOffsetAndName(offset, name);
2282 PyObject *est_zone_macro_noname = PyTimeZone_FromOffset(offset);
2283
2284 Py_DecRef(offset);
2285 Py_DecRef(name);
2286
2287 PyObject *rv = PyTuple_New(3);
2288
2289 PyTuple_SET_ITEM(rv, 0, est_zone_capi);
2290 PyTuple_SET_ITEM(rv, 1, est_zone_macro);
2291 PyTuple_SET_ITEM(rv, 2, est_zone_macro_noname);
2292
2293 return rv;
2294 }
2295
2296 static PyObject *
get_timezones_offset_zero(PyObject * self,PyObject * args)2297 get_timezones_offset_zero(PyObject *self, PyObject *args) {
2298 PyObject *offset = PyDelta_FromDSU(0, 0, 0);
2299 PyObject *name = PyUnicode_FromString("");
2300
2301 // These two should return the UTC singleton
2302 PyObject *utc_singleton_0 = PyTimeZone_FromOffset(offset);
2303 PyObject *utc_singleton_1 = PyTimeZone_FromOffsetAndName(offset, NULL);
2304
2305 // This one will return +00:00 zone, but not the UTC singleton
2306 PyObject *non_utc_zone = PyTimeZone_FromOffsetAndName(offset, name);
2307
2308 Py_DecRef(offset);
2309 Py_DecRef(name);
2310
2311 PyObject *rv = PyTuple_New(3);
2312 PyTuple_SET_ITEM(rv, 0, utc_singleton_0);
2313 PyTuple_SET_ITEM(rv, 1, utc_singleton_1);
2314 PyTuple_SET_ITEM(rv, 2, non_utc_zone);
2315
2316 return rv;
2317 }
2318
2319 static PyObject *
get_timezone_utc_capi(PyObject * self,PyObject * args)2320 get_timezone_utc_capi(PyObject* self, PyObject *args) {
2321 int macro = 0;
2322 if (!PyArg_ParseTuple(args, "|p", ¯o)) {
2323 return NULL;
2324 }
2325 if (macro) {
2326 Py_INCREF(PyDateTime_TimeZone_UTC);
2327 return PyDateTime_TimeZone_UTC;
2328 } else {
2329 Py_INCREF(PyDateTimeAPI->TimeZone_UTC);
2330 return PyDateTimeAPI->TimeZone_UTC;
2331 }
2332 }
2333
2334
2335 /* test_thread_state spawns a thread of its own, and that thread releases
2336 * `thread_done` when it's finished. The driver code has to know when the
2337 * thread finishes, because the thread uses a PyObject (the callable) that
2338 * may go away when the driver finishes. The former lack of this explicit
2339 * synchronization caused rare segfaults, so rare that they were seen only
2340 * on a Mac buildbot (although they were possible on any box).
2341 */
2342 static PyThread_type_lock thread_done = NULL;
2343
2344 static int
_make_call(void * callable)2345 _make_call(void *callable)
2346 {
2347 PyObject *rc;
2348 int success;
2349 PyGILState_STATE s = PyGILState_Ensure();
2350 rc = _PyObject_CallNoArg((PyObject *)callable);
2351 success = (rc != NULL);
2352 Py_XDECREF(rc);
2353 PyGILState_Release(s);
2354 return success;
2355 }
2356
2357 /* Same thing, but releases `thread_done` when it returns. This variant
2358 * should be called only from threads spawned by test_thread_state().
2359 */
2360 static void
_make_call_from_thread(void * callable)2361 _make_call_from_thread(void *callable)
2362 {
2363 _make_call(callable);
2364 PyThread_release_lock(thread_done);
2365 }
2366
2367 static PyObject *
test_thread_state(PyObject * self,PyObject * args)2368 test_thread_state(PyObject *self, PyObject *args)
2369 {
2370 PyObject *fn;
2371 int success = 1;
2372
2373 if (!PyArg_ParseTuple(args, "O:test_thread_state", &fn))
2374 return NULL;
2375
2376 if (!PyCallable_Check(fn)) {
2377 PyErr_Format(PyExc_TypeError, "'%s' object is not callable",
2378 fn->ob_type->tp_name);
2379 return NULL;
2380 }
2381
2382 /* Ensure Python is set up for threading */
2383 PyEval_InitThreads();
2384 thread_done = PyThread_allocate_lock();
2385 if (thread_done == NULL)
2386 return PyErr_NoMemory();
2387 PyThread_acquire_lock(thread_done, 1);
2388
2389 /* Start a new thread with our callback. */
2390 PyThread_start_new_thread(_make_call_from_thread, fn);
2391 /* Make the callback with the thread lock held by this thread */
2392 success &= _make_call(fn);
2393 /* Do it all again, but this time with the thread-lock released */
2394 Py_BEGIN_ALLOW_THREADS
2395 success &= _make_call(fn);
2396 PyThread_acquire_lock(thread_done, 1); /* wait for thread to finish */
2397 Py_END_ALLOW_THREADS
2398
2399 /* And once more with and without a thread
2400 XXX - should use a lock and work out exactly what we are trying
2401 to test <wink>
2402 */
2403 Py_BEGIN_ALLOW_THREADS
2404 PyThread_start_new_thread(_make_call_from_thread, fn);
2405 success &= _make_call(fn);
2406 PyThread_acquire_lock(thread_done, 1); /* wait for thread to finish */
2407 Py_END_ALLOW_THREADS
2408
2409 /* Release lock we acquired above. This is required on HP-UX. */
2410 PyThread_release_lock(thread_done);
2411
2412 PyThread_free_lock(thread_done);
2413 if (!success)
2414 return NULL;
2415 Py_RETURN_NONE;
2416 }
2417
2418 /* test Py_AddPendingCalls using threads */
_pending_callback(void * arg)2419 static int _pending_callback(void *arg)
2420 {
2421 /* we assume the argument is callable object to which we own a reference */
2422 PyObject *callable = (PyObject *)arg;
2423 PyObject *r = _PyObject_CallNoArg(callable);
2424 Py_DECREF(callable);
2425 Py_XDECREF(r);
2426 return r != NULL ? 0 : -1;
2427 }
2428
2429 /* The following requests n callbacks to _pending_callback. It can be
2430 * run from any python thread.
2431 */
2432 static PyObject *
pending_threadfunc(PyObject * self,PyObject * arg)2433 pending_threadfunc(PyObject *self, PyObject *arg)
2434 {
2435 PyObject *callable;
2436 int r;
2437 if (PyArg_ParseTuple(arg, "O", &callable) == 0)
2438 return NULL;
2439
2440 /* create the reference for the callbackwhile we hold the lock */
2441 Py_INCREF(callable);
2442
2443 Py_BEGIN_ALLOW_THREADS
2444 r = Py_AddPendingCall(&_pending_callback, callable);
2445 Py_END_ALLOW_THREADS
2446
2447 if (r<0) {
2448 Py_DECREF(callable); /* unsuccessful add, destroy the extra reference */
2449 Py_RETURN_FALSE;
2450 }
2451 Py_RETURN_TRUE;
2452 }
2453
2454 /* Some tests of PyUnicode_FromFormat(). This needs more tests. */
2455 static PyObject *
test_string_from_format(PyObject * self,PyObject * Py_UNUSED (ignored))2456 test_string_from_format(PyObject *self, PyObject *Py_UNUSED(ignored))
2457 {
2458 PyObject *result;
2459 char *msg;
2460
2461 #define CHECK_1_FORMAT(FORMAT, TYPE) \
2462 result = PyUnicode_FromFormat(FORMAT, (TYPE)1); \
2463 if (result == NULL) \
2464 return NULL; \
2465 if (!_PyUnicode_EqualToASCIIString(result, "1")) { \
2466 msg = FORMAT " failed at 1"; \
2467 goto Fail; \
2468 } \
2469 Py_DECREF(result)
2470
2471 CHECK_1_FORMAT("%d", int);
2472 CHECK_1_FORMAT("%ld", long);
2473 /* The z width modifier was added in Python 2.5. */
2474 CHECK_1_FORMAT("%zd", Py_ssize_t);
2475
2476 /* The u type code was added in Python 2.5. */
2477 CHECK_1_FORMAT("%u", unsigned int);
2478 CHECK_1_FORMAT("%lu", unsigned long);
2479 CHECK_1_FORMAT("%zu", size_t);
2480
2481 /* "%lld" and "%llu" support added in Python 2.7. */
2482 CHECK_1_FORMAT("%llu", unsigned long long);
2483 CHECK_1_FORMAT("%lld", long long);
2484
2485 Py_RETURN_NONE;
2486
2487 Fail:
2488 Py_XDECREF(result);
2489 return raiseTestError("test_string_from_format", msg);
2490
2491 #undef CHECK_1_FORMAT
2492 }
2493
2494
2495 static PyObject *
test_unicode_compare_with_ascii(PyObject * self)2496 test_unicode_compare_with_ascii(PyObject *self) {
2497 PyObject *py_s = PyUnicode_FromStringAndSize("str\0", 4);
2498 int result;
2499 if (py_s == NULL)
2500 return NULL;
2501 result = PyUnicode_CompareWithASCIIString(py_s, "str");
2502 Py_DECREF(py_s);
2503 if (!result) {
2504 PyErr_SetString(TestError, "Python string ending in NULL "
2505 "should not compare equal to c string.");
2506 return NULL;
2507 }
2508 Py_RETURN_NONE;
2509 }
2510
2511 /* This is here to provide a docstring for test_descr. */
2512 static PyObject *
test_with_docstring(PyObject * self)2513 test_with_docstring(PyObject *self)
2514 {
2515 Py_RETURN_NONE;
2516 }
2517
2518 /* Test PyOS_string_to_double. */
2519 static PyObject *
test_string_to_double(PyObject * self)2520 test_string_to_double(PyObject *self) {
2521 double result;
2522 const char *msg;
2523
2524 #define CHECK_STRING(STR, expected) \
2525 result = PyOS_string_to_double(STR, NULL, NULL); \
2526 if (result == -1.0 && PyErr_Occurred()) \
2527 return NULL; \
2528 if (result != (double)expected) { \
2529 msg = "conversion of " STR " to float failed"; \
2530 goto fail; \
2531 }
2532
2533 #define CHECK_INVALID(STR) \
2534 result = PyOS_string_to_double(STR, NULL, NULL); \
2535 if (result == -1.0 && PyErr_Occurred()) { \
2536 if (PyErr_ExceptionMatches(PyExc_ValueError)) \
2537 PyErr_Clear(); \
2538 else \
2539 return NULL; \
2540 } \
2541 else { \
2542 msg = "conversion of " STR " didn't raise ValueError"; \
2543 goto fail; \
2544 }
2545
2546 CHECK_STRING("0.1", 0.1);
2547 CHECK_STRING("1.234", 1.234);
2548 CHECK_STRING("-1.35", -1.35);
2549 CHECK_STRING(".1e01", 1.0);
2550 CHECK_STRING("2.e-2", 0.02);
2551
2552 CHECK_INVALID(" 0.1");
2553 CHECK_INVALID("\t\n-3");
2554 CHECK_INVALID(".123 ");
2555 CHECK_INVALID("3\n");
2556 CHECK_INVALID("123abc");
2557
2558 Py_RETURN_NONE;
2559 fail:
2560 return raiseTestError("test_string_to_double", msg);
2561 #undef CHECK_STRING
2562 #undef CHECK_INVALID
2563 }
2564
2565
2566 /* Coverage testing of capsule objects. */
2567
2568 static const char *capsule_name = "capsule name";
2569 static char *capsule_pointer = "capsule pointer";
2570 static char *capsule_context = "capsule context";
2571 static const char *capsule_error = NULL;
2572 static int
2573 capsule_destructor_call_count = 0;
2574
2575 static void
capsule_destructor(PyObject * o)2576 capsule_destructor(PyObject *o) {
2577 capsule_destructor_call_count++;
2578 if (PyCapsule_GetContext(o) != capsule_context) {
2579 capsule_error = "context did not match in destructor!";
2580 } else if (PyCapsule_GetDestructor(o) != capsule_destructor) {
2581 capsule_error = "destructor did not match in destructor! (woah!)";
2582 } else if (PyCapsule_GetName(o) != capsule_name) {
2583 capsule_error = "name did not match in destructor!";
2584 } else if (PyCapsule_GetPointer(o, capsule_name) != capsule_pointer) {
2585 capsule_error = "pointer did not match in destructor!";
2586 }
2587 }
2588
2589 typedef struct {
2590 char *name;
2591 char *module;
2592 char *attribute;
2593 } known_capsule;
2594
2595 static PyObject *
test_capsule(PyObject * self,PyObject * Py_UNUSED (ignored))2596 test_capsule(PyObject *self, PyObject *Py_UNUSED(ignored))
2597 {
2598 PyObject *object;
2599 const char *error = NULL;
2600 void *pointer;
2601 void *pointer2;
2602 known_capsule known_capsules[] = {
2603 #define KNOWN_CAPSULE(module, name) { module "." name, module, name }
2604 KNOWN_CAPSULE("_socket", "CAPI"),
2605 KNOWN_CAPSULE("_curses", "_C_API"),
2606 KNOWN_CAPSULE("datetime", "datetime_CAPI"),
2607 { NULL, NULL },
2608 };
2609 known_capsule *known = &known_capsules[0];
2610
2611 #define FAIL(x) { error = (x); goto exit; }
2612
2613 #define CHECK_DESTRUCTOR \
2614 if (capsule_error) { \
2615 FAIL(capsule_error); \
2616 } \
2617 else if (!capsule_destructor_call_count) { \
2618 FAIL("destructor not called!"); \
2619 } \
2620 capsule_destructor_call_count = 0; \
2621
2622 object = PyCapsule_New(capsule_pointer, capsule_name, capsule_destructor);
2623 PyCapsule_SetContext(object, capsule_context);
2624 capsule_destructor(object);
2625 CHECK_DESTRUCTOR;
2626 Py_DECREF(object);
2627 CHECK_DESTRUCTOR;
2628
2629 object = PyCapsule_New(known, "ignored", NULL);
2630 PyCapsule_SetPointer(object, capsule_pointer);
2631 PyCapsule_SetName(object, capsule_name);
2632 PyCapsule_SetDestructor(object, capsule_destructor);
2633 PyCapsule_SetContext(object, capsule_context);
2634 capsule_destructor(object);
2635 CHECK_DESTRUCTOR;
2636 /* intentionally access using the wrong name */
2637 pointer2 = PyCapsule_GetPointer(object, "the wrong name");
2638 if (!PyErr_Occurred()) {
2639 FAIL("PyCapsule_GetPointer should have failed but did not!");
2640 }
2641 PyErr_Clear();
2642 if (pointer2) {
2643 if (pointer2 == capsule_pointer) {
2644 FAIL("PyCapsule_GetPointer should not have"
2645 " returned the internal pointer!");
2646 } else {
2647 FAIL("PyCapsule_GetPointer should have "
2648 "returned NULL pointer but did not!");
2649 }
2650 }
2651 PyCapsule_SetDestructor(object, NULL);
2652 Py_DECREF(object);
2653 if (capsule_destructor_call_count) {
2654 FAIL("destructor called when it should not have been!");
2655 }
2656
2657 for (known = &known_capsules[0]; known->module != NULL; known++) {
2658 /* yeah, ordinarily I wouldn't do this either,
2659 but it's fine for this test harness.
2660 */
2661 static char buffer[256];
2662 #undef FAIL
2663 #define FAIL(x) \
2664 { \
2665 sprintf(buffer, "%s module: \"%s\" attribute: \"%s\"", \
2666 x, known->module, known->attribute); \
2667 error = buffer; \
2668 goto exit; \
2669 } \
2670
2671 PyObject *module = PyImport_ImportModule(known->module);
2672 if (module) {
2673 pointer = PyCapsule_Import(known->name, 0);
2674 if (!pointer) {
2675 Py_DECREF(module);
2676 FAIL("PyCapsule_GetPointer returned NULL unexpectedly!");
2677 }
2678 object = PyObject_GetAttrString(module, known->attribute);
2679 if (!object) {
2680 Py_DECREF(module);
2681 return NULL;
2682 }
2683 pointer2 = PyCapsule_GetPointer(object,
2684 "weebles wobble but they don't fall down");
2685 if (!PyErr_Occurred()) {
2686 Py_DECREF(object);
2687 Py_DECREF(module);
2688 FAIL("PyCapsule_GetPointer should have failed but did not!");
2689 }
2690 PyErr_Clear();
2691 if (pointer2) {
2692 Py_DECREF(module);
2693 Py_DECREF(object);
2694 if (pointer2 == pointer) {
2695 FAIL("PyCapsule_GetPointer should not have"
2696 " returned its internal pointer!");
2697 } else {
2698 FAIL("PyCapsule_GetPointer should have"
2699 " returned NULL pointer but did not!");
2700 }
2701 }
2702 Py_DECREF(object);
2703 Py_DECREF(module);
2704 }
2705 else
2706 PyErr_Clear();
2707 }
2708
2709 exit:
2710 if (error) {
2711 return raiseTestError("test_capsule", error);
2712 }
2713 Py_RETURN_NONE;
2714 #undef FAIL
2715 }
2716
2717 #ifdef HAVE_GETTIMEOFDAY
2718 /* Profiling of integer performance */
print_delta(int test,struct timeval * s,struct timeval * e)2719 static void print_delta(int test, struct timeval *s, struct timeval *e)
2720 {
2721 e->tv_sec -= s->tv_sec;
2722 e->tv_usec -= s->tv_usec;
2723 if (e->tv_usec < 0) {
2724 e->tv_sec -=1;
2725 e->tv_usec += 1000000;
2726 }
2727 printf("Test %d: %d.%06ds\n", test, (int)e->tv_sec, (int)e->tv_usec);
2728 }
2729
2730 static PyObject *
profile_int(PyObject * self,PyObject * args)2731 profile_int(PyObject *self, PyObject* args)
2732 {
2733 int i, k;
2734 struct timeval start, stop;
2735 PyObject *single, **multiple, *op1, *result;
2736
2737 /* Test 1: Allocate and immediately deallocate
2738 many small integers */
2739 gettimeofday(&start, NULL);
2740 for(k=0; k < 20000; k++)
2741 for(i=0; i < 1000; i++) {
2742 single = PyLong_FromLong(i);
2743 Py_DECREF(single);
2744 }
2745 gettimeofday(&stop, NULL);
2746 print_delta(1, &start, &stop);
2747
2748 /* Test 2: Allocate and immediately deallocate
2749 many large integers */
2750 gettimeofday(&start, NULL);
2751 for(k=0; k < 20000; k++)
2752 for(i=0; i < 1000; i++) {
2753 single = PyLong_FromLong(i+1000000);
2754 Py_DECREF(single);
2755 }
2756 gettimeofday(&stop, NULL);
2757 print_delta(2, &start, &stop);
2758
2759 /* Test 3: Allocate a few integers, then release
2760 them all simultaneously. */
2761 multiple = malloc(sizeof(PyObject*) * 1000);
2762 if (multiple == NULL)
2763 return PyErr_NoMemory();
2764 gettimeofday(&start, NULL);
2765 for(k=0; k < 20000; k++) {
2766 for(i=0; i < 1000; i++) {
2767 multiple[i] = PyLong_FromLong(i+1000000);
2768 }
2769 for(i=0; i < 1000; i++) {
2770 Py_DECREF(multiple[i]);
2771 }
2772 }
2773 gettimeofday(&stop, NULL);
2774 print_delta(3, &start, &stop);
2775 free(multiple);
2776
2777 /* Test 4: Allocate many integers, then release
2778 them all simultaneously. */
2779 multiple = malloc(sizeof(PyObject*) * 1000000);
2780 if (multiple == NULL)
2781 return PyErr_NoMemory();
2782 gettimeofday(&start, NULL);
2783 for(k=0; k < 20; k++) {
2784 for(i=0; i < 1000000; i++) {
2785 multiple[i] = PyLong_FromLong(i+1000000);
2786 }
2787 for(i=0; i < 1000000; i++) {
2788 Py_DECREF(multiple[i]);
2789 }
2790 }
2791 gettimeofday(&stop, NULL);
2792 print_delta(4, &start, &stop);
2793 free(multiple);
2794
2795 /* Test 5: Allocate many integers < 32000 */
2796 multiple = malloc(sizeof(PyObject*) * 1000000);
2797 if (multiple == NULL)
2798 return PyErr_NoMemory();
2799 gettimeofday(&start, NULL);
2800 for(k=0; k < 10; k++) {
2801 for(i=0; i < 1000000; i++) {
2802 multiple[i] = PyLong_FromLong(i+1000);
2803 }
2804 for(i=0; i < 1000000; i++) {
2805 Py_DECREF(multiple[i]);
2806 }
2807 }
2808 gettimeofday(&stop, NULL);
2809 print_delta(5, &start, &stop);
2810 free(multiple);
2811
2812 /* Test 6: Perform small int addition */
2813 op1 = PyLong_FromLong(1);
2814 gettimeofday(&start, NULL);
2815 for(i=0; i < 10000000; i++) {
2816 result = PyNumber_Add(op1, op1);
2817 Py_DECREF(result);
2818 }
2819 gettimeofday(&stop, NULL);
2820 Py_DECREF(op1);
2821 print_delta(6, &start, &stop);
2822
2823 /* Test 7: Perform medium int addition */
2824 op1 = PyLong_FromLong(1000);
2825 if (op1 == NULL)
2826 return NULL;
2827 gettimeofday(&start, NULL);
2828 for(i=0; i < 10000000; i++) {
2829 result = PyNumber_Add(op1, op1);
2830 Py_XDECREF(result);
2831 }
2832 gettimeofday(&stop, NULL);
2833 Py_DECREF(op1);
2834 print_delta(7, &start, &stop);
2835
2836 Py_RETURN_NONE;
2837 }
2838 #endif
2839
2840 /* To test the format of tracebacks as printed out. */
2841 static PyObject *
traceback_print(PyObject * self,PyObject * args)2842 traceback_print(PyObject *self, PyObject *args)
2843 {
2844 PyObject *file;
2845 PyObject *traceback;
2846 int result;
2847
2848 if (!PyArg_ParseTuple(args, "OO:traceback_print",
2849 &traceback, &file))
2850 return NULL;
2851
2852 result = PyTraceBack_Print(traceback, file);
2853 if (result < 0)
2854 return NULL;
2855 Py_RETURN_NONE;
2856 }
2857
2858 /* To test the format of exceptions as printed out. */
2859 static PyObject *
exception_print(PyObject * self,PyObject * args)2860 exception_print(PyObject *self, PyObject *args)
2861 {
2862 PyObject *value;
2863 PyObject *tb;
2864
2865 if (!PyArg_ParseTuple(args, "O:exception_print",
2866 &value))
2867 return NULL;
2868 if (!PyExceptionInstance_Check(value)) {
2869 PyErr_Format(PyExc_TypeError, "an exception instance is required");
2870 return NULL;
2871 }
2872
2873 tb = PyException_GetTraceback(value);
2874 PyErr_Display((PyObject *) Py_TYPE(value), value, tb);
2875 Py_XDECREF(tb);
2876
2877 Py_RETURN_NONE;
2878 }
2879
2880
2881
2882
2883 /* reliably raise a MemoryError */
2884 static PyObject *
raise_memoryerror(PyObject * self)2885 raise_memoryerror(PyObject *self)
2886 {
2887 PyErr_NoMemory();
2888 return NULL;
2889 }
2890
2891 /* Issue 6012 */
2892 static PyObject *str1, *str2;
2893 static int
failing_converter(PyObject * obj,void * arg)2894 failing_converter(PyObject *obj, void *arg)
2895 {
2896 /* Clone str1, then let the conversion fail. */
2897 assert(str1);
2898 str2 = str1;
2899 Py_INCREF(str2);
2900 return 0;
2901 }
2902 static PyObject*
argparsing(PyObject * o,PyObject * args)2903 argparsing(PyObject *o, PyObject *args)
2904 {
2905 PyObject *res;
2906 str1 = str2 = NULL;
2907 if (!PyArg_ParseTuple(args, "O&O&",
2908 PyUnicode_FSConverter, &str1,
2909 failing_converter, &str2)) {
2910 if (!str2)
2911 /* argument converter not called? */
2912 return NULL;
2913 /* Should be 1 */
2914 res = PyLong_FromSsize_t(Py_REFCNT(str2));
2915 Py_DECREF(str2);
2916 PyErr_Clear();
2917 return res;
2918 }
2919 Py_RETURN_NONE;
2920 }
2921
2922 /* To test that the result of PyCode_NewEmpty has the right members. */
2923 static PyObject *
code_newempty(PyObject * self,PyObject * args)2924 code_newempty(PyObject *self, PyObject *args)
2925 {
2926 const char *filename;
2927 const char *funcname;
2928 int firstlineno;
2929
2930 if (!PyArg_ParseTuple(args, "ssi:code_newempty",
2931 &filename, &funcname, &firstlineno))
2932 return NULL;
2933
2934 return (PyObject *)PyCode_NewEmpty(filename, funcname, firstlineno);
2935 }
2936
2937 /* Test PyErr_NewExceptionWithDoc (also exercise PyErr_NewException).
2938 Run via Lib/test/test_exceptions.py */
2939 static PyObject *
make_exception_with_doc(PyObject * self,PyObject * args,PyObject * kwargs)2940 make_exception_with_doc(PyObject *self, PyObject *args, PyObject *kwargs)
2941 {
2942 const char *name;
2943 const char *doc = NULL;
2944 PyObject *base = NULL;
2945 PyObject *dict = NULL;
2946
2947 static char *kwlist[] = {"name", "doc", "base", "dict", NULL};
2948
2949 if (!PyArg_ParseTupleAndKeywords(args, kwargs,
2950 "s|sOO:make_exception_with_doc", kwlist,
2951 &name, &doc, &base, &dict))
2952 return NULL;
2953
2954 return PyErr_NewExceptionWithDoc(name, doc, base, dict);
2955 }
2956
2957 static PyObject *
make_memoryview_from_NULL_pointer(PyObject * self)2958 make_memoryview_from_NULL_pointer(PyObject *self)
2959 {
2960 Py_buffer info;
2961 if (PyBuffer_FillInfo(&info, NULL, NULL, 1, 1, PyBUF_FULL_RO) < 0)
2962 return NULL;
2963 return PyMemoryView_FromBuffer(&info);
2964 }
2965
2966 static PyObject *
test_from_contiguous(PyObject * self,PyObject * Py_UNUSED (ignored))2967 test_from_contiguous(PyObject* self, PyObject *Py_UNUSED(ignored))
2968 {
2969 int data[9] = {-1,-1,-1,-1,-1,-1,-1,-1,-1};
2970 int init[5] = {0, 1, 2, 3, 4};
2971 Py_ssize_t itemsize = sizeof(int);
2972 Py_ssize_t shape = 5;
2973 Py_ssize_t strides = 2 * itemsize;
2974 Py_buffer view = {
2975 data,
2976 NULL,
2977 5 * itemsize,
2978 itemsize,
2979 1,
2980 1,
2981 NULL,
2982 &shape,
2983 &strides,
2984 NULL,
2985 NULL
2986 };
2987 int *ptr;
2988 int i;
2989
2990 PyBuffer_FromContiguous(&view, init, view.len, 'C');
2991 ptr = view.buf;
2992 for (i = 0; i < 5; i++) {
2993 if (ptr[2*i] != i) {
2994 PyErr_SetString(TestError,
2995 "test_from_contiguous: incorrect result");
2996 return NULL;
2997 }
2998 }
2999
3000 view.buf = &data[8];
3001 view.strides[0] = -2 * itemsize;
3002
3003 PyBuffer_FromContiguous(&view, init, view.len, 'C');
3004 ptr = view.buf;
3005 for (i = 0; i < 5; i++) {
3006 if (*(ptr-2*i) != i) {
3007 PyErr_SetString(TestError,
3008 "test_from_contiguous: incorrect result");
3009 return NULL;
3010 }
3011 }
3012
3013 Py_RETURN_NONE;
3014 }
3015
3016 #if (defined(__linux__) || defined(__FreeBSD__)) && defined(__GNUC__)
3017 extern PyTypeObject _PyBytesIOBuffer_Type;
3018
3019 static PyObject *
test_pep3118_obsolete_write_locks(PyObject * self,PyObject * Py_UNUSED (ignored))3020 test_pep3118_obsolete_write_locks(PyObject* self, PyObject *Py_UNUSED(ignored))
3021 {
3022 PyTypeObject *type = &_PyBytesIOBuffer_Type;
3023 PyObject *b;
3024 char *dummy[1];
3025 int ret, match;
3026
3027 /* PyBuffer_FillInfo() */
3028 ret = PyBuffer_FillInfo(NULL, NULL, dummy, 1, 0, PyBUF_SIMPLE);
3029 match = PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_BufferError);
3030 PyErr_Clear();
3031 if (ret != -1 || match == 0)
3032 goto error;
3033
3034 /* bytesiobuf_getbuffer() */
3035 b = type->tp_alloc(type, 0);
3036 if (b == NULL) {
3037 return NULL;
3038 }
3039
3040 ret = PyObject_GetBuffer(b, NULL, PyBUF_SIMPLE);
3041 Py_DECREF(b);
3042 match = PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_BufferError);
3043 PyErr_Clear();
3044 if (ret != -1 || match == 0)
3045 goto error;
3046
3047 Py_RETURN_NONE;
3048
3049 error:
3050 PyErr_SetString(TestError,
3051 "test_pep3118_obsolete_write_locks: failure");
3052 return NULL;
3053 }
3054 #endif
3055
3056 /* This tests functions that historically supported write locks. It is
3057 wrong to call getbuffer() with view==NULL and a compliant getbufferproc
3058 is entitled to segfault in that case. */
3059 static PyObject *
getbuffer_with_null_view(PyObject * self,PyObject * obj)3060 getbuffer_with_null_view(PyObject* self, PyObject *obj)
3061 {
3062 if (PyObject_GetBuffer(obj, NULL, PyBUF_SIMPLE) < 0)
3063 return NULL;
3064
3065 Py_RETURN_NONE;
3066 }
3067
3068 /* Test that the fatal error from not having a current thread doesn't
3069 cause an infinite loop. Run via Lib/test/test_capi.py */
3070 static PyObject *
crash_no_current_thread(PyObject * self)3071 crash_no_current_thread(PyObject *self)
3072 {
3073 Py_BEGIN_ALLOW_THREADS
3074 /* Using PyThreadState_Get() directly allows the test to pass in
3075 !pydebug mode. However, the test only actually tests anything
3076 in pydebug mode, since that's where the infinite loop was in
3077 the first place. */
3078 PyThreadState_Get();
3079 Py_END_ALLOW_THREADS
3080 return NULL;
3081 }
3082
3083 /* To run some code in a sub-interpreter. */
3084 static PyObject *
run_in_subinterp(PyObject * self,PyObject * args)3085 run_in_subinterp(PyObject *self, PyObject *args)
3086 {
3087 const char *code;
3088 int r;
3089 PyThreadState *substate, *mainstate;
3090
3091 if (!PyArg_ParseTuple(args, "s:run_in_subinterp",
3092 &code))
3093 return NULL;
3094
3095 mainstate = PyThreadState_Get();
3096
3097 PyThreadState_Swap(NULL);
3098
3099 substate = Py_NewInterpreter();
3100 if (substate == NULL) {
3101 /* Since no new thread state was created, there is no exception to
3102 propagate; raise a fresh one after swapping in the old thread
3103 state. */
3104 PyThreadState_Swap(mainstate);
3105 PyErr_SetString(PyExc_RuntimeError, "sub-interpreter creation failed");
3106 return NULL;
3107 }
3108 r = PyRun_SimpleString(code);
3109 Py_EndInterpreter(substate);
3110
3111 PyThreadState_Swap(mainstate);
3112
3113 return PyLong_FromLong(r);
3114 }
3115
3116 static int
check_time_rounding(int round)3117 check_time_rounding(int round)
3118 {
3119 if (round != _PyTime_ROUND_FLOOR
3120 && round != _PyTime_ROUND_CEILING
3121 && round != _PyTime_ROUND_HALF_EVEN
3122 && round != _PyTime_ROUND_UP) {
3123 PyErr_SetString(PyExc_ValueError, "invalid rounding");
3124 return -1;
3125 }
3126 return 0;
3127 }
3128
3129 static PyObject *
test_pytime_object_to_time_t(PyObject * self,PyObject * args)3130 test_pytime_object_to_time_t(PyObject *self, PyObject *args)
3131 {
3132 PyObject *obj;
3133 time_t sec;
3134 int round;
3135 if (!PyArg_ParseTuple(args, "Oi:pytime_object_to_time_t", &obj, &round))
3136 return NULL;
3137 if (check_time_rounding(round) < 0)
3138 return NULL;
3139 if (_PyTime_ObjectToTime_t(obj, &sec, round) == -1)
3140 return NULL;
3141 return _PyLong_FromTime_t(sec);
3142 }
3143
3144 static PyObject *
test_pytime_object_to_timeval(PyObject * self,PyObject * args)3145 test_pytime_object_to_timeval(PyObject *self, PyObject *args)
3146 {
3147 PyObject *obj;
3148 time_t sec;
3149 long usec;
3150 int round;
3151 if (!PyArg_ParseTuple(args, "Oi:pytime_object_to_timeval", &obj, &round))
3152 return NULL;
3153 if (check_time_rounding(round) < 0)
3154 return NULL;
3155 if (_PyTime_ObjectToTimeval(obj, &sec, &usec, round) == -1)
3156 return NULL;
3157 return Py_BuildValue("Nl", _PyLong_FromTime_t(sec), usec);
3158 }
3159
3160 static PyObject *
test_pytime_object_to_timespec(PyObject * self,PyObject * args)3161 test_pytime_object_to_timespec(PyObject *self, PyObject *args)
3162 {
3163 PyObject *obj;
3164 time_t sec;
3165 long nsec;
3166 int round;
3167 if (!PyArg_ParseTuple(args, "Oi:pytime_object_to_timespec", &obj, &round))
3168 return NULL;
3169 if (check_time_rounding(round) < 0)
3170 return NULL;
3171 if (_PyTime_ObjectToTimespec(obj, &sec, &nsec, round) == -1)
3172 return NULL;
3173 return Py_BuildValue("Nl", _PyLong_FromTime_t(sec), nsec);
3174 }
3175
3176 static void
slot_tp_del(PyObject * self)3177 slot_tp_del(PyObject *self)
3178 {
3179 _Py_IDENTIFIER(__tp_del__);
3180 PyObject *del, *res;
3181 PyObject *error_type, *error_value, *error_traceback;
3182
3183 /* Temporarily resurrect the object. */
3184 assert(self->ob_refcnt == 0);
3185 self->ob_refcnt = 1;
3186
3187 /* Save the current exception, if any. */
3188 PyErr_Fetch(&error_type, &error_value, &error_traceback);
3189
3190 /* Execute __del__ method, if any. */
3191 del = _PyObject_LookupSpecial(self, &PyId___tp_del__);
3192 if (del != NULL) {
3193 res = _PyObject_CallNoArg(del);
3194 if (res == NULL)
3195 PyErr_WriteUnraisable(del);
3196 else
3197 Py_DECREF(res);
3198 Py_DECREF(del);
3199 }
3200
3201 /* Restore the saved exception. */
3202 PyErr_Restore(error_type, error_value, error_traceback);
3203
3204 /* Undo the temporary resurrection; can't use DECREF here, it would
3205 * cause a recursive call.
3206 */
3207 assert(self->ob_refcnt > 0);
3208 if (--self->ob_refcnt == 0)
3209 return; /* this is the normal path out */
3210
3211 /* __del__ resurrected it! Make it look like the original Py_DECREF
3212 * never happened.
3213 */
3214 {
3215 Py_ssize_t refcnt = self->ob_refcnt;
3216 _Py_NewReference(self);
3217 self->ob_refcnt = refcnt;
3218 }
3219 assert(!PyType_IS_GC(Py_TYPE(self)) ||
3220 _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED);
3221 /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
3222 * we need to undo that. */
3223 _Py_DEC_REFTOTAL;
3224 /* If Py_TRACE_REFS, _Py_NewReference re-added self to the object
3225 * chain, so no more to do there.
3226 * If COUNT_ALLOCS, the original decref bumped tp_frees, and
3227 * _Py_NewReference bumped tp_allocs: both of those need to be
3228 * undone.
3229 */
3230 #ifdef COUNT_ALLOCS
3231 --Py_TYPE(self)->tp_frees;
3232 --Py_TYPE(self)->tp_allocs;
3233 #endif
3234 }
3235
3236 static PyObject *
with_tp_del(PyObject * self,PyObject * args)3237 with_tp_del(PyObject *self, PyObject *args)
3238 {
3239 PyObject *obj;
3240 PyTypeObject *tp;
3241
3242 if (!PyArg_ParseTuple(args, "O:with_tp_del", &obj))
3243 return NULL;
3244 tp = (PyTypeObject *) obj;
3245 if (!PyType_Check(obj) || !PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE)) {
3246 PyErr_Format(PyExc_TypeError,
3247 "heap type expected, got %R", obj);
3248 return NULL;
3249 }
3250 tp->tp_del = slot_tp_del;
3251 Py_INCREF(obj);
3252 return obj;
3253 }
3254
3255 static PyMethodDef ml;
3256
3257 static PyObject *
create_cfunction(PyObject * self,PyObject * args)3258 create_cfunction(PyObject *self, PyObject *args)
3259 {
3260 return PyCFunction_NewEx(&ml, self, NULL);
3261 }
3262
3263 static PyMethodDef ml = {
3264 "create_cfunction",
3265 create_cfunction,
3266 METH_NOARGS,
3267 NULL
3268 };
3269
3270 static PyObject *
_test_incref(PyObject * ob)3271 _test_incref(PyObject *ob)
3272 {
3273 Py_INCREF(ob);
3274 return ob;
3275 }
3276
3277 static PyObject *
test_xincref_doesnt_leak(PyObject * ob)3278 test_xincref_doesnt_leak(PyObject *ob)
3279 {
3280 PyObject *obj = PyLong_FromLong(0);
3281 Py_XINCREF(_test_incref(obj));
3282 Py_DECREF(obj);
3283 Py_DECREF(obj);
3284 Py_DECREF(obj);
3285 Py_RETURN_NONE;
3286 }
3287
3288 static PyObject *
test_incref_doesnt_leak(PyObject * ob)3289 test_incref_doesnt_leak(PyObject *ob)
3290 {
3291 PyObject *obj = PyLong_FromLong(0);
3292 Py_INCREF(_test_incref(obj));
3293 Py_DECREF(obj);
3294 Py_DECREF(obj);
3295 Py_DECREF(obj);
3296 Py_RETURN_NONE;
3297 }
3298
3299 static PyObject *
test_xdecref_doesnt_leak(PyObject * ob)3300 test_xdecref_doesnt_leak(PyObject *ob)
3301 {
3302 Py_XDECREF(PyLong_FromLong(0));
3303 Py_RETURN_NONE;
3304 }
3305
3306 static PyObject *
test_decref_doesnt_leak(PyObject * ob)3307 test_decref_doesnt_leak(PyObject *ob)
3308 {
3309 Py_DECREF(PyLong_FromLong(0));
3310 Py_RETURN_NONE;
3311 }
3312
3313 static PyObject *
test_incref_decref_API(PyObject * ob)3314 test_incref_decref_API(PyObject *ob)
3315 {
3316 PyObject *obj = PyLong_FromLong(0);
3317 Py_IncRef(obj);
3318 Py_DecRef(obj);
3319 Py_DecRef(obj);
3320 Py_RETURN_NONE;
3321 }
3322
3323 static PyObject *
test_pymem_alloc0(PyObject * self)3324 test_pymem_alloc0(PyObject *self)
3325 {
3326 void *ptr;
3327
3328 ptr = PyMem_RawMalloc(0);
3329 if (ptr == NULL) {
3330 PyErr_SetString(PyExc_RuntimeError, "PyMem_RawMalloc(0) returns NULL");
3331 return NULL;
3332 }
3333 PyMem_RawFree(ptr);
3334
3335 ptr = PyMem_RawCalloc(0, 0);
3336 if (ptr == NULL) {
3337 PyErr_SetString(PyExc_RuntimeError, "PyMem_RawCalloc(0, 0) returns NULL");
3338 return NULL;
3339 }
3340 PyMem_RawFree(ptr);
3341
3342 ptr = PyMem_Malloc(0);
3343 if (ptr == NULL) {
3344 PyErr_SetString(PyExc_RuntimeError, "PyMem_Malloc(0) returns NULL");
3345 return NULL;
3346 }
3347 PyMem_Free(ptr);
3348
3349 ptr = PyMem_Calloc(0, 0);
3350 if (ptr == NULL) {
3351 PyErr_SetString(PyExc_RuntimeError, "PyMem_Calloc(0, 0) returns NULL");
3352 return NULL;
3353 }
3354 PyMem_Free(ptr);
3355
3356 ptr = PyObject_Malloc(0);
3357 if (ptr == NULL) {
3358 PyErr_SetString(PyExc_RuntimeError, "PyObject_Malloc(0) returns NULL");
3359 return NULL;
3360 }
3361 PyObject_Free(ptr);
3362
3363 ptr = PyObject_Calloc(0, 0);
3364 if (ptr == NULL) {
3365 PyErr_SetString(PyExc_RuntimeError, "PyObject_Calloc(0, 0) returns NULL");
3366 return NULL;
3367 }
3368 PyObject_Free(ptr);
3369
3370 Py_RETURN_NONE;
3371 }
3372
3373 typedef struct {
3374 PyMemAllocatorEx alloc;
3375
3376 size_t malloc_size;
3377 size_t calloc_nelem;
3378 size_t calloc_elsize;
3379 void *realloc_ptr;
3380 size_t realloc_new_size;
3381 void *free_ptr;
3382 void *ctx;
3383 } alloc_hook_t;
3384
hook_malloc(void * ctx,size_t size)3385 static void* hook_malloc(void* ctx, size_t size)
3386 {
3387 alloc_hook_t *hook = (alloc_hook_t *)ctx;
3388 hook->ctx = ctx;
3389 hook->malloc_size = size;
3390 return hook->alloc.malloc(hook->alloc.ctx, size);
3391 }
3392
hook_calloc(void * ctx,size_t nelem,size_t elsize)3393 static void* hook_calloc(void* ctx, size_t nelem, size_t elsize)
3394 {
3395 alloc_hook_t *hook = (alloc_hook_t *)ctx;
3396 hook->ctx = ctx;
3397 hook->calloc_nelem = nelem;
3398 hook->calloc_elsize = elsize;
3399 return hook->alloc.calloc(hook->alloc.ctx, nelem, elsize);
3400 }
3401
hook_realloc(void * ctx,void * ptr,size_t new_size)3402 static void* hook_realloc(void* ctx, void* ptr, size_t new_size)
3403 {
3404 alloc_hook_t *hook = (alloc_hook_t *)ctx;
3405 hook->ctx = ctx;
3406 hook->realloc_ptr = ptr;
3407 hook->realloc_new_size = new_size;
3408 return hook->alloc.realloc(hook->alloc.ctx, ptr, new_size);
3409 }
3410
hook_free(void * ctx,void * ptr)3411 static void hook_free(void *ctx, void *ptr)
3412 {
3413 alloc_hook_t *hook = (alloc_hook_t *)ctx;
3414 hook->ctx = ctx;
3415 hook->free_ptr = ptr;
3416 hook->alloc.free(hook->alloc.ctx, ptr);
3417 }
3418
3419 static PyObject *
test_setallocators(PyMemAllocatorDomain domain)3420 test_setallocators(PyMemAllocatorDomain domain)
3421 {
3422 PyObject *res = NULL;
3423 const char *error_msg;
3424 alloc_hook_t hook;
3425 PyMemAllocatorEx alloc;
3426 size_t size, size2, nelem, elsize;
3427 void *ptr, *ptr2;
3428
3429 memset(&hook, 0, sizeof(hook));
3430
3431 alloc.ctx = &hook;
3432 alloc.malloc = &hook_malloc;
3433 alloc.calloc = &hook_calloc;
3434 alloc.realloc = &hook_realloc;
3435 alloc.free = &hook_free;
3436 PyMem_GetAllocator(domain, &hook.alloc);
3437 PyMem_SetAllocator(domain, &alloc);
3438
3439 /* malloc, realloc, free */
3440 size = 42;
3441 hook.ctx = NULL;
3442 switch(domain)
3443 {
3444 case PYMEM_DOMAIN_RAW: ptr = PyMem_RawMalloc(size); break;
3445 case PYMEM_DOMAIN_MEM: ptr = PyMem_Malloc(size); break;
3446 case PYMEM_DOMAIN_OBJ: ptr = PyObject_Malloc(size); break;
3447 default: ptr = NULL; break;
3448 }
3449
3450 #define CHECK_CTX(FUNC) \
3451 if (hook.ctx != &hook) { \
3452 error_msg = FUNC " wrong context"; \
3453 goto fail; \
3454 } \
3455 hook.ctx = NULL; /* reset for next check */
3456
3457 if (ptr == NULL) {
3458 error_msg = "malloc failed";
3459 goto fail;
3460 }
3461 CHECK_CTX("malloc");
3462 if (hook.malloc_size != size) {
3463 error_msg = "malloc invalid size";
3464 goto fail;
3465 }
3466
3467 size2 = 200;
3468 switch(domain)
3469 {
3470 case PYMEM_DOMAIN_RAW: ptr2 = PyMem_RawRealloc(ptr, size2); break;
3471 case PYMEM_DOMAIN_MEM: ptr2 = PyMem_Realloc(ptr, size2); break;
3472 case PYMEM_DOMAIN_OBJ: ptr2 = PyObject_Realloc(ptr, size2); break;
3473 default: ptr2 = NULL; break;
3474 }
3475
3476 if (ptr2 == NULL) {
3477 error_msg = "realloc failed";
3478 goto fail;
3479 }
3480 CHECK_CTX("realloc");
3481 if (hook.realloc_ptr != ptr
3482 || hook.realloc_new_size != size2) {
3483 error_msg = "realloc invalid parameters";
3484 goto fail;
3485 }
3486
3487 switch(domain)
3488 {
3489 case PYMEM_DOMAIN_RAW: PyMem_RawFree(ptr2); break;
3490 case PYMEM_DOMAIN_MEM: PyMem_Free(ptr2); break;
3491 case PYMEM_DOMAIN_OBJ: PyObject_Free(ptr2); break;
3492 }
3493
3494 CHECK_CTX("free");
3495 if (hook.free_ptr != ptr2) {
3496 error_msg = "free invalid pointer";
3497 goto fail;
3498 }
3499
3500 /* calloc, free */
3501 nelem = 2;
3502 elsize = 5;
3503 switch(domain)
3504 {
3505 case PYMEM_DOMAIN_RAW: ptr = PyMem_RawCalloc(nelem, elsize); break;
3506 case PYMEM_DOMAIN_MEM: ptr = PyMem_Calloc(nelem, elsize); break;
3507 case PYMEM_DOMAIN_OBJ: ptr = PyObject_Calloc(nelem, elsize); break;
3508 default: ptr = NULL; break;
3509 }
3510
3511 if (ptr == NULL) {
3512 error_msg = "calloc failed";
3513 goto fail;
3514 }
3515 CHECK_CTX("calloc");
3516 if (hook.calloc_nelem != nelem || hook.calloc_elsize != elsize) {
3517 error_msg = "calloc invalid nelem or elsize";
3518 goto fail;
3519 }
3520
3521 hook.free_ptr = NULL;
3522 switch(domain)
3523 {
3524 case PYMEM_DOMAIN_RAW: PyMem_RawFree(ptr); break;
3525 case PYMEM_DOMAIN_MEM: PyMem_Free(ptr); break;
3526 case PYMEM_DOMAIN_OBJ: PyObject_Free(ptr); break;
3527 }
3528
3529 CHECK_CTX("calloc free");
3530 if (hook.free_ptr != ptr) {
3531 error_msg = "calloc free invalid pointer";
3532 goto fail;
3533 }
3534
3535 Py_INCREF(Py_None);
3536 res = Py_None;
3537 goto finally;
3538
3539 fail:
3540 PyErr_SetString(PyExc_RuntimeError, error_msg);
3541
3542 finally:
3543 PyMem_SetAllocator(domain, &hook.alloc);
3544 return res;
3545
3546 #undef CHECK_CTX
3547 }
3548
3549 static PyObject *
test_pymem_setrawallocators(PyObject * self)3550 test_pymem_setrawallocators(PyObject *self)
3551 {
3552 return test_setallocators(PYMEM_DOMAIN_RAW);
3553 }
3554
3555 static PyObject *
test_pymem_setallocators(PyObject * self)3556 test_pymem_setallocators(PyObject *self)
3557 {
3558 return test_setallocators(PYMEM_DOMAIN_MEM);
3559 }
3560
3561 static PyObject *
test_pyobject_setallocators(PyObject * self)3562 test_pyobject_setallocators(PyObject *self)
3563 {
3564 return test_setallocators(PYMEM_DOMAIN_OBJ);
3565 }
3566
3567 /* Most part of the following code is inherited from the pyfailmalloc project
3568 * written by Victor Stinner. */
3569 static struct {
3570 int installed;
3571 PyMemAllocatorEx raw;
3572 PyMemAllocatorEx mem;
3573 PyMemAllocatorEx obj;
3574 } FmHook;
3575
3576 static struct {
3577 int start;
3578 int stop;
3579 Py_ssize_t count;
3580 } FmData;
3581
3582 static int
fm_nomemory(void)3583 fm_nomemory(void)
3584 {
3585 FmData.count++;
3586 if (FmData.count > FmData.start &&
3587 (FmData.stop <= 0 || FmData.count <= FmData.stop)) {
3588 return 1;
3589 }
3590 return 0;
3591 }
3592
3593 static void *
hook_fmalloc(void * ctx,size_t size)3594 hook_fmalloc(void *ctx, size_t size)
3595 {
3596 PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
3597 if (fm_nomemory()) {
3598 return NULL;
3599 }
3600 return alloc->malloc(alloc->ctx, size);
3601 }
3602
3603 static void *
hook_fcalloc(void * ctx,size_t nelem,size_t elsize)3604 hook_fcalloc(void *ctx, size_t nelem, size_t elsize)
3605 {
3606 PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
3607 if (fm_nomemory()) {
3608 return NULL;
3609 }
3610 return alloc->calloc(alloc->ctx, nelem, elsize);
3611 }
3612
3613 static void *
hook_frealloc(void * ctx,void * ptr,size_t new_size)3614 hook_frealloc(void *ctx, void *ptr, size_t new_size)
3615 {
3616 PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
3617 if (fm_nomemory()) {
3618 return NULL;
3619 }
3620 return alloc->realloc(alloc->ctx, ptr, new_size);
3621 }
3622
3623 static void
hook_ffree(void * ctx,void * ptr)3624 hook_ffree(void *ctx, void *ptr)
3625 {
3626 PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
3627 alloc->free(alloc->ctx, ptr);
3628 }
3629
3630 static void
fm_setup_hooks(void)3631 fm_setup_hooks(void)
3632 {
3633 PyMemAllocatorEx alloc;
3634
3635 if (FmHook.installed) {
3636 return;
3637 }
3638 FmHook.installed = 1;
3639
3640 alloc.malloc = hook_fmalloc;
3641 alloc.calloc = hook_fcalloc;
3642 alloc.realloc = hook_frealloc;
3643 alloc.free = hook_ffree;
3644 PyMem_GetAllocator(PYMEM_DOMAIN_RAW, &FmHook.raw);
3645 PyMem_GetAllocator(PYMEM_DOMAIN_MEM, &FmHook.mem);
3646 PyMem_GetAllocator(PYMEM_DOMAIN_OBJ, &FmHook.obj);
3647
3648 alloc.ctx = &FmHook.raw;
3649 PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &alloc);
3650
3651 alloc.ctx = &FmHook.mem;
3652 PyMem_SetAllocator(PYMEM_DOMAIN_MEM, &alloc);
3653
3654 alloc.ctx = &FmHook.obj;
3655 PyMem_SetAllocator(PYMEM_DOMAIN_OBJ, &alloc);
3656 }
3657
3658 static void
fm_remove_hooks(void)3659 fm_remove_hooks(void)
3660 {
3661 if (FmHook.installed) {
3662 FmHook.installed = 0;
3663 PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &FmHook.raw);
3664 PyMem_SetAllocator(PYMEM_DOMAIN_MEM, &FmHook.mem);
3665 PyMem_SetAllocator(PYMEM_DOMAIN_OBJ, &FmHook.obj);
3666 }
3667 }
3668
3669 static PyObject*
set_nomemory(PyObject * self,PyObject * args)3670 set_nomemory(PyObject *self, PyObject *args)
3671 {
3672 /* Memory allocation fails after 'start' allocation requests, and until
3673 * 'stop' allocation requests except when 'stop' is negative or equal
3674 * to 0 (default) in which case allocation failures never stop. */
3675 FmData.count = 0;
3676 FmData.stop = 0;
3677 if (!PyArg_ParseTuple(args, "i|i", &FmData.start, &FmData.stop)) {
3678 return NULL;
3679 }
3680 fm_setup_hooks();
3681 Py_RETURN_NONE;
3682 }
3683
3684 static PyObject*
remove_mem_hooks(PyObject * self)3685 remove_mem_hooks(PyObject *self)
3686 {
3687 fm_remove_hooks();
3688 Py_RETURN_NONE;
3689 }
3690
3691 PyDoc_STRVAR(docstring_empty,
3692 ""
3693 );
3694
3695 PyDoc_STRVAR(docstring_no_signature,
3696 "This docstring has no signature."
3697 );
3698
3699 PyDoc_STRVAR(docstring_with_invalid_signature,
3700 "docstring_with_invalid_signature($module, /, boo)\n"
3701 "\n"
3702 "This docstring has an invalid signature."
3703 );
3704
3705 PyDoc_STRVAR(docstring_with_invalid_signature2,
3706 "docstring_with_invalid_signature2($module, /, boo)\n"
3707 "\n"
3708 "--\n"
3709 "\n"
3710 "This docstring also has an invalid signature."
3711 );
3712
3713 PyDoc_STRVAR(docstring_with_signature,
3714 "docstring_with_signature($module, /, sig)\n"
3715 "--\n"
3716 "\n"
3717 "This docstring has a valid signature."
3718 );
3719
3720 PyDoc_STRVAR(docstring_with_signature_but_no_doc,
3721 "docstring_with_signature_but_no_doc($module, /, sig)\n"
3722 "--\n"
3723 "\n"
3724 );
3725
3726 PyDoc_STRVAR(docstring_with_signature_and_extra_newlines,
3727 "docstring_with_signature_and_extra_newlines($module, /, parameter)\n"
3728 "--\n"
3729 "\n"
3730 "\n"
3731 "This docstring has a valid signature and some extra newlines."
3732 );
3733
3734 PyDoc_STRVAR(docstring_with_signature_with_defaults,
3735 "docstring_with_signature_with_defaults(module, s='avocado',\n"
3736 " b=b'bytes', d=3.14, i=35, n=None, t=True, f=False,\n"
3737 " local=the_number_three, sys=sys.maxsize,\n"
3738 " exp=sys.maxsize - 1)\n"
3739 "--\n"
3740 "\n"
3741 "\n"
3742 "\n"
3743 "This docstring has a valid signature with parameters,\n"
3744 "and the parameters take defaults of varying types."
3745 );
3746
3747 typedef struct {
3748 PyThread_type_lock start_event;
3749 PyThread_type_lock exit_event;
3750 PyObject *callback;
3751 } test_c_thread_t;
3752
3753 static void
temporary_c_thread(void * data)3754 temporary_c_thread(void *data)
3755 {
3756 test_c_thread_t *test_c_thread = data;
3757 PyGILState_STATE state;
3758 PyObject *res;
3759
3760 PyThread_release_lock(test_c_thread->start_event);
3761
3762 /* Allocate a Python thread state for this thread */
3763 state = PyGILState_Ensure();
3764
3765 res = _PyObject_CallNoArg(test_c_thread->callback);
3766 Py_CLEAR(test_c_thread->callback);
3767
3768 if (res == NULL) {
3769 PyErr_Print();
3770 }
3771 else {
3772 Py_DECREF(res);
3773 }
3774
3775 /* Destroy the Python thread state for this thread */
3776 PyGILState_Release(state);
3777
3778 PyThread_release_lock(test_c_thread->exit_event);
3779
3780 PyThread_exit_thread();
3781 }
3782
3783 static PyObject *
call_in_temporary_c_thread(PyObject * self,PyObject * callback)3784 call_in_temporary_c_thread(PyObject *self, PyObject *callback)
3785 {
3786 PyObject *res = NULL;
3787 test_c_thread_t test_c_thread;
3788 long thread;
3789
3790 PyEval_InitThreads();
3791
3792 test_c_thread.start_event = PyThread_allocate_lock();
3793 test_c_thread.exit_event = PyThread_allocate_lock();
3794 test_c_thread.callback = NULL;
3795 if (!test_c_thread.start_event || !test_c_thread.exit_event) {
3796 PyErr_SetString(PyExc_RuntimeError, "could not allocate lock");
3797 goto exit;
3798 }
3799
3800 Py_INCREF(callback);
3801 test_c_thread.callback = callback;
3802
3803 PyThread_acquire_lock(test_c_thread.start_event, 1);
3804 PyThread_acquire_lock(test_c_thread.exit_event, 1);
3805
3806 thread = PyThread_start_new_thread(temporary_c_thread, &test_c_thread);
3807 if (thread == -1) {
3808 PyErr_SetString(PyExc_RuntimeError, "unable to start the thread");
3809 PyThread_release_lock(test_c_thread.start_event);
3810 PyThread_release_lock(test_c_thread.exit_event);
3811 goto exit;
3812 }
3813
3814 PyThread_acquire_lock(test_c_thread.start_event, 1);
3815 PyThread_release_lock(test_c_thread.start_event);
3816
3817 Py_BEGIN_ALLOW_THREADS
3818 PyThread_acquire_lock(test_c_thread.exit_event, 1);
3819 PyThread_release_lock(test_c_thread.exit_event);
3820 Py_END_ALLOW_THREADS
3821
3822 Py_INCREF(Py_None);
3823 res = Py_None;
3824
3825 exit:
3826 Py_CLEAR(test_c_thread.callback);
3827 if (test_c_thread.start_event)
3828 PyThread_free_lock(test_c_thread.start_event);
3829 if (test_c_thread.exit_event)
3830 PyThread_free_lock(test_c_thread.exit_event);
3831 return res;
3832 }
3833
3834 static PyObject*
test_raise_signal(PyObject * self,PyObject * args)3835 test_raise_signal(PyObject* self, PyObject *args)
3836 {
3837 int signum, err;
3838
3839 if (!PyArg_ParseTuple(args, "i:raise_signal", &signum)) {
3840 return NULL;
3841 }
3842
3843 err = raise(signum);
3844 if (err)
3845 return PyErr_SetFromErrno(PyExc_OSError);
3846
3847 if (PyErr_CheckSignals() < 0)
3848 return NULL;
3849
3850 Py_RETURN_NONE;
3851 }
3852
3853 /* marshal */
3854
3855 static PyObject*
pymarshal_write_long_to_file(PyObject * self,PyObject * args)3856 pymarshal_write_long_to_file(PyObject* self, PyObject *args)
3857 {
3858 long value;
3859 char *filename;
3860 int version;
3861 FILE *fp;
3862
3863 if (!PyArg_ParseTuple(args, "lsi:pymarshal_write_long_to_file",
3864 &value, &filename, &version))
3865 return NULL;
3866
3867 fp = fopen(filename, "wb");
3868 if (fp == NULL) {
3869 PyErr_SetFromErrno(PyExc_OSError);
3870 return NULL;
3871 }
3872
3873 PyMarshal_WriteLongToFile(value, fp, version);
3874
3875 fclose(fp);
3876 if (PyErr_Occurred())
3877 return NULL;
3878 Py_RETURN_NONE;
3879 }
3880
3881 static PyObject*
pymarshal_write_object_to_file(PyObject * self,PyObject * args)3882 pymarshal_write_object_to_file(PyObject* self, PyObject *args)
3883 {
3884 PyObject *obj;
3885 char *filename;
3886 int version;
3887 FILE *fp;
3888
3889 if (!PyArg_ParseTuple(args, "Osi:pymarshal_write_object_to_file",
3890 &obj, &filename, &version))
3891 return NULL;
3892
3893 fp = fopen(filename, "wb");
3894 if (fp == NULL) {
3895 PyErr_SetFromErrno(PyExc_OSError);
3896 return NULL;
3897 }
3898
3899 PyMarshal_WriteObjectToFile(obj, fp, version);
3900
3901 fclose(fp);
3902 if (PyErr_Occurred())
3903 return NULL;
3904 Py_RETURN_NONE;
3905 }
3906
3907 static PyObject*
pymarshal_read_short_from_file(PyObject * self,PyObject * args)3908 pymarshal_read_short_from_file(PyObject* self, PyObject *args)
3909 {
3910 int value;
3911 long pos;
3912 char *filename;
3913 FILE *fp;
3914
3915 if (!PyArg_ParseTuple(args, "s:pymarshal_read_short_from_file", &filename))
3916 return NULL;
3917
3918 fp = fopen(filename, "rb");
3919 if (fp == NULL) {
3920 PyErr_SetFromErrno(PyExc_OSError);
3921 return NULL;
3922 }
3923
3924 value = PyMarshal_ReadShortFromFile(fp);
3925 pos = ftell(fp);
3926
3927 fclose(fp);
3928 if (PyErr_Occurred())
3929 return NULL;
3930 return Py_BuildValue("il", value, pos);
3931 }
3932
3933 static PyObject*
pymarshal_read_long_from_file(PyObject * self,PyObject * args)3934 pymarshal_read_long_from_file(PyObject* self, PyObject *args)
3935 {
3936 long value, pos;
3937 char *filename;
3938 FILE *fp;
3939
3940 if (!PyArg_ParseTuple(args, "s:pymarshal_read_long_from_file", &filename))
3941 return NULL;
3942
3943 fp = fopen(filename, "rb");
3944 if (fp == NULL) {
3945 PyErr_SetFromErrno(PyExc_OSError);
3946 return NULL;
3947 }
3948
3949 value = PyMarshal_ReadLongFromFile(fp);
3950 pos = ftell(fp);
3951
3952 fclose(fp);
3953 if (PyErr_Occurred())
3954 return NULL;
3955 return Py_BuildValue("ll", value, pos);
3956 }
3957
3958 static PyObject*
pymarshal_read_last_object_from_file(PyObject * self,PyObject * args)3959 pymarshal_read_last_object_from_file(PyObject* self, PyObject *args)
3960 {
3961 PyObject *obj;
3962 long pos;
3963 char *filename;
3964 FILE *fp;
3965
3966 if (!PyArg_ParseTuple(args, "s:pymarshal_read_last_object_from_file", &filename))
3967 return NULL;
3968
3969 fp = fopen(filename, "rb");
3970 if (fp == NULL) {
3971 PyErr_SetFromErrno(PyExc_OSError);
3972 return NULL;
3973 }
3974
3975 obj = PyMarshal_ReadLastObjectFromFile(fp);
3976 pos = ftell(fp);
3977
3978 fclose(fp);
3979 return Py_BuildValue("Nl", obj, pos);
3980 }
3981
3982 static PyObject*
pymarshal_read_object_from_file(PyObject * self,PyObject * args)3983 pymarshal_read_object_from_file(PyObject* self, PyObject *args)
3984 {
3985 PyObject *obj;
3986 long pos;
3987 char *filename;
3988 FILE *fp;
3989
3990 if (!PyArg_ParseTuple(args, "s:pymarshal_read_object_from_file", &filename))
3991 return NULL;
3992
3993 fp = fopen(filename, "rb");
3994 if (fp == NULL) {
3995 PyErr_SetFromErrno(PyExc_OSError);
3996 return NULL;
3997 }
3998
3999 obj = PyMarshal_ReadObjectFromFile(fp);
4000 pos = ftell(fp);
4001
4002 fclose(fp);
4003 return Py_BuildValue("Nl", obj, pos);
4004 }
4005
4006 static PyObject*
return_null_without_error(PyObject * self,PyObject * args)4007 return_null_without_error(PyObject *self, PyObject *args)
4008 {
4009 /* invalid call: return NULL without setting an error,
4010 * _Py_CheckFunctionResult() must detect such bug at runtime. */
4011 PyErr_Clear();
4012 return NULL;
4013 }
4014
4015 static PyObject*
return_result_with_error(PyObject * self,PyObject * args)4016 return_result_with_error(PyObject *self, PyObject *args)
4017 {
4018 /* invalid call: return a result with an error set,
4019 * _Py_CheckFunctionResult() must detect such bug at runtime. */
4020 PyErr_SetNone(PyExc_ValueError);
4021 Py_RETURN_NONE;
4022 }
4023
4024 static PyObject *
test_pytime_fromseconds(PyObject * self,PyObject * args)4025 test_pytime_fromseconds(PyObject *self, PyObject *args)
4026 {
4027 int seconds;
4028 _PyTime_t ts;
4029
4030 if (!PyArg_ParseTuple(args, "i", &seconds))
4031 return NULL;
4032 ts = _PyTime_FromSeconds(seconds);
4033 return _PyTime_AsNanosecondsObject(ts);
4034 }
4035
4036 static PyObject *
test_pytime_fromsecondsobject(PyObject * self,PyObject * args)4037 test_pytime_fromsecondsobject(PyObject *self, PyObject *args)
4038 {
4039 PyObject *obj;
4040 int round;
4041 _PyTime_t ts;
4042
4043 if (!PyArg_ParseTuple(args, "Oi", &obj, &round))
4044 return NULL;
4045 if (check_time_rounding(round) < 0)
4046 return NULL;
4047 if (_PyTime_FromSecondsObject(&ts, obj, round) == -1)
4048 return NULL;
4049 return _PyTime_AsNanosecondsObject(ts);
4050 }
4051
4052 static PyObject *
test_pytime_assecondsdouble(PyObject * self,PyObject * args)4053 test_pytime_assecondsdouble(PyObject *self, PyObject *args)
4054 {
4055 PyObject *obj;
4056 _PyTime_t ts;
4057 double d;
4058
4059 if (!PyArg_ParseTuple(args, "O", &obj)) {
4060 return NULL;
4061 }
4062 if (_PyTime_FromNanosecondsObject(&ts, obj) < 0) {
4063 return NULL;
4064 }
4065 d = _PyTime_AsSecondsDouble(ts);
4066 return PyFloat_FromDouble(d);
4067 }
4068
4069 static PyObject *
test_PyTime_AsTimeval(PyObject * self,PyObject * args)4070 test_PyTime_AsTimeval(PyObject *self, PyObject *args)
4071 {
4072 PyObject *obj;
4073 int round;
4074 _PyTime_t t;
4075 struct timeval tv;
4076 PyObject *seconds;
4077
4078 if (!PyArg_ParseTuple(args, "Oi", &obj, &round))
4079 return NULL;
4080 if (check_time_rounding(round) < 0) {
4081 return NULL;
4082 }
4083 if (_PyTime_FromNanosecondsObject(&t, obj) < 0) {
4084 return NULL;
4085 }
4086 if (_PyTime_AsTimeval(t, &tv, round) < 0) {
4087 return NULL;
4088 }
4089
4090 seconds = PyLong_FromLongLong(tv.tv_sec);
4091 if (seconds == NULL) {
4092 return NULL;
4093 }
4094 return Py_BuildValue("Nl", seconds, tv.tv_usec);
4095 }
4096
4097 #ifdef HAVE_CLOCK_GETTIME
4098 static PyObject *
test_PyTime_AsTimespec(PyObject * self,PyObject * args)4099 test_PyTime_AsTimespec(PyObject *self, PyObject *args)
4100 {
4101 PyObject *obj;
4102 _PyTime_t t;
4103 struct timespec ts;
4104
4105 if (!PyArg_ParseTuple(args, "O", &obj)) {
4106 return NULL;
4107 }
4108 if (_PyTime_FromNanosecondsObject(&t, obj) < 0) {
4109 return NULL;
4110 }
4111 if (_PyTime_AsTimespec(t, &ts) == -1) {
4112 return NULL;
4113 }
4114 return Py_BuildValue("Nl", _PyLong_FromTime_t(ts.tv_sec), ts.tv_nsec);
4115 }
4116 #endif
4117
4118 static PyObject *
test_PyTime_AsMilliseconds(PyObject * self,PyObject * args)4119 test_PyTime_AsMilliseconds(PyObject *self, PyObject *args)
4120 {
4121 PyObject *obj;
4122 int round;
4123 _PyTime_t t, ms;
4124
4125 if (!PyArg_ParseTuple(args, "Oi", &obj, &round)) {
4126 return NULL;
4127 }
4128 if (_PyTime_FromNanosecondsObject(&t, obj) < 0) {
4129 return NULL;
4130 }
4131 if (check_time_rounding(round) < 0) {
4132 return NULL;
4133 }
4134 ms = _PyTime_AsMilliseconds(t, round);
4135 /* This conversion rely on the fact that _PyTime_t is a number of
4136 nanoseconds */
4137 return _PyTime_AsNanosecondsObject(ms);
4138 }
4139
4140 static PyObject *
test_PyTime_AsMicroseconds(PyObject * self,PyObject * args)4141 test_PyTime_AsMicroseconds(PyObject *self, PyObject *args)
4142 {
4143 PyObject *obj;
4144 int round;
4145 _PyTime_t t, ms;
4146
4147 if (!PyArg_ParseTuple(args, "Oi", &obj, &round))
4148 return NULL;
4149 if (_PyTime_FromNanosecondsObject(&t, obj) < 0) {
4150 return NULL;
4151 }
4152 if (check_time_rounding(round) < 0) {
4153 return NULL;
4154 }
4155 ms = _PyTime_AsMicroseconds(t, round);
4156 /* This conversion rely on the fact that _PyTime_t is a number of
4157 nanoseconds */
4158 return _PyTime_AsNanosecondsObject(ms);
4159 }
4160
4161 static PyObject*
get_recursion_depth(PyObject * self,PyObject * args)4162 get_recursion_depth(PyObject *self, PyObject *args)
4163 {
4164 PyThreadState *tstate = PyThreadState_GET();
4165
4166 /* subtract one to ignore the frame of the get_recursion_depth() call */
4167 return PyLong_FromLong(tstate->recursion_depth - 1);
4168 }
4169
4170 static PyObject*
pymem_buffer_overflow(PyObject * self,PyObject * args)4171 pymem_buffer_overflow(PyObject *self, PyObject *args)
4172 {
4173 char *buffer;
4174
4175 /* Deliberate buffer overflow to check that PyMem_Free() detects
4176 the overflow when debug hooks are installed. */
4177 buffer = PyMem_Malloc(16);
4178 buffer[16] = 'x';
4179 PyMem_Free(buffer);
4180
4181 Py_RETURN_NONE;
4182 }
4183
4184 static PyObject*
pymem_api_misuse(PyObject * self,PyObject * args)4185 pymem_api_misuse(PyObject *self, PyObject *args)
4186 {
4187 char *buffer;
4188
4189 /* Deliberate misusage of Python allocators:
4190 allococate with PyMem but release with PyMem_Raw. */
4191 buffer = PyMem_Malloc(16);
4192 PyMem_RawFree(buffer);
4193
4194 Py_RETURN_NONE;
4195 }
4196
4197 static PyObject*
pymem_malloc_without_gil(PyObject * self,PyObject * args)4198 pymem_malloc_without_gil(PyObject *self, PyObject *args)
4199 {
4200 char *buffer;
4201
4202 /* Deliberate bug to test debug hooks on Python memory allocators:
4203 call PyMem_Malloc() without holding the GIL */
4204 Py_BEGIN_ALLOW_THREADS
4205 buffer = PyMem_Malloc(10);
4206 Py_END_ALLOW_THREADS
4207
4208 PyMem_Free(buffer);
4209
4210 Py_RETURN_NONE;
4211 }
4212
4213
4214 static PyObject*
test_pymem_getallocatorsname(PyObject * self,PyObject * args)4215 test_pymem_getallocatorsname(PyObject *self, PyObject *args)
4216 {
4217 const char *name = _PyMem_GetAllocatorsName();
4218 if (name == NULL) {
4219 PyErr_SetString(PyExc_RuntimeError, "cannot get allocators name");
4220 return NULL;
4221 }
4222 return PyUnicode_FromString(name);
4223 }
4224
4225
4226 static PyObject*
pyobject_malloc_without_gil(PyObject * self,PyObject * args)4227 pyobject_malloc_without_gil(PyObject *self, PyObject *args)
4228 {
4229 char *buffer;
4230
4231 /* Deliberate bug to test debug hooks on Python memory allocators:
4232 call PyObject_Malloc() without holding the GIL */
4233 Py_BEGIN_ALLOW_THREADS
4234 buffer = PyObject_Malloc(10);
4235 Py_END_ALLOW_THREADS
4236
4237 PyObject_Free(buffer);
4238
4239 Py_RETURN_NONE;
4240 }
4241
4242 static PyObject *
tracemalloc_track(PyObject * self,PyObject * args)4243 tracemalloc_track(PyObject *self, PyObject *args)
4244 {
4245 unsigned int domain;
4246 PyObject *ptr_obj;
4247 void *ptr;
4248 Py_ssize_t size;
4249 int release_gil = 0;
4250 int res;
4251
4252 if (!PyArg_ParseTuple(args, "IOn|i", &domain, &ptr_obj, &size, &release_gil))
4253 return NULL;
4254 ptr = PyLong_AsVoidPtr(ptr_obj);
4255 if (PyErr_Occurred())
4256 return NULL;
4257
4258 if (release_gil) {
4259 Py_BEGIN_ALLOW_THREADS
4260 res = PyTraceMalloc_Track(domain, (uintptr_t)ptr, size);
4261 Py_END_ALLOW_THREADS
4262 }
4263 else {
4264 res = PyTraceMalloc_Track(domain, (uintptr_t)ptr, size);
4265 }
4266
4267 if (res < 0) {
4268 PyErr_SetString(PyExc_RuntimeError, "PyTraceMalloc_Track error");
4269 return NULL;
4270 }
4271
4272 Py_RETURN_NONE;
4273 }
4274
4275 static PyObject *
tracemalloc_untrack(PyObject * self,PyObject * args)4276 tracemalloc_untrack(PyObject *self, PyObject *args)
4277 {
4278 unsigned int domain;
4279 PyObject *ptr_obj;
4280 void *ptr;
4281 int res;
4282
4283 if (!PyArg_ParseTuple(args, "IO", &domain, &ptr_obj))
4284 return NULL;
4285 ptr = PyLong_AsVoidPtr(ptr_obj);
4286 if (PyErr_Occurred())
4287 return NULL;
4288
4289 res = PyTraceMalloc_Untrack(domain, (uintptr_t)ptr);
4290 if (res < 0) {
4291 PyErr_SetString(PyExc_RuntimeError, "PyTraceMalloc_Untrack error");
4292 return NULL;
4293 }
4294
4295 Py_RETURN_NONE;
4296 }
4297
4298 static PyObject *
tracemalloc_get_traceback(PyObject * self,PyObject * args)4299 tracemalloc_get_traceback(PyObject *self, PyObject *args)
4300 {
4301 unsigned int domain;
4302 PyObject *ptr_obj;
4303 void *ptr;
4304
4305 if (!PyArg_ParseTuple(args, "IO", &domain, &ptr_obj))
4306 return NULL;
4307 ptr = PyLong_AsVoidPtr(ptr_obj);
4308 if (PyErr_Occurred())
4309 return NULL;
4310
4311 return _PyTraceMalloc_GetTraceback(domain, (uintptr_t)ptr);
4312 }
4313
4314 static PyObject *
dict_get_version(PyObject * self,PyObject * args)4315 dict_get_version(PyObject *self, PyObject *args)
4316 {
4317 PyDictObject *dict;
4318 uint64_t version;
4319
4320 if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &dict))
4321 return NULL;
4322
4323 version = dict->ma_version_tag;
4324
4325 Py_BUILD_ASSERT(sizeof(unsigned PY_LONG_LONG) >= sizeof(version));
4326 return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)version);
4327 }
4328
4329
4330 static PyObject *
raise_SIGINT_then_send_None(PyObject * self,PyObject * args)4331 raise_SIGINT_then_send_None(PyObject *self, PyObject *args)
4332 {
4333 PyGenObject *gen;
4334
4335 if (!PyArg_ParseTuple(args, "O!", &PyGen_Type, &gen))
4336 return NULL;
4337
4338 /* This is used in a test to check what happens if a signal arrives just
4339 as we're in the process of entering a yield from chain (see
4340 bpo-30039).
4341
4342 Needs to be done in C, because:
4343 - we don't have a Python wrapper for raise()
4344 - we need to make sure that the Python-level signal handler doesn't run
4345 *before* we enter the generator frame, which is impossible in Python
4346 because we check for signals before every bytecode operation.
4347 */
4348 raise(SIGINT);
4349 return _PyGen_Send(gen, Py_None);
4350 }
4351
4352
4353 static int
fastcall_args(PyObject * args,PyObject *** stack,Py_ssize_t * nargs)4354 fastcall_args(PyObject *args, PyObject ***stack, Py_ssize_t *nargs)
4355 {
4356 if (args == Py_None) {
4357 *stack = NULL;
4358 *nargs = 0;
4359 }
4360 else if (PyTuple_Check(args)) {
4361 *stack = &PyTuple_GET_ITEM(args, 0);
4362 *nargs = PyTuple_GET_SIZE(args);
4363 }
4364 else {
4365 PyErr_SetString(PyExc_TypeError, "args must be None or a tuple");
4366 return -1;
4367 }
4368 return 0;
4369 }
4370
4371
4372 static PyObject *
test_pyobject_fastcall(PyObject * self,PyObject * args)4373 test_pyobject_fastcall(PyObject *self, PyObject *args)
4374 {
4375 PyObject *func, *func_args;
4376 PyObject **stack;
4377 Py_ssize_t nargs;
4378
4379 if (!PyArg_ParseTuple(args, "OO", &func, &func_args)) {
4380 return NULL;
4381 }
4382
4383 if (fastcall_args(func_args, &stack, &nargs) < 0) {
4384 return NULL;
4385 }
4386 return _PyObject_FastCall(func, stack, nargs);
4387 }
4388
4389
4390 static PyObject *
test_pyobject_fastcalldict(PyObject * self,PyObject * args)4391 test_pyobject_fastcalldict(PyObject *self, PyObject *args)
4392 {
4393 PyObject *func, *func_args, *kwargs;
4394 PyObject **stack;
4395 Py_ssize_t nargs;
4396
4397 if (!PyArg_ParseTuple(args, "OOO", &func, &func_args, &kwargs)) {
4398 return NULL;
4399 }
4400
4401 if (fastcall_args(func_args, &stack, &nargs) < 0) {
4402 return NULL;
4403 }
4404
4405 if (kwargs == Py_None) {
4406 kwargs = NULL;
4407 }
4408 else if (!PyDict_Check(kwargs)) {
4409 PyErr_SetString(PyExc_TypeError, "kwnames must be None or a dict");
4410 return NULL;
4411 }
4412
4413 return _PyObject_FastCallDict(func, stack, nargs, kwargs);
4414 }
4415
4416
4417 static PyObject *
test_pyobject_fastcallkeywords(PyObject * self,PyObject * args)4418 test_pyobject_fastcallkeywords(PyObject *self, PyObject *args)
4419 {
4420 PyObject *func, *func_args, *kwnames = NULL;
4421 PyObject **stack;
4422 Py_ssize_t nargs, nkw;
4423
4424 if (!PyArg_ParseTuple(args, "OOO", &func, &func_args, &kwnames)) {
4425 return NULL;
4426 }
4427
4428 if (fastcall_args(func_args, &stack, &nargs) < 0) {
4429 return NULL;
4430 }
4431
4432 if (kwnames == Py_None) {
4433 kwnames = NULL;
4434 }
4435 else if (PyTuple_Check(kwnames)) {
4436 nkw = PyTuple_GET_SIZE(kwnames);
4437 if (nargs < nkw) {
4438 PyErr_SetString(PyExc_ValueError, "kwnames longer than args");
4439 return NULL;
4440 }
4441 nargs -= nkw;
4442 }
4443 else {
4444 PyErr_SetString(PyExc_TypeError, "kwnames must be None or a tuple");
4445 return NULL;
4446 }
4447 return _PyObject_FastCallKeywords(func, stack, nargs, kwnames);
4448 }
4449
4450
4451 static PyObject*
stack_pointer(PyObject * self,PyObject * args)4452 stack_pointer(PyObject *self, PyObject *args)
4453 {
4454 int v = 5;
4455 return PyLong_FromVoidPtr(&v);
4456 }
4457
4458
4459 #ifdef W_STOPCODE
4460 static PyObject*
py_w_stopcode(PyObject * self,PyObject * args)4461 py_w_stopcode(PyObject *self, PyObject *args)
4462 {
4463 int sig, status;
4464 if (!PyArg_ParseTuple(args, "i", &sig)) {
4465 return NULL;
4466 }
4467 status = W_STOPCODE(sig);
4468 return PyLong_FromLong(status);
4469 }
4470 #endif
4471
4472
4473 static PyObject *
get_mapping_keys(PyObject * self,PyObject * obj)4474 get_mapping_keys(PyObject* self, PyObject *obj)
4475 {
4476 return PyMapping_Keys(obj);
4477 }
4478
4479 static PyObject *
get_mapping_values(PyObject * self,PyObject * obj)4480 get_mapping_values(PyObject* self, PyObject *obj)
4481 {
4482 return PyMapping_Values(obj);
4483 }
4484
4485 static PyObject *
get_mapping_items(PyObject * self,PyObject * obj)4486 get_mapping_items(PyObject* self, PyObject *obj)
4487 {
4488 return PyMapping_Items(obj);
4489 }
4490
4491
4492 static PyObject *
test_pythread_tss_key_state(PyObject * self,PyObject * args)4493 test_pythread_tss_key_state(PyObject *self, PyObject *args)
4494 {
4495 Py_tss_t tss_key = Py_tss_NEEDS_INIT;
4496 if (PyThread_tss_is_created(&tss_key)) {
4497 return raiseTestError("test_pythread_tss_key_state",
4498 "TSS key not in an uninitialized state at "
4499 "creation time");
4500 }
4501 if (PyThread_tss_create(&tss_key) != 0) {
4502 PyErr_SetString(PyExc_RuntimeError, "PyThread_tss_create failed");
4503 return NULL;
4504 }
4505 if (!PyThread_tss_is_created(&tss_key)) {
4506 return raiseTestError("test_pythread_tss_key_state",
4507 "PyThread_tss_create succeeded, "
4508 "but with TSS key in an uninitialized state");
4509 }
4510 if (PyThread_tss_create(&tss_key) != 0) {
4511 return raiseTestError("test_pythread_tss_key_state",
4512 "PyThread_tss_create unsuccessful with "
4513 "an already initialized key");
4514 }
4515 #define CHECK_TSS_API(expr) \
4516 (void)(expr); \
4517 if (!PyThread_tss_is_created(&tss_key)) { \
4518 return raiseTestError("test_pythread_tss_key_state", \
4519 "TSS key initialization state was not " \
4520 "preserved after calling " #expr); }
4521 CHECK_TSS_API(PyThread_tss_set(&tss_key, NULL));
4522 CHECK_TSS_API(PyThread_tss_get(&tss_key));
4523 #undef CHECK_TSS_API
4524 PyThread_tss_delete(&tss_key);
4525 if (PyThread_tss_is_created(&tss_key)) {
4526 return raiseTestError("test_pythread_tss_key_state",
4527 "PyThread_tss_delete called, but did not "
4528 "set the key state to uninitialized");
4529 }
4530
4531 Py_tss_t *ptr_key = PyThread_tss_alloc();
4532 if (ptr_key == NULL) {
4533 PyErr_SetString(PyExc_RuntimeError, "PyThread_tss_alloc failed");
4534 return NULL;
4535 }
4536 if (PyThread_tss_is_created(ptr_key)) {
4537 return raiseTestError("test_pythread_tss_key_state",
4538 "TSS key not in an uninitialized state at "
4539 "allocation time");
4540 }
4541 PyThread_tss_free(ptr_key);
4542 ptr_key = NULL;
4543 Py_RETURN_NONE;
4544 }
4545
4546
4547 static PyObject*
new_hamt(PyObject * self,PyObject * args)4548 new_hamt(PyObject *self, PyObject *args)
4549 {
4550 return _PyContext_NewHamtForTests();
4551 }
4552
4553
4554 static PyObject *
get_global_config(PyObject * self,PyObject * Py_UNUSED (args))4555 get_global_config(PyObject *self, PyObject *Py_UNUSED(args))
4556 {
4557 return _Py_GetGlobalVariablesAsDict();
4558 }
4559
4560
4561 static PyObject *
get_core_config(PyObject * self,PyObject * Py_UNUSED (args))4562 get_core_config(PyObject *self, PyObject *Py_UNUSED(args))
4563 {
4564 PyInterpreterState *interp = PyThreadState_GET()->interp;
4565 const _PyCoreConfig *config = &interp->core_config;
4566 return _PyCoreConfig_AsDict(config);
4567 }
4568
4569
4570 static PyObject *
get_main_config(PyObject * self,PyObject * Py_UNUSED (args))4571 get_main_config(PyObject *self, PyObject *Py_UNUSED(args))
4572 {
4573 PyInterpreterState *interp = PyThreadState_GET()->interp;
4574 const _PyMainInterpreterConfig *config = &interp->config;
4575 return _PyMainInterpreterConfig_AsDict(config);
4576 }
4577
4578
4579 static PyMethodDef TestMethods[] = {
4580 {"raise_exception", raise_exception, METH_VARARGS},
4581 {"raise_memoryerror", (PyCFunction)raise_memoryerror, METH_NOARGS},
4582 {"set_errno", set_errno, METH_VARARGS},
4583 {"test_config", (PyCFunction)test_config, METH_NOARGS},
4584 {"test_sizeof_c_types", (PyCFunction)test_sizeof_c_types, METH_NOARGS},
4585 {"test_datetime_capi", test_datetime_capi, METH_NOARGS},
4586 {"datetime_check_date", datetime_check_date, METH_VARARGS},
4587 {"datetime_check_time", datetime_check_time, METH_VARARGS},
4588 {"datetime_check_datetime", datetime_check_datetime, METH_VARARGS},
4589 {"datetime_check_delta", datetime_check_delta, METH_VARARGS},
4590 {"datetime_check_tzinfo", datetime_check_tzinfo, METH_VARARGS},
4591 {"make_timezones_capi", make_timezones_capi, METH_NOARGS},
4592 {"get_timezones_offset_zero", get_timezones_offset_zero, METH_NOARGS},
4593 {"get_timezone_utc_capi", get_timezone_utc_capi, METH_VARARGS},
4594 {"test_list_api", (PyCFunction)test_list_api, METH_NOARGS},
4595 {"test_dict_iteration", (PyCFunction)test_dict_iteration,METH_NOARGS},
4596 {"dict_getitem_knownhash", dict_getitem_knownhash, METH_VARARGS},
4597 {"dict_hassplittable", dict_hassplittable, METH_O},
4598 {"test_lazy_hash_inheritance", (PyCFunction)test_lazy_hash_inheritance,METH_NOARGS},
4599 {"test_long_api", (PyCFunction)test_long_api, METH_NOARGS},
4600 {"test_xincref_doesnt_leak",(PyCFunction)test_xincref_doesnt_leak, METH_NOARGS},
4601 {"test_incref_doesnt_leak", (PyCFunction)test_incref_doesnt_leak, METH_NOARGS},
4602 {"test_xdecref_doesnt_leak",(PyCFunction)test_xdecref_doesnt_leak, METH_NOARGS},
4603 {"test_decref_doesnt_leak", (PyCFunction)test_decref_doesnt_leak, METH_NOARGS},
4604 {"test_incref_decref_API", (PyCFunction)test_incref_decref_API, METH_NOARGS},
4605 {"test_long_and_overflow", (PyCFunction)test_long_and_overflow,
4606 METH_NOARGS},
4607 {"test_long_as_double", (PyCFunction)test_long_as_double,METH_NOARGS},
4608 {"test_long_as_size_t", (PyCFunction)test_long_as_size_t,METH_NOARGS},
4609 {"test_long_numbits", (PyCFunction)test_long_numbits, METH_NOARGS},
4610 {"test_k_code", (PyCFunction)test_k_code, METH_NOARGS},
4611 {"test_empty_argparse", (PyCFunction)test_empty_argparse,METH_NOARGS},
4612 {"parse_tuple_and_keywords", parse_tuple_and_keywords, METH_VARARGS},
4613 {"test_null_strings", (PyCFunction)test_null_strings, METH_NOARGS},
4614 {"test_string_from_format", (PyCFunction)test_string_from_format, METH_NOARGS},
4615 {"test_with_docstring", (PyCFunction)test_with_docstring, METH_NOARGS,
4616 PyDoc_STR("This is a pretty normal docstring.")},
4617 {"test_string_to_double", (PyCFunction)test_string_to_double, METH_NOARGS},
4618 {"test_unicode_compare_with_ascii", (PyCFunction)test_unicode_compare_with_ascii, METH_NOARGS},
4619 {"test_capsule", (PyCFunction)test_capsule, METH_NOARGS},
4620 {"test_from_contiguous", (PyCFunction)test_from_contiguous, METH_NOARGS},
4621 #if (defined(__linux__) || defined(__FreeBSD__)) && defined(__GNUC__)
4622 {"test_pep3118_obsolete_write_locks", (PyCFunction)test_pep3118_obsolete_write_locks, METH_NOARGS},
4623 #endif
4624 {"getbuffer_with_null_view", getbuffer_with_null_view, METH_O},
4625 {"test_buildvalue_N", test_buildvalue_N, METH_NOARGS},
4626 {"get_args", get_args, METH_VARARGS},
4627 {"get_kwargs", (PyCFunction)get_kwargs, METH_VARARGS|METH_KEYWORDS},
4628 {"getargs_tuple", getargs_tuple, METH_VARARGS},
4629 {"getargs_keywords", (PyCFunction)getargs_keywords,
4630 METH_VARARGS|METH_KEYWORDS},
4631 {"getargs_keyword_only", (PyCFunction)getargs_keyword_only,
4632 METH_VARARGS|METH_KEYWORDS},
4633 {"getargs_positional_only_and_keywords",
4634 (PyCFunction)getargs_positional_only_and_keywords,
4635 METH_VARARGS|METH_KEYWORDS},
4636 {"getargs_b", getargs_b, METH_VARARGS},
4637 {"getargs_B", getargs_B, METH_VARARGS},
4638 {"getargs_h", getargs_h, METH_VARARGS},
4639 {"getargs_H", getargs_H, METH_VARARGS},
4640 {"getargs_I", getargs_I, METH_VARARGS},
4641 {"getargs_k", getargs_k, METH_VARARGS},
4642 {"getargs_i", getargs_i, METH_VARARGS},
4643 {"getargs_l", getargs_l, METH_VARARGS},
4644 {"getargs_n", getargs_n, METH_VARARGS},
4645 {"getargs_p", getargs_p, METH_VARARGS},
4646 {"getargs_L", getargs_L, METH_VARARGS},
4647 {"getargs_K", getargs_K, METH_VARARGS},
4648 {"test_longlong_api", test_longlong_api, METH_NOARGS},
4649 {"test_long_long_and_overflow",
4650 (PyCFunction)test_long_long_and_overflow, METH_NOARGS},
4651 {"test_L_code", (PyCFunction)test_L_code, METH_NOARGS},
4652 {"getargs_f", getargs_f, METH_VARARGS},
4653 {"getargs_d", getargs_d, METH_VARARGS},
4654 {"getargs_D", getargs_D, METH_VARARGS},
4655 {"getargs_S", getargs_S, METH_VARARGS},
4656 {"getargs_Y", getargs_Y, METH_VARARGS},
4657 {"getargs_U", getargs_U, METH_VARARGS},
4658 {"getargs_c", getargs_c, METH_VARARGS},
4659 {"getargs_C", getargs_C, METH_VARARGS},
4660 {"getargs_s", getargs_s, METH_VARARGS},
4661 {"getargs_s_star", getargs_s_star, METH_VARARGS},
4662 {"getargs_s_hash", getargs_s_hash, METH_VARARGS},
4663 {"getargs_z", getargs_z, METH_VARARGS},
4664 {"getargs_z_star", getargs_z_star, METH_VARARGS},
4665 {"getargs_z_hash", getargs_z_hash, METH_VARARGS},
4666 {"getargs_y", getargs_y, METH_VARARGS},
4667 {"getargs_y_star", getargs_y_star, METH_VARARGS},
4668 {"getargs_y_hash", getargs_y_hash, METH_VARARGS},
4669 {"getargs_u", getargs_u, METH_VARARGS},
4670 {"getargs_u_hash", getargs_u_hash, METH_VARARGS},
4671 {"getargs_Z", getargs_Z, METH_VARARGS},
4672 {"getargs_Z_hash", getargs_Z_hash, METH_VARARGS},
4673 {"getargs_w_star", getargs_w_star, METH_VARARGS},
4674 {"getargs_es", getargs_es, METH_VARARGS},
4675 {"getargs_et", getargs_et, METH_VARARGS},
4676 {"getargs_es_hash", getargs_es_hash, METH_VARARGS},
4677 {"getargs_et_hash", getargs_et_hash, METH_VARARGS},
4678 {"codec_incrementalencoder",
4679 (PyCFunction)codec_incrementalencoder, METH_VARARGS},
4680 {"codec_incrementaldecoder",
4681 (PyCFunction)codec_incrementaldecoder, METH_VARARGS},
4682 {"test_s_code", (PyCFunction)test_s_code, METH_NOARGS},
4683 {"test_u_code", (PyCFunction)test_u_code, METH_NOARGS},
4684 {"test_Z_code", (PyCFunction)test_Z_code, METH_NOARGS},
4685 {"test_widechar", (PyCFunction)test_widechar, METH_NOARGS},
4686 {"unicode_aswidechar", unicode_aswidechar, METH_VARARGS},
4687 {"unicode_aswidecharstring",unicode_aswidecharstring, METH_VARARGS},
4688 {"unicode_asucs4", unicode_asucs4, METH_VARARGS},
4689 {"unicode_findchar", unicode_findchar, METH_VARARGS},
4690 {"unicode_copycharacters", unicode_copycharacters, METH_VARARGS},
4691 {"unicode_encodedecimal", unicode_encodedecimal, METH_VARARGS},
4692 {"unicode_transformdecimaltoascii", unicode_transformdecimaltoascii, METH_VARARGS},
4693 {"unicode_legacy_string", unicode_legacy_string, METH_VARARGS},
4694 {"_test_thread_state", test_thread_state, METH_VARARGS},
4695 {"_pending_threadfunc", pending_threadfunc, METH_VARARGS},
4696 #ifdef HAVE_GETTIMEOFDAY
4697 {"profile_int", profile_int, METH_NOARGS},
4698 #endif
4699 {"traceback_print", traceback_print, METH_VARARGS},
4700 {"exception_print", exception_print, METH_VARARGS},
4701 {"set_exc_info", test_set_exc_info, METH_VARARGS},
4702 {"argparsing", argparsing, METH_VARARGS},
4703 {"code_newempty", code_newempty, METH_VARARGS},
4704 {"make_exception_with_doc", (PyCFunction)make_exception_with_doc,
4705 METH_VARARGS | METH_KEYWORDS},
4706 {"make_memoryview_from_NULL_pointer", (PyCFunction)make_memoryview_from_NULL_pointer,
4707 METH_NOARGS},
4708 {"crash_no_current_thread", (PyCFunction)crash_no_current_thread, METH_NOARGS},
4709 {"run_in_subinterp", run_in_subinterp, METH_VARARGS},
4710 {"pytime_object_to_time_t", test_pytime_object_to_time_t, METH_VARARGS},
4711 {"pytime_object_to_timeval", test_pytime_object_to_timeval, METH_VARARGS},
4712 {"pytime_object_to_timespec", test_pytime_object_to_timespec, METH_VARARGS},
4713 {"with_tp_del", with_tp_del, METH_VARARGS},
4714 {"create_cfunction", create_cfunction, METH_NOARGS},
4715 {"test_pymem_alloc0",
4716 (PyCFunction)test_pymem_alloc0, METH_NOARGS},
4717 {"test_pymem_setrawallocators",
4718 (PyCFunction)test_pymem_setrawallocators, METH_NOARGS},
4719 {"test_pymem_setallocators",
4720 (PyCFunction)test_pymem_setallocators, METH_NOARGS},
4721 {"test_pyobject_setallocators",
4722 (PyCFunction)test_pyobject_setallocators, METH_NOARGS},
4723 {"set_nomemory", (PyCFunction)set_nomemory, METH_VARARGS,
4724 PyDoc_STR("set_nomemory(start:int, stop:int = 0)")},
4725 {"remove_mem_hooks", (PyCFunction)remove_mem_hooks, METH_NOARGS,
4726 PyDoc_STR("Remove memory hooks.")},
4727 {"no_docstring",
4728 (PyCFunction)test_with_docstring, METH_NOARGS},
4729 {"docstring_empty",
4730 (PyCFunction)test_with_docstring, METH_NOARGS,
4731 docstring_empty},
4732 {"docstring_no_signature",
4733 (PyCFunction)test_with_docstring, METH_NOARGS,
4734 docstring_no_signature},
4735 {"docstring_with_invalid_signature",
4736 (PyCFunction)test_with_docstring, METH_NOARGS,
4737 docstring_with_invalid_signature},
4738 {"docstring_with_invalid_signature2",
4739 (PyCFunction)test_with_docstring, METH_NOARGS,
4740 docstring_with_invalid_signature2},
4741 {"docstring_with_signature",
4742 (PyCFunction)test_with_docstring, METH_NOARGS,
4743 docstring_with_signature},
4744 {"docstring_with_signature_but_no_doc",
4745 (PyCFunction)test_with_docstring, METH_NOARGS,
4746 docstring_with_signature_but_no_doc},
4747 {"docstring_with_signature_and_extra_newlines",
4748 (PyCFunction)test_with_docstring, METH_NOARGS,
4749 docstring_with_signature_and_extra_newlines},
4750 {"docstring_with_signature_with_defaults",
4751 (PyCFunction)test_with_docstring, METH_NOARGS,
4752 docstring_with_signature_with_defaults},
4753 {"raise_signal",
4754 (PyCFunction)test_raise_signal, METH_VARARGS},
4755 {"call_in_temporary_c_thread", call_in_temporary_c_thread, METH_O,
4756 PyDoc_STR("set_error_class(error_class) -> None")},
4757 {"pymarshal_write_long_to_file",
4758 pymarshal_write_long_to_file, METH_VARARGS},
4759 {"pymarshal_write_object_to_file",
4760 pymarshal_write_object_to_file, METH_VARARGS},
4761 {"pymarshal_read_short_from_file",
4762 pymarshal_read_short_from_file, METH_VARARGS},
4763 {"pymarshal_read_long_from_file",
4764 pymarshal_read_long_from_file, METH_VARARGS},
4765 {"pymarshal_read_last_object_from_file",
4766 pymarshal_read_last_object_from_file, METH_VARARGS},
4767 {"pymarshal_read_object_from_file",
4768 pymarshal_read_object_from_file, METH_VARARGS},
4769 {"return_null_without_error",
4770 return_null_without_error, METH_NOARGS},
4771 {"return_result_with_error",
4772 return_result_with_error, METH_NOARGS},
4773 {"PyTime_FromSeconds", test_pytime_fromseconds, METH_VARARGS},
4774 {"PyTime_FromSecondsObject", test_pytime_fromsecondsobject, METH_VARARGS},
4775 {"PyTime_AsSecondsDouble", test_pytime_assecondsdouble, METH_VARARGS},
4776 {"PyTime_AsTimeval", test_PyTime_AsTimeval, METH_VARARGS},
4777 #ifdef HAVE_CLOCK_GETTIME
4778 {"PyTime_AsTimespec", test_PyTime_AsTimespec, METH_VARARGS},
4779 #endif
4780 {"PyTime_AsMilliseconds", test_PyTime_AsMilliseconds, METH_VARARGS},
4781 {"PyTime_AsMicroseconds", test_PyTime_AsMicroseconds, METH_VARARGS},
4782 {"get_recursion_depth", get_recursion_depth, METH_NOARGS},
4783 {"pymem_buffer_overflow", pymem_buffer_overflow, METH_NOARGS},
4784 {"pymem_api_misuse", pymem_api_misuse, METH_NOARGS},
4785 {"pymem_malloc_without_gil", pymem_malloc_without_gil, METH_NOARGS},
4786 {"pymem_getallocatorsname", test_pymem_getallocatorsname, METH_NOARGS},
4787 {"pyobject_malloc_without_gil", pyobject_malloc_without_gil, METH_NOARGS},
4788 {"tracemalloc_track", tracemalloc_track, METH_VARARGS},
4789 {"tracemalloc_untrack", tracemalloc_untrack, METH_VARARGS},
4790 {"tracemalloc_get_traceback", tracemalloc_get_traceback, METH_VARARGS},
4791 {"dict_get_version", dict_get_version, METH_VARARGS},
4792 {"raise_SIGINT_then_send_None", raise_SIGINT_then_send_None, METH_VARARGS},
4793 {"pyobject_fastcall", test_pyobject_fastcall, METH_VARARGS},
4794 {"pyobject_fastcalldict", test_pyobject_fastcalldict, METH_VARARGS},
4795 {"pyobject_fastcallkeywords", test_pyobject_fastcallkeywords, METH_VARARGS},
4796 {"stack_pointer", stack_pointer, METH_NOARGS},
4797 #ifdef W_STOPCODE
4798 {"W_STOPCODE", py_w_stopcode, METH_VARARGS},
4799 #endif
4800 {"get_mapping_keys", get_mapping_keys, METH_O},
4801 {"get_mapping_values", get_mapping_values, METH_O},
4802 {"get_mapping_items", get_mapping_items, METH_O},
4803 {"test_pythread_tss_key_state", test_pythread_tss_key_state, METH_VARARGS},
4804 {"hamt", new_hamt, METH_NOARGS},
4805 {"get_global_config", get_global_config, METH_NOARGS},
4806 {"get_core_config", get_core_config, METH_NOARGS},
4807 {"get_main_config", get_main_config, METH_NOARGS},
4808 {NULL, NULL} /* sentinel */
4809 };
4810
4811 #define AddSym(d, n, f, v) {PyObject *o = f(v); PyDict_SetItemString(d, n, o); Py_DECREF(o);}
4812
4813 typedef struct {
4814 char bool_member;
4815 char byte_member;
4816 unsigned char ubyte_member;
4817 short short_member;
4818 unsigned short ushort_member;
4819 int int_member;
4820 unsigned int uint_member;
4821 long long_member;
4822 unsigned long ulong_member;
4823 Py_ssize_t pyssizet_member;
4824 float float_member;
4825 double double_member;
4826 char inplace_member[6];
4827 long long longlong_member;
4828 unsigned long long ulonglong_member;
4829 } all_structmembers;
4830
4831 typedef struct {
4832 PyObject_HEAD
4833 all_structmembers structmembers;
4834 } test_structmembers;
4835
4836 static struct PyMemberDef test_members[] = {
4837 {"T_BOOL", T_BOOL, offsetof(test_structmembers, structmembers.bool_member), 0, NULL},
4838 {"T_BYTE", T_BYTE, offsetof(test_structmembers, structmembers.byte_member), 0, NULL},
4839 {"T_UBYTE", T_UBYTE, offsetof(test_structmembers, structmembers.ubyte_member), 0, NULL},
4840 {"T_SHORT", T_SHORT, offsetof(test_structmembers, structmembers.short_member), 0, NULL},
4841 {"T_USHORT", T_USHORT, offsetof(test_structmembers, structmembers.ushort_member), 0, NULL},
4842 {"T_INT", T_INT, offsetof(test_structmembers, structmembers.int_member), 0, NULL},
4843 {"T_UINT", T_UINT, offsetof(test_structmembers, structmembers.uint_member), 0, NULL},
4844 {"T_LONG", T_LONG, offsetof(test_structmembers, structmembers.long_member), 0, NULL},
4845 {"T_ULONG", T_ULONG, offsetof(test_structmembers, structmembers.ulong_member), 0, NULL},
4846 {"T_PYSSIZET", T_PYSSIZET, offsetof(test_structmembers, structmembers.pyssizet_member), 0, NULL},
4847 {"T_FLOAT", T_FLOAT, offsetof(test_structmembers, structmembers.float_member), 0, NULL},
4848 {"T_DOUBLE", T_DOUBLE, offsetof(test_structmembers, structmembers.double_member), 0, NULL},
4849 {"T_STRING_INPLACE", T_STRING_INPLACE, offsetof(test_structmembers, structmembers.inplace_member), 0, NULL},
4850 {"T_LONGLONG", T_LONGLONG, offsetof(test_structmembers, structmembers.longlong_member), 0, NULL},
4851 {"T_ULONGLONG", T_ULONGLONG, offsetof(test_structmembers, structmembers.ulonglong_member), 0, NULL},
4852 {NULL}
4853 };
4854
4855
4856 static PyObject *
test_structmembers_new(PyTypeObject * type,PyObject * args,PyObject * kwargs)4857 test_structmembers_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
4858 {
4859 static char *keywords[] = {
4860 "T_BOOL", "T_BYTE", "T_UBYTE", "T_SHORT", "T_USHORT",
4861 "T_INT", "T_UINT", "T_LONG", "T_ULONG", "T_PYSSIZET",
4862 "T_FLOAT", "T_DOUBLE", "T_STRING_INPLACE",
4863 "T_LONGLONG", "T_ULONGLONG",
4864 NULL};
4865 static const char fmt[] = "|bbBhHiIlknfds#LK";
4866 test_structmembers *ob;
4867 const char *s = NULL;
4868 Py_ssize_t string_len = 0;
4869 ob = PyObject_New(test_structmembers, type);
4870 if (ob == NULL)
4871 return NULL;
4872 memset(&ob->structmembers, 0, sizeof(all_structmembers));
4873 if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,
4874 &ob->structmembers.bool_member,
4875 &ob->structmembers.byte_member,
4876 &ob->structmembers.ubyte_member,
4877 &ob->structmembers.short_member,
4878 &ob->structmembers.ushort_member,
4879 &ob->structmembers.int_member,
4880 &ob->structmembers.uint_member,
4881 &ob->structmembers.long_member,
4882 &ob->structmembers.ulong_member,
4883 &ob->structmembers.pyssizet_member,
4884 &ob->structmembers.float_member,
4885 &ob->structmembers.double_member,
4886 &s, &string_len
4887 , &ob->structmembers.longlong_member,
4888 &ob->structmembers.ulonglong_member
4889 )) {
4890 Py_DECREF(ob);
4891 return NULL;
4892 }
4893 if (s != NULL) {
4894 if (string_len > 5) {
4895 Py_DECREF(ob);
4896 PyErr_SetString(PyExc_ValueError, "string too long");
4897 return NULL;
4898 }
4899 strcpy(ob->structmembers.inplace_member, s);
4900 }
4901 else {
4902 strcpy(ob->structmembers.inplace_member, "");
4903 }
4904 return (PyObject *)ob;
4905 }
4906
4907 static void
test_structmembers_free(PyObject * ob)4908 test_structmembers_free(PyObject *ob)
4909 {
4910 PyObject_FREE(ob);
4911 }
4912
4913 static PyTypeObject test_structmembersType = {
4914 PyVarObject_HEAD_INIT(NULL, 0)
4915 "test_structmembersType",
4916 sizeof(test_structmembers), /* tp_basicsize */
4917 0, /* tp_itemsize */
4918 test_structmembers_free, /* destructor tp_dealloc */
4919 0, /* tp_print */
4920 0, /* tp_getattr */
4921 0, /* tp_setattr */
4922 0, /* tp_reserved */
4923 0, /* tp_repr */
4924 0, /* tp_as_number */
4925 0, /* tp_as_sequence */
4926 0, /* tp_as_mapping */
4927 0, /* tp_hash */
4928 0, /* tp_call */
4929 0, /* tp_str */
4930 PyObject_GenericGetAttr, /* tp_getattro */
4931 PyObject_GenericSetAttr, /* tp_setattro */
4932 0, /* tp_as_buffer */
4933 0, /* tp_flags */
4934 "Type containing all structmember types",
4935 0, /* traverseproc tp_traverse */
4936 0, /* tp_clear */
4937 0, /* tp_richcompare */
4938 0, /* tp_weaklistoffset */
4939 0, /* tp_iter */
4940 0, /* tp_iternext */
4941 0, /* tp_methods */
4942 test_members, /* tp_members */
4943 0,
4944 0,
4945 0,
4946 0,
4947 0,
4948 0,
4949 0,
4950 0,
4951 test_structmembers_new, /* tp_new */
4952 };
4953
4954
4955 typedef struct {
4956 PyObject_HEAD
4957 } matmulObject;
4958
4959 static PyObject *
matmulType_matmul(PyObject * self,PyObject * other)4960 matmulType_matmul(PyObject *self, PyObject *other)
4961 {
4962 return Py_BuildValue("(sOO)", "matmul", self, other);
4963 }
4964
4965 static PyObject *
matmulType_imatmul(PyObject * self,PyObject * other)4966 matmulType_imatmul(PyObject *self, PyObject *other)
4967 {
4968 return Py_BuildValue("(sOO)", "imatmul", self, other);
4969 }
4970
4971 static void
matmulType_dealloc(PyObject * self)4972 matmulType_dealloc(PyObject *self)
4973 {
4974 Py_TYPE(self)->tp_free(self);
4975 }
4976
4977 static PyNumberMethods matmulType_as_number = {
4978 0, /* nb_add */
4979 0, /* nb_subtract */
4980 0, /* nb_multiply */
4981 0, /* nb_remainde r*/
4982 0, /* nb_divmod */
4983 0, /* nb_power */
4984 0, /* nb_negative */
4985 0, /* tp_positive */
4986 0, /* tp_absolute */
4987 0, /* tp_bool */
4988 0, /* nb_invert */
4989 0, /* nb_lshift */
4990 0, /* nb_rshift */
4991 0, /* nb_and */
4992 0, /* nb_xor */
4993 0, /* nb_or */
4994 0, /* nb_int */
4995 0, /* nb_reserved */
4996 0, /* nb_float */
4997 0, /* nb_inplace_add */
4998 0, /* nb_inplace_subtract */
4999 0, /* nb_inplace_multiply */
5000 0, /* nb_inplace_remainder */
5001 0, /* nb_inplace_power */
5002 0, /* nb_inplace_lshift */
5003 0, /* nb_inplace_rshift */
5004 0, /* nb_inplace_and */
5005 0, /* nb_inplace_xor */
5006 0, /* nb_inplace_or */
5007 0, /* nb_floor_divide */
5008 0, /* nb_true_divide */
5009 0, /* nb_inplace_floor_divide */
5010 0, /* nb_inplace_true_divide */
5011 0, /* nb_index */
5012 matmulType_matmul, /* nb_matrix_multiply */
5013 matmulType_imatmul /* nb_matrix_inplace_multiply */
5014 };
5015
5016 static PyTypeObject matmulType = {
5017 PyVarObject_HEAD_INIT(NULL, 0)
5018 "matmulType",
5019 sizeof(matmulObject), /* tp_basicsize */
5020 0, /* tp_itemsize */
5021 matmulType_dealloc, /* destructor tp_dealloc */
5022 0, /* tp_print */
5023 0, /* tp_getattr */
5024 0, /* tp_setattr */
5025 0, /* tp_reserved */
5026 0, /* tp_repr */
5027 &matmulType_as_number, /* tp_as_number */
5028 0, /* tp_as_sequence */
5029 0, /* tp_as_mapping */
5030 0, /* tp_hash */
5031 0, /* tp_call */
5032 0, /* tp_str */
5033 PyObject_GenericGetAttr, /* tp_getattro */
5034 PyObject_GenericSetAttr, /* tp_setattro */
5035 0, /* tp_as_buffer */
5036 0, /* tp_flags */
5037 "C level type with matrix operations defined",
5038 0, /* traverseproc tp_traverse */
5039 0, /* tp_clear */
5040 0, /* tp_richcompare */
5041 0, /* tp_weaklistoffset */
5042 0, /* tp_iter */
5043 0, /* tp_iternext */
5044 0, /* tp_methods */
5045 0, /* tp_members */
5046 0,
5047 0,
5048 0,
5049 0,
5050 0,
5051 0,
5052 0,
5053 0,
5054 PyType_GenericNew, /* tp_new */
5055 PyObject_Del, /* tp_free */
5056 };
5057
5058
5059 typedef struct {
5060 PyObject_HEAD
5061 PyObject *ao_iterator;
5062 } awaitObject;
5063
5064
5065 static PyObject *
awaitObject_new(PyTypeObject * type,PyObject * args,PyObject * kwds)5066 awaitObject_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
5067 {
5068 PyObject *v;
5069 awaitObject *ao;
5070
5071 if (!PyArg_UnpackTuple(args, "awaitObject", 1, 1, &v))
5072 return NULL;
5073
5074 ao = (awaitObject *)type->tp_alloc(type, 0);
5075 if (ao == NULL) {
5076 return NULL;
5077 }
5078
5079 Py_INCREF(v);
5080 ao->ao_iterator = v;
5081
5082 return (PyObject *)ao;
5083 }
5084
5085
5086 static void
awaitObject_dealloc(awaitObject * ao)5087 awaitObject_dealloc(awaitObject *ao)
5088 {
5089 Py_CLEAR(ao->ao_iterator);
5090 Py_TYPE(ao)->tp_free(ao);
5091 }
5092
5093
5094 static PyObject *
awaitObject_await(awaitObject * ao)5095 awaitObject_await(awaitObject *ao)
5096 {
5097 Py_INCREF(ao->ao_iterator);
5098 return ao->ao_iterator;
5099 }
5100
5101 static PyAsyncMethods awaitType_as_async = {
5102 (unaryfunc)awaitObject_await, /* am_await */
5103 0, /* am_aiter */
5104 0 /* am_anext */
5105 };
5106
5107
5108 static PyTypeObject awaitType = {
5109 PyVarObject_HEAD_INIT(NULL, 0)
5110 "awaitType",
5111 sizeof(awaitObject), /* tp_basicsize */
5112 0, /* tp_itemsize */
5113 (destructor)awaitObject_dealloc, /* destructor tp_dealloc */
5114 0, /* tp_print */
5115 0, /* tp_getattr */
5116 0, /* tp_setattr */
5117 &awaitType_as_async, /* tp_as_async */
5118 0, /* tp_repr */
5119 0, /* tp_as_number */
5120 0, /* tp_as_sequence */
5121 0, /* tp_as_mapping */
5122 0, /* tp_hash */
5123 0, /* tp_call */
5124 0, /* tp_str */
5125 PyObject_GenericGetAttr, /* tp_getattro */
5126 PyObject_GenericSetAttr, /* tp_setattro */
5127 0, /* tp_as_buffer */
5128 0, /* tp_flags */
5129 "C level type with tp_as_async",
5130 0, /* traverseproc tp_traverse */
5131 0, /* tp_clear */
5132 0, /* tp_richcompare */
5133 0, /* tp_weaklistoffset */
5134 0, /* tp_iter */
5135 0, /* tp_iternext */
5136 0, /* tp_methods */
5137 0, /* tp_members */
5138 0,
5139 0,
5140 0,
5141 0,
5142 0,
5143 0,
5144 0,
5145 0,
5146 awaitObject_new, /* tp_new */
5147 PyObject_Del, /* tp_free */
5148 };
5149
5150
5151 static int recurse_infinitely_error_init(PyObject *, PyObject *, PyObject *);
5152
5153 static PyTypeObject PyRecursingInfinitelyError_Type = {
5154 PyVarObject_HEAD_INIT(NULL, 0)
5155 "RecursingInfinitelyError", /* tp_name */
5156 sizeof(PyBaseExceptionObject), /* tp_basicsize */
5157 0, /* tp_itemsize */
5158 0, /* tp_dealloc */
5159 0, /* tp_print */
5160 0, /* tp_getattr */
5161 0, /* tp_setattr */
5162 0, /* tp_reserved */
5163 0, /* tp_repr */
5164 0, /* tp_as_number */
5165 0, /* tp_as_sequence */
5166 0, /* tp_as_mapping */
5167 0, /* tp_hash */
5168 0, /* tp_call */
5169 0, /* tp_str */
5170 0, /* tp_getattro */
5171 0, /* tp_setattro */
5172 0, /* tp_as_buffer */
5173 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
5174 "Instantiating this exception starts infinite recursion.", /* tp_doc */
5175 0, /* tp_traverse */
5176 0, /* tp_clear */
5177 0, /* tp_richcompare */
5178 0, /* tp_weaklistoffset */
5179 0, /* tp_iter */
5180 0, /* tp_iternext */
5181 0, /* tp_methods */
5182 0, /* tp_members */
5183 0, /* tp_getset */
5184 0, /* tp_base */
5185 0, /* tp_dict */
5186 0, /* tp_descr_get */
5187 0, /* tp_descr_set */
5188 0, /* tp_dictoffset */
5189 (initproc)recurse_infinitely_error_init, /* tp_init */
5190 0, /* tp_alloc */
5191 0, /* tp_new */
5192 };
5193
5194 static int
recurse_infinitely_error_init(PyObject * self,PyObject * args,PyObject * kwds)5195 recurse_infinitely_error_init(PyObject *self, PyObject *args, PyObject *kwds)
5196 {
5197 PyObject *type = (PyObject *)&PyRecursingInfinitelyError_Type;
5198
5199 /* Instantiating this exception starts infinite recursion. */
5200 Py_INCREF(type);
5201 PyErr_SetObject(type, NULL);
5202 return -1;
5203 }
5204
5205
5206 /* Test PEP 560 */
5207
5208 typedef struct {
5209 PyObject_HEAD
5210 PyObject *item;
5211 } PyGenericAliasObject;
5212
5213 static void
generic_alias_dealloc(PyGenericAliasObject * self)5214 generic_alias_dealloc(PyGenericAliasObject *self)
5215 {
5216 Py_CLEAR(self->item);
5217 Py_TYPE(self)->tp_free((PyObject *)self);
5218 }
5219
5220 static PyObject *
generic_alias_mro_entries(PyGenericAliasObject * self,PyObject * bases)5221 generic_alias_mro_entries(PyGenericAliasObject *self, PyObject *bases)
5222 {
5223 return PyTuple_Pack(1, self->item);
5224 }
5225
5226 static PyMethodDef generic_alias_methods[] = {
5227 {"__mro_entries__", (PyCFunction) generic_alias_mro_entries, METH_O, NULL},
5228 {NULL} /* sentinel */
5229 };
5230
5231 static PyTypeObject GenericAlias_Type = {
5232 PyVarObject_HEAD_INIT(NULL, 0)
5233 "GenericAlias",
5234 sizeof(PyGenericAliasObject),
5235 0,
5236 .tp_dealloc = (destructor)generic_alias_dealloc,
5237 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5238 .tp_methods = generic_alias_methods,
5239 };
5240
5241 static PyObject *
generic_alias_new(PyObject * item)5242 generic_alias_new(PyObject *item)
5243 {
5244 PyGenericAliasObject *o = PyObject_New(PyGenericAliasObject, &GenericAlias_Type);
5245 if (o == NULL) {
5246 return NULL;
5247 }
5248 Py_INCREF(item);
5249 o->item = item;
5250 return (PyObject*) o;
5251 }
5252
5253 typedef struct {
5254 PyObject_HEAD
5255 } PyGenericObject;
5256
5257 static PyObject *
generic_class_getitem(PyObject * type,PyObject * item)5258 generic_class_getitem(PyObject *type, PyObject *item)
5259 {
5260 return generic_alias_new(item);
5261 }
5262
5263 static PyMethodDef generic_methods[] = {
5264 {"__class_getitem__", generic_class_getitem, METH_O|METH_CLASS, NULL},
5265 {NULL} /* sentinel */
5266 };
5267
5268 static PyTypeObject Generic_Type = {
5269 PyVarObject_HEAD_INIT(NULL, 0)
5270 "Generic",
5271 sizeof(PyGenericObject),
5272 0,
5273 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
5274 .tp_methods = generic_methods,
5275 };
5276
5277
5278 static struct PyModuleDef _testcapimodule = {
5279 PyModuleDef_HEAD_INIT,
5280 "_testcapi",
5281 NULL,
5282 -1,
5283 TestMethods,
5284 NULL,
5285 NULL,
5286 NULL,
5287 NULL
5288 };
5289
5290 /* Per PEP 489, this module will not be converted to multi-phase initialization
5291 */
5292
5293 PyMODINIT_FUNC
PyInit__testcapi(void)5294 PyInit__testcapi(void)
5295 {
5296 PyObject *m;
5297
5298 m = PyModule_Create(&_testcapimodule);
5299 if (m == NULL)
5300 return NULL;
5301
5302 Py_TYPE(&_HashInheritanceTester_Type)=&PyType_Type;
5303
5304 Py_TYPE(&test_structmembersType)=&PyType_Type;
5305 Py_INCREF(&test_structmembersType);
5306 /* don't use a name starting with "test", since we don't want
5307 test_capi to automatically call this */
5308 PyModule_AddObject(m, "_test_structmembersType", (PyObject *)&test_structmembersType);
5309 if (PyType_Ready(&matmulType) < 0)
5310 return NULL;
5311 Py_INCREF(&matmulType);
5312 PyModule_AddObject(m, "matmulType", (PyObject *)&matmulType);
5313
5314 if (PyType_Ready(&awaitType) < 0)
5315 return NULL;
5316 Py_INCREF(&awaitType);
5317 PyModule_AddObject(m, "awaitType", (PyObject *)&awaitType);
5318
5319 if (PyType_Ready(&GenericAlias_Type) < 0)
5320 return NULL;
5321 Py_INCREF(&GenericAlias_Type);
5322 PyModule_AddObject(m, "GenericAlias", (PyObject *)&GenericAlias_Type);
5323
5324 if (PyType_Ready(&Generic_Type) < 0)
5325 return NULL;
5326 Py_INCREF(&Generic_Type);
5327 PyModule_AddObject(m, "Generic", (PyObject *)&Generic_Type);
5328
5329 PyRecursingInfinitelyError_Type.tp_base = (PyTypeObject *)PyExc_Exception;
5330 if (PyType_Ready(&PyRecursingInfinitelyError_Type) < 0) {
5331 return NULL;
5332 }
5333 Py_INCREF(&PyRecursingInfinitelyError_Type);
5334 PyModule_AddObject(m, "RecursingInfinitelyError",
5335 (PyObject *)&PyRecursingInfinitelyError_Type);
5336
5337 PyModule_AddObject(m, "CHAR_MAX", PyLong_FromLong(CHAR_MAX));
5338 PyModule_AddObject(m, "CHAR_MIN", PyLong_FromLong(CHAR_MIN));
5339 PyModule_AddObject(m, "UCHAR_MAX", PyLong_FromLong(UCHAR_MAX));
5340 PyModule_AddObject(m, "SHRT_MAX", PyLong_FromLong(SHRT_MAX));
5341 PyModule_AddObject(m, "SHRT_MIN", PyLong_FromLong(SHRT_MIN));
5342 PyModule_AddObject(m, "USHRT_MAX", PyLong_FromLong(USHRT_MAX));
5343 PyModule_AddObject(m, "INT_MAX", PyLong_FromLong(INT_MAX));
5344 PyModule_AddObject(m, "INT_MIN", PyLong_FromLong(INT_MIN));
5345 PyModule_AddObject(m, "UINT_MAX", PyLong_FromUnsignedLong(UINT_MAX));
5346 PyModule_AddObject(m, "LONG_MAX", PyLong_FromLong(LONG_MAX));
5347 PyModule_AddObject(m, "LONG_MIN", PyLong_FromLong(LONG_MIN));
5348 PyModule_AddObject(m, "ULONG_MAX", PyLong_FromUnsignedLong(ULONG_MAX));
5349 PyModule_AddObject(m, "FLT_MAX", PyFloat_FromDouble(FLT_MAX));
5350 PyModule_AddObject(m, "FLT_MIN", PyFloat_FromDouble(FLT_MIN));
5351 PyModule_AddObject(m, "DBL_MAX", PyFloat_FromDouble(DBL_MAX));
5352 PyModule_AddObject(m, "DBL_MIN", PyFloat_FromDouble(DBL_MIN));
5353 PyModule_AddObject(m, "LLONG_MAX", PyLong_FromLongLong(PY_LLONG_MAX));
5354 PyModule_AddObject(m, "LLONG_MIN", PyLong_FromLongLong(PY_LLONG_MIN));
5355 PyModule_AddObject(m, "ULLONG_MAX", PyLong_FromUnsignedLongLong(PY_ULLONG_MAX));
5356 PyModule_AddObject(m, "PY_SSIZE_T_MAX", PyLong_FromSsize_t(PY_SSIZE_T_MAX));
5357 PyModule_AddObject(m, "PY_SSIZE_T_MIN", PyLong_FromSsize_t(PY_SSIZE_T_MIN));
5358 PyModule_AddObject(m, "SIZEOF_PYGC_HEAD", PyLong_FromSsize_t(sizeof(PyGC_Head)));
5359 PyModule_AddObject(m, "SIZEOF_TIME_T", PyLong_FromSsize_t(sizeof(time_t)));
5360 Py_INCREF(&PyInstanceMethod_Type);
5361 PyModule_AddObject(m, "instancemethod", (PyObject *)&PyInstanceMethod_Type);
5362
5363 PyModule_AddIntConstant(m, "the_number_three", 3);
5364 #ifdef WITH_PYMALLOC
5365 PyModule_AddObject(m, "WITH_PYMALLOC", Py_True);
5366 #else
5367 PyModule_AddObject(m, "WITH_PYMALLOC", Py_False);
5368 #endif
5369
5370 TestError = PyErr_NewException("_testcapi.error", NULL, NULL);
5371 Py_INCREF(TestError);
5372 PyModule_AddObject(m, "error", TestError);
5373 return m;
5374 }
5375