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/* This module tests the public (Include/ and Include/cpython/) C API.
9 The internal C API must not be used here: use _testinternalcapi for that.
10
11 The Visual Studio projects builds _testcapi with Py_BUILD_CORE_MODULE
12 macro defined, but only the public C API must be tested here. */
13
14#undef Py_BUILD_CORE_MODULE
15/* Always enable assertions */
16#undef NDEBUG
17
18#define PY_SSIZE_T_CLEAN
19
20#include "Python.h"
21#include "datetime.h"
22#include "marshal.h"
23#include "structmember.h" // PyMemberDef
24#include <float.h>
25#include <signal.h>
26
27#ifdef MS_WINDOWS
28# include <winsock2.h> /* struct timeval */
29#endif
30
31#ifdef HAVE_SYS_WAIT_H
32#include <sys/wait.h> /* For W_STOPCODE */
33#endif
34
35#ifdef Py_BUILD_CORE
36# error "_testcapi must test the public Python C API, not CPython internal C API"
37#endif
38
39static struct PyModuleDef _testcapimodule;
40
41static PyObject *TestError; /* set to exception object in init */
42
43/* Raise TestError with test_name + ": " + msg, and return NULL. */
44
45static PyObject *
46raiseTestError(const char* test_name, const char* msg)
47{
48 PyErr_Format(TestError, "%s: %s", test_name, msg);
49 return NULL;
50}
51
52/* Test #defines from pyconfig.h (particularly the SIZEOF_* defines).
53
54 The ones derived from autoconf on the UNIX-like OSes can be relied
55 upon (in the absence of sloppy cross-compiling), but the Windows
56 platforms have these hardcoded. Better safe than sorry.
57*/
58static PyObject*
59sizeof_error(const char* fatname, const char* typname,
60 int expected, int got)
61{
62 PyErr_Format(TestError,
63 "%s #define == %d but sizeof(%s) == %d",
64 fatname, expected, typname, got);
65 return (PyObject*)NULL;
66}
67
68static PyObject*
69test_config(PyObject *self, PyObject *Py_UNUSED(ignored))
70{
71#define CHECK_SIZEOF(FATNAME, TYPE) \
72 if (FATNAME != sizeof(TYPE)) \
73 return sizeof_error(#FATNAME, #TYPE, FATNAME, sizeof(TYPE))
74
75 CHECK_SIZEOF(SIZEOF_SHORT, short);
76 CHECK_SIZEOF(SIZEOF_INT, int);
77 CHECK_SIZEOF(SIZEOF_LONG, long);
78 CHECK_SIZEOF(SIZEOF_VOID_P, void*);
79 CHECK_SIZEOF(SIZEOF_TIME_T, time_t);
80 CHECK_SIZEOF(SIZEOF_LONG_LONG, long long);
81
82#undef CHECK_SIZEOF
83
84 Py_RETURN_NONE;
85}
86
87static PyObject*
88test_sizeof_c_types(PyObject *self, PyObject *Py_UNUSED(ignored))
89{
90#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))
91#pragma GCC diagnostic push
92#pragma GCC diagnostic ignored "-Wtype-limits"
93#endif
94#define CHECK_SIZEOF(TYPE, EXPECTED) \
95 if (EXPECTED != sizeof(TYPE)) { \
96 PyErr_Format(TestError, \
97 "sizeof(%s) = %u instead of %u", \
98 #TYPE, sizeof(TYPE), EXPECTED); \
99 return (PyObject*)NULL; \
100 }
101#define IS_SIGNED(TYPE) (((TYPE)-1) < (TYPE)0)
102#define CHECK_SIGNNESS(TYPE, SIGNED) \
103 if (IS_SIGNED(TYPE) != SIGNED) { \
104 PyErr_Format(TestError, \
105 "%s signness is, instead of %i", \
106 #TYPE, IS_SIGNED(TYPE), SIGNED); \
107 return (PyObject*)NULL; \
108 }
109
110 /* integer types */
111 CHECK_SIZEOF(Py_UCS1, 1);
112 CHECK_SIZEOF(Py_UCS2, 2);
113 CHECK_SIZEOF(Py_UCS4, 4);
114 CHECK_SIGNNESS(Py_UCS1, 0);
115 CHECK_SIGNNESS(Py_UCS2, 0);
116 CHECK_SIGNNESS(Py_UCS4, 0);
117 CHECK_SIZEOF(int32_t, 4);
118 CHECK_SIGNNESS(int32_t, 1);
119 CHECK_SIZEOF(uint32_t, 4);
120 CHECK_SIGNNESS(uint32_t, 0);
121 CHECK_SIZEOF(int64_t, 8);
122 CHECK_SIGNNESS(int64_t, 1);
123 CHECK_SIZEOF(uint64_t, 8);
124 CHECK_SIGNNESS(uint64_t, 0);
125
126 /* pointer/size types */
127 CHECK_SIZEOF(size_t, sizeof(void *));
128 CHECK_SIGNNESS(size_t, 0);
129 CHECK_SIZEOF(Py_ssize_t, sizeof(void *));
130 CHECK_SIGNNESS(Py_ssize_t, 1);
131
132 CHECK_SIZEOF(uintptr_t, sizeof(void *));
133 CHECK_SIGNNESS(uintptr_t, 0);
134 CHECK_SIZEOF(intptr_t, sizeof(void *));
135 CHECK_SIGNNESS(intptr_t, 1);
136
137 Py_RETURN_NONE;
138
139#undef IS_SIGNED
140#undef CHECK_SIGNESS
141#undef CHECK_SIZEOF
142#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))
143#pragma GCC diagnostic pop
144#endif
145}
146
147static PyObject*
148test_gc_control(PyObject *self, PyObject *Py_UNUSED(ignored))
149{
150 int orig_enabled = PyGC_IsEnabled();
151 const char* msg = "ok";
152 int old_state;
153
154 old_state = PyGC_Enable();
155 msg = "Enable(1)";
156 if (old_state != orig_enabled) {
157 goto failed;
158 }
159 msg = "IsEnabled(1)";
160 if (!PyGC_IsEnabled()) {
161 goto failed;
162 }
163
164 old_state = PyGC_Disable();
165 msg = "disable(2)";
166 if (!old_state) {
167 goto failed;
168 }
169 msg = "IsEnabled(2)";
170 if (PyGC_IsEnabled()) {
171 goto failed;
172 }
173
174 old_state = PyGC_Enable();
175 msg = "enable(3)";
176 if (old_state) {
177 goto failed;
178 }
179 msg = "IsEnabled(3)";
180 if (!PyGC_IsEnabled()) {
181 goto failed;
182 }
183
184 if (!orig_enabled) {
185 old_state = PyGC_Disable();
186 msg = "disable(4)";
187 if (old_state) {
188 goto failed;
189 }
190 msg = "IsEnabled(4)";
191 if (PyGC_IsEnabled()) {
192 goto failed;
193 }
194 }
195
196 Py_RETURN_NONE;
197
198failed:
199 /* Try to clean up if we can. */
200 if (orig_enabled) {
201 PyGC_Enable();
202 } else {
203 PyGC_Disable();
204 }
205 PyErr_Format(TestError, "GC control failed in %s", msg);
206 return NULL;
207}
208
209static PyObject*
210test_list_api(PyObject *self, PyObject *Py_UNUSED(ignored))
211{
212 PyObject* list;
213 int i;
214
215 /* SF bug 132008: PyList_Reverse segfaults */
216#define NLIST 30
217 list = PyList_New(NLIST);
218 if (list == (PyObject*)NULL)
219 return (PyObject*)NULL;
220 /* list = range(NLIST) */
221 for (i = 0; i < NLIST; ++i) {
222 PyObject* anint = PyLong_FromLong(i);
223 if (anint == (PyObject*)NULL) {
224 Py_DECREF(list);
225 return (PyObject*)NULL;
226 }
227 PyList_SET_ITEM(list, i, anint);
228 }
229 /* list.reverse(), via PyList_Reverse() */
230 i = PyList_Reverse(list); /* should not blow up! */
231 if (i != 0) {
232 Py_DECREF(list);
233 return (PyObject*)NULL;
234 }
235 /* Check that list == range(29, -1, -1) now */
236 for (i = 0; i < NLIST; ++i) {
237 PyObject* anint = PyList_GET_ITEM(list, i);
238 if (PyLong_AS_LONG(anint) != NLIST-1-i) {
239 PyErr_SetString(TestError,
240 "test_list_api: reverse screwed up");
241 Py_DECREF(list);
242 return (PyObject*)NULL;
243 }
244 }
245 Py_DECREF(list);
246#undef NLIST
247
248 Py_RETURN_NONE;
249}
250
251static int
252test_dict_inner(int count)
253{
254 Py_ssize_t pos = 0, iterations = 0;
255 int i;
256 PyObject *dict = PyDict_New();
257 PyObject *v, *k;
258
259 if (dict == NULL)
260 return -1;
261
262 for (i = 0; i < count; i++) {
263 v = PyLong_FromLong(i);
264 if (v == NULL) {
265 return -1;
266 }
267 if (PyDict_SetItem(dict, v, v) < 0) {
268 Py_DECREF(v);
269 return -1;
270 }
271 Py_DECREF(v);
272 }
273
274 while (PyDict_Next(dict, &pos, &k, &v)) {
275 PyObject *o;
276 iterations++;
277
278 i = PyLong_AS_LONG(v) + 1;
279 o = PyLong_FromLong(i);
280 if (o == NULL)
281 return -1;
282 if (PyDict_SetItem(dict, k, o) < 0) {
283 Py_DECREF(o);
284 return -1;
285 }
286 Py_DECREF(o);
287 }
288
289 Py_DECREF(dict);
290
291 if (iterations != count) {
292 PyErr_SetString(
293 TestError,
294 "test_dict_iteration: dict iteration went wrong ");
295 return -1;
296 } else {
297 return 0;
298 }
299}
300
301static PyObject*
302test_dict_iteration(PyObject* self, PyObject *Py_UNUSED(ignored))
303{
304 int i;
305
306 for (i = 0; i < 200; i++) {
307 if (test_dict_inner(i) < 0) {
308 return NULL;
309 }
310 }
311
312 Py_RETURN_NONE;
313}
314
315static PyObject*
316dict_getitem_knownhash(PyObject *self, PyObject *args)
317{
318 PyObject *mp, *key, *result;
319 Py_ssize_t hash;
320
321 if (!PyArg_ParseTuple(args, "OOn:dict_getitem_knownhash",
322 &mp, &key, &hash)) {
323 return NULL;
324 }
325
326 result = _PyDict_GetItem_KnownHash(mp, key, (Py_hash_t)hash);
327 if (result == NULL && !PyErr_Occurred()) {
328 _PyErr_SetKeyError(key);
329 return NULL;
330 }
331
332 Py_XINCREF(result);
333 return result;
334}
335
336static PyObject*
337dict_hassplittable(PyObject *self, PyObject *arg)
338{
339 if (!PyDict_Check(arg)) {
340 PyErr_Format(PyExc_TypeError,
341 "dict_hassplittable() argument must be dict, not '%s'",
342 Py_TYPE(arg)->tp_name);
343 return NULL;
344 }
345
346 return PyBool_FromLong(_PyDict_HasSplitTable((PyDictObject*)arg));
347}
348
349/* Issue #4701: Check that PyObject_Hash implicitly calls
350 * PyType_Ready if it hasn't already been called
351 */
352static PyTypeObject _HashInheritanceTester_Type = {
353 PyVarObject_HEAD_INIT(NULL, 0)
354 "hashinheritancetester", /* Name of this type */
355 sizeof(PyObject), /* Basic object size */
356 0, /* Item size for varobject */
357 (destructor)PyObject_Del, /* tp_dealloc */
358 0, /* tp_vectorcall_offset */
359 0, /* tp_getattr */
360 0, /* tp_setattr */
361 0, /* tp_as_async */
362 0, /* tp_repr */
363 0, /* tp_as_number */
364 0, /* tp_as_sequence */
365 0, /* tp_as_mapping */
366 0, /* tp_hash */
367 0, /* tp_call */
368 0, /* tp_str */
369 PyObject_GenericGetAttr, /* tp_getattro */
370 0, /* tp_setattro */
371 0, /* tp_as_buffer */
372 Py_TPFLAGS_DEFAULT, /* tp_flags */
373 0, /* tp_doc */
374 0, /* tp_traverse */
375 0, /* tp_clear */
376 0, /* tp_richcompare */
377 0, /* tp_weaklistoffset */
378 0, /* tp_iter */
379 0, /* tp_iternext */
380 0, /* tp_methods */
381 0, /* tp_members */
382 0, /* tp_getset */
383 0, /* tp_base */
384 0, /* tp_dict */
385 0, /* tp_descr_get */
386 0, /* tp_descr_set */
387 0, /* tp_dictoffset */
388 0, /* tp_init */
389 0, /* tp_alloc */
390 PyType_GenericNew, /* tp_new */
391};
392
393static PyObject*
394pycompilestring(PyObject* self, PyObject *obj) {
395 if (PyBytes_CheckExact(obj) == 0) {
396 PyErr_SetString(PyExc_ValueError, "Argument must be a bytes object");
397 return NULL;
398 }
399 const char *the_string = PyBytes_AsString(obj);
400 if (the_string == NULL) {
401 return NULL;
402 }
403 return Py_CompileString(the_string, "<string>", Py_file_input);
404}
405
406static PyObject*
407test_lazy_hash_inheritance(PyObject* self, PyObject *Py_UNUSED(ignored))
408{
409 PyTypeObject *type;
410 PyObject *obj;
411 Py_hash_t hash;
412
413 type = &_HashInheritanceTester_Type;
414
415 if (type->tp_dict != NULL)
416 /* The type has already been initialized. This probably means
417 -R is being used. */
418 Py_RETURN_NONE;
419
420
421 obj = PyObject_New(PyObject, type);
422 if (obj == NULL) {
423 PyErr_Clear();
424 PyErr_SetString(
425 TestError,
426 "test_lazy_hash_inheritance: failed to create object");
427 return NULL;
428 }
429
430 if (type->tp_dict != NULL) {
431 PyErr_SetString(
432 TestError,
433 "test_lazy_hash_inheritance: type initialised too soon");
434 Py_DECREF(obj);
435 return NULL;
436 }
437
438 hash = PyObject_Hash(obj);
439 if ((hash == -1) && PyErr_Occurred()) {
440 PyErr_Clear();
441 PyErr_SetString(
442 TestError,
443 "test_lazy_hash_inheritance: could not hash object");
444 Py_DECREF(obj);
445 return NULL;
446 }
447
448 if (type->tp_dict == NULL) {
449 PyErr_SetString(
450 TestError,
451 "test_lazy_hash_inheritance: type not initialised by hash()");
452 Py_DECREF(obj);
453 return NULL;
454 }
455
456 if (type->tp_hash != PyType_Type.tp_hash) {
457 PyErr_SetString(
458 TestError,
459 "test_lazy_hash_inheritance: unexpected hash function");
460 Py_DECREF(obj);
461 return NULL;
462 }
463
464 Py_DECREF(obj);
465
466 Py_RETURN_NONE;
467}
468
469
470/* Tests of PyLong_{As, From}{Unsigned,}Long(), and
471 PyLong_{As, From}{Unsigned,}LongLong().
472
473 Note that the meat of the test is contained in testcapi_long.h.
474 This is revolting, but delicate code duplication is worse: "almost
475 exactly the same" code is needed to test long long, but the ubiquitous
476 dependence on type names makes it impossible to use a parameterized
477 function. A giant macro would be even worse than this. A C++ template
478 would be perfect.
479
480 The "report an error" functions are deliberately not part of the #include
481 file: if the test fails, you can set a breakpoint in the appropriate
482 error function directly, and crawl back from there in the debugger.
483*/
484
485#define UNBIND(X) Py_DECREF(X); (X) = NULL
486
487static PyObject *
488raise_test_long_error(const char* msg)
489{
490 return raiseTestError("test_long_api", msg);
491}
492
493#define TESTNAME test_long_api_inner
494#define TYPENAME long
495#define F_S_TO_PY PyLong_FromLong
496#define F_PY_TO_S PyLong_AsLong
497#define F_U_TO_PY PyLong_FromUnsignedLong
498#define F_PY_TO_U PyLong_AsUnsignedLong
499
500#include "testcapi_long.h"
501
502static PyObject *
503test_long_api(PyObject* self, PyObject *Py_UNUSED(ignored))
504{
505 return TESTNAME(raise_test_long_error);
506}
507
508#undef TESTNAME
509#undef TYPENAME
510#undef F_S_TO_PY
511#undef F_PY_TO_S
512#undef F_U_TO_PY
513#undef F_PY_TO_U
514
515static PyObject *
516raise_test_longlong_error(const char* msg)
517{
518 return raiseTestError("test_longlong_api", msg);
519}
520
521#define TESTNAME test_longlong_api_inner
522#define TYPENAME long long
523#define F_S_TO_PY PyLong_FromLongLong
524#define F_PY_TO_S PyLong_AsLongLong
525#define F_U_TO_PY PyLong_FromUnsignedLongLong
526#define F_PY_TO_U PyLong_AsUnsignedLongLong
527
528#include "testcapi_long.h"
529
530static PyObject *
531test_longlong_api(PyObject* self, PyObject *args)
532{
533 return TESTNAME(raise_test_longlong_error);
534}
535
536#undef TESTNAME
537#undef TYPENAME
538#undef F_S_TO_PY
539#undef F_PY_TO_S
540#undef F_U_TO_PY
541#undef F_PY_TO_U
542
543/* Test the PyLong_AsLongAndOverflow API. General conversion to PY_LONG
544 is tested by test_long_api_inner. This test will concentrate on proper
545 handling of overflow.
546*/
547
548static PyObject *
549test_long_and_overflow(PyObject *self, PyObject *Py_UNUSED(ignored))
550{
551 PyObject *num, *one, *temp;
552 long value;
553 int overflow;
554
555 /* Test that overflow is set properly for a large value. */
556 /* num is a number larger than LONG_MAX even on 64-bit platforms */
557 num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
558 if (num == NULL)
559 return NULL;
560 overflow = 1234;
561 value = PyLong_AsLongAndOverflow(num, &overflow);
562 Py_DECREF(num);
563 if (value == -1 && PyErr_Occurred())
564 return NULL;
565 if (value != -1)
566 return raiseTestError("test_long_and_overflow",
567 "return value was not set to -1");
568 if (overflow != 1)
569 return raiseTestError("test_long_and_overflow",
570 "overflow was not set to 1");
571
572 /* Same again, with num = LONG_MAX + 1 */
573 num = PyLong_FromLong(LONG_MAX);
574 if (num == NULL)
575 return NULL;
576 one = PyLong_FromLong(1L);
577 if (one == NULL) {
578 Py_DECREF(num);
579 return NULL;
580 }
581 temp = PyNumber_Add(num, one);
582 Py_DECREF(one);
583 Py_DECREF(num);
584 num = temp;
585 if (num == NULL)
586 return NULL;
587 overflow = 0;
588 value = PyLong_AsLongAndOverflow(num, &overflow);
589 Py_DECREF(num);
590 if (value == -1 && PyErr_Occurred())
591 return NULL;
592 if (value != -1)
593 return raiseTestError("test_long_and_overflow",
594 "return value was not set to -1");
595 if (overflow != 1)
596 return raiseTestError("test_long_and_overflow",
597 "overflow was not set to 1");
598
599 /* Test that overflow is set properly for a large negative value. */
600 /* num is a number smaller than LONG_MIN even on 64-bit platforms */
601 num = PyLong_FromString("-FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
602 if (num == NULL)
603 return NULL;
604 overflow = 1234;
605 value = PyLong_AsLongAndOverflow(num, &overflow);
606 Py_DECREF(num);
607 if (value == -1 && PyErr_Occurred())
608 return NULL;
609 if (value != -1)
610 return raiseTestError("test_long_and_overflow",
611 "return value was not set to -1");
612 if (overflow != -1)
613 return raiseTestError("test_long_and_overflow",
614 "overflow was not set to -1");
615
616 /* Same again, with num = LONG_MIN - 1 */
617 num = PyLong_FromLong(LONG_MIN);
618 if (num == NULL)
619 return NULL;
620 one = PyLong_FromLong(1L);
621 if (one == NULL) {
622 Py_DECREF(num);
623 return NULL;
624 }
625 temp = PyNumber_Subtract(num, one);
626 Py_DECREF(one);
627 Py_DECREF(num);
628 num = temp;
629 if (num == NULL)
630 return NULL;
631 overflow = 0;
632 value = PyLong_AsLongAndOverflow(num, &overflow);
633 Py_DECREF(num);
634 if (value == -1 && PyErr_Occurred())
635 return NULL;
636 if (value != -1)
637 return raiseTestError("test_long_and_overflow",
638 "return value was not set to -1");
639 if (overflow != -1)
640 return raiseTestError("test_long_and_overflow",
641 "overflow was not set to -1");
642
643 /* Test that overflow is cleared properly for small values. */
644 num = PyLong_FromString("FF", NULL, 16);
645 if (num == NULL)
646 return NULL;
647 overflow = 1234;
648 value = PyLong_AsLongAndOverflow(num, &overflow);
649 Py_DECREF(num);
650 if (value == -1 && PyErr_Occurred())
651 return NULL;
652 if (value != 0xFF)
653 return raiseTestError("test_long_and_overflow",
654 "expected return value 0xFF");
655 if (overflow != 0)
656 return raiseTestError("test_long_and_overflow",
657 "overflow was not cleared");
658
659 num = PyLong_FromString("-FF", NULL, 16);
660 if (num == NULL)
661 return NULL;
662 overflow = 0;
663 value = PyLong_AsLongAndOverflow(num, &overflow);
664 Py_DECREF(num);
665 if (value == -1 && PyErr_Occurred())
666 return NULL;
667 if (value != -0xFF)
668 return raiseTestError("test_long_and_overflow",
669 "expected return value 0xFF");
670 if (overflow != 0)
671 return raiseTestError("test_long_and_overflow",
672 "overflow was set incorrectly");
673
674 num = PyLong_FromLong(LONG_MAX);
675 if (num == NULL)
676 return NULL;
677 overflow = 1234;
678 value = PyLong_AsLongAndOverflow(num, &overflow);
679 Py_DECREF(num);
680 if (value == -1 && PyErr_Occurred())
681 return NULL;
682 if (value != LONG_MAX)
683 return raiseTestError("test_long_and_overflow",
684 "expected return value LONG_MAX");
685 if (overflow != 0)
686 return raiseTestError("test_long_and_overflow",
687 "overflow was not cleared");
688
689 num = PyLong_FromLong(LONG_MIN);
690 if (num == NULL)
691 return NULL;
692 overflow = 0;
693 value = PyLong_AsLongAndOverflow(num, &overflow);
694 Py_DECREF(num);
695 if (value == -1 && PyErr_Occurred())
696 return NULL;
697 if (value != LONG_MIN)
698 return raiseTestError("test_long_and_overflow",
699 "expected return value LONG_MIN");
700 if (overflow != 0)
701 return raiseTestError("test_long_and_overflow",
702 "overflow was not cleared");
703
704 Py_RETURN_NONE;
705}
706
707/* Test the PyLong_AsLongLongAndOverflow API. General conversion to
708 long long is tested by test_long_api_inner. This test will
709 concentrate on proper handling of overflow.
710*/
711
712static PyObject *
713test_long_long_and_overflow(PyObject *self, PyObject *Py_UNUSED(ignored))
714{
715 PyObject *num, *one, *temp;
716 long long value;
717 int overflow;
718
719 /* Test that overflow is set properly for a large value. */
720 /* num is a number larger than LLONG_MAX on a typical machine. */
721 num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
722 if (num == NULL)
723 return NULL;
724 overflow = 1234;
725 value = PyLong_AsLongLongAndOverflow(num, &overflow);
726 Py_DECREF(num);
727 if (value == -1 && PyErr_Occurred())
728 return NULL;
729 if (value != -1)
730 return raiseTestError("test_long_long_and_overflow",
731 "return value was not set to -1");
732 if (overflow != 1)
733 return raiseTestError("test_long_long_and_overflow",
734 "overflow was not set to 1");
735
736 /* Same again, with num = LLONG_MAX + 1 */
737 num = PyLong_FromLongLong(LLONG_MAX);
738 if (num == NULL)
739 return NULL;
740 one = PyLong_FromLong(1L);
741 if (one == NULL) {
742 Py_DECREF(num);
743 return NULL;
744 }
745 temp = PyNumber_Add(num, one);
746 Py_DECREF(one);
747 Py_DECREF(num);
748 num = temp;
749 if (num == NULL)
750 return NULL;
751 overflow = 0;
752 value = PyLong_AsLongLongAndOverflow(num, &overflow);
753 Py_DECREF(num);
754 if (value == -1 && PyErr_Occurred())
755 return NULL;
756 if (value != -1)
757 return raiseTestError("test_long_long_and_overflow",
758 "return value was not set to -1");
759 if (overflow != 1)
760 return raiseTestError("test_long_long_and_overflow",
761 "overflow was not set to 1");
762
763 /* Test that overflow is set properly for a large negative value. */
764 /* num is a number smaller than LLONG_MIN on a typical platform */
765 num = PyLong_FromString("-FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
766 if (num == NULL)
767 return NULL;
768 overflow = 1234;
769 value = PyLong_AsLongLongAndOverflow(num, &overflow);
770 Py_DECREF(num);
771 if (value == -1 && PyErr_Occurred())
772 return NULL;
773 if (value != -1)
774 return raiseTestError("test_long_long_and_overflow",
775 "return value was not set to -1");
776 if (overflow != -1)
777 return raiseTestError("test_long_long_and_overflow",
778 "overflow was not set to -1");
779
780 /* Same again, with num = LLONG_MIN - 1 */
781 num = PyLong_FromLongLong(LLONG_MIN);
782 if (num == NULL)
783 return NULL;
784 one = PyLong_FromLong(1L);
785 if (one == NULL) {
786 Py_DECREF(num);
787 return NULL;
788 }
789 temp = PyNumber_Subtract(num, one);
790 Py_DECREF(one);
791 Py_DECREF(num);
792 num = temp;
793 if (num == NULL)
794 return NULL;
795 overflow = 0;
796 value = PyLong_AsLongLongAndOverflow(num, &overflow);
797 Py_DECREF(num);
798 if (value == -1 && PyErr_Occurred())
799 return NULL;
800 if (value != -1)
801 return raiseTestError("test_long_long_and_overflow",
802 "return value was not set to -1");
803 if (overflow != -1)
804 return raiseTestError("test_long_long_and_overflow",
805 "overflow was not set to -1");
806
807 /* Test that overflow is cleared properly for small values. */
808 num = PyLong_FromString("FF", NULL, 16);
809 if (num == NULL)
810 return NULL;
811 overflow = 1234;
812 value = PyLong_AsLongLongAndOverflow(num, &overflow);
813 Py_DECREF(num);
814 if (value == -1 && PyErr_Occurred())
815 return NULL;
816 if (value != 0xFF)
817 return raiseTestError("test_long_long_and_overflow",
818 "expected return value 0xFF");
819 if (overflow != 0)
820 return raiseTestError("test_long_long_and_overflow",
821 "overflow was not cleared");
822
823 num = PyLong_FromString("-FF", NULL, 16);
824 if (num == NULL)
825 return NULL;
826 overflow = 0;
827 value = PyLong_AsLongLongAndOverflow(num, &overflow);
828 Py_DECREF(num);
829 if (value == -1 && PyErr_Occurred())
830 return NULL;
831 if (value != -0xFF)
832 return raiseTestError("test_long_long_and_overflow",
833 "expected return value 0xFF");
834 if (overflow != 0)
835 return raiseTestError("test_long_long_and_overflow",
836 "overflow was set incorrectly");
837
838 num = PyLong_FromLongLong(LLONG_MAX);
839 if (num == NULL)
840 return NULL;
841 overflow = 1234;
842 value = PyLong_AsLongLongAndOverflow(num, &overflow);
843 Py_DECREF(num);
844 if (value == -1 && PyErr_Occurred())
845 return NULL;
846 if (value != LLONG_MAX)
847 return raiseTestError("test_long_long_and_overflow",
848 "expected return value LLONG_MAX");
849 if (overflow != 0)
850 return raiseTestError("test_long_long_and_overflow",
851 "overflow was not cleared");
852
853 num = PyLong_FromLongLong(LLONG_MIN);
854 if (num == NULL)
855 return NULL;
856 overflow = 0;
857 value = PyLong_AsLongLongAndOverflow(num, &overflow);
858 Py_DECREF(num);
859 if (value == -1 && PyErr_Occurred())
860 return NULL;
861 if (value != LLONG_MIN)
862 return raiseTestError("test_long_long_and_overflow",
863 "expected return value LLONG_MIN");
864 if (overflow != 0)
865 return raiseTestError("test_long_long_and_overflow",
866 "overflow was not cleared");
867
868 Py_RETURN_NONE;
869}
870
871/* Test the PyLong_As{Size,Ssize}_t API. At present this just tests that
872 non-integer arguments are handled correctly. It should be extended to
873 test overflow handling.
874 */
875
876static PyObject *
877test_long_as_size_t(PyObject *self, PyObject *Py_UNUSED(ignored))
878{
879 size_t out_u;
880 Py_ssize_t out_s;
881
882 Py_INCREF(Py_None);
883
884 out_u = PyLong_AsSize_t(Py_None);
885 if (out_u != (size_t)-1 || !PyErr_Occurred())
886 return raiseTestError("test_long_as_size_t",
887 "PyLong_AsSize_t(None) didn't complain");
888 if (!PyErr_ExceptionMatches(PyExc_TypeError))
889 return raiseTestError("test_long_as_size_t",
890 "PyLong_AsSize_t(None) raised "
891 "something other than TypeError");
892 PyErr_Clear();
893
894 out_s = PyLong_AsSsize_t(Py_None);
895 if (out_s != (Py_ssize_t)-1 || !PyErr_Occurred())
896 return raiseTestError("test_long_as_size_t",
897 "PyLong_AsSsize_t(None) didn't complain");
898 if (!PyErr_ExceptionMatches(PyExc_TypeError))
899 return raiseTestError("test_long_as_size_t",
900 "PyLong_AsSsize_t(None) raised "
901 "something other than TypeError");
902 PyErr_Clear();
903
904 /* Py_INCREF(Py_None) omitted - we already have a reference to it. */
905 return Py_None;
906}
907
908static PyObject *
909test_long_as_unsigned_long_long_mask(PyObject *self,
910 PyObject *Py_UNUSED(ignored))
911{
912 unsigned long long res = PyLong_AsUnsignedLongLongMask(NULL);
913
914 if (res != (unsigned long long)-1 || !PyErr_Occurred()) {
915 return raiseTestError("test_long_as_unsigned_long_long_mask",
916 "PyLong_AsUnsignedLongLongMask(NULL) didn't "
917 "complain");
918 }
919 if (!PyErr_ExceptionMatches(PyExc_SystemError)) {
920 return raiseTestError("test_long_as_unsigned_long_long_mask",
921 "PyLong_AsUnsignedLongLongMask(NULL) raised "
922 "something other than SystemError");
923 }
924 PyErr_Clear();
925 Py_RETURN_NONE;
926}
927
928/* Test the PyLong_AsDouble API. At present this just tests that
929 non-integer arguments are handled correctly.
930 */
931
932static PyObject *
933test_long_as_double(PyObject *self, PyObject *Py_UNUSED(ignored))
934{
935 double out;
936
937 Py_INCREF(Py_None);
938
939 out = PyLong_AsDouble(Py_None);
940 if (out != -1.0 || !PyErr_Occurred())
941 return raiseTestError("test_long_as_double",
942 "PyLong_AsDouble(None) didn't complain");
943 if (!PyErr_ExceptionMatches(PyExc_TypeError))
944 return raiseTestError("test_long_as_double",
945 "PyLong_AsDouble(None) raised "
946 "something other than TypeError");
947 PyErr_Clear();
948
949 /* Py_INCREF(Py_None) omitted - we already have a reference to it. */
950 return Py_None;
951}
952
953/* Test the L code for PyArg_ParseTuple. This should deliver a long long
954 for both long and int arguments. The test may leak a little memory if
955 it fails.
956*/
957static PyObject *
958test_L_code(PyObject *self, PyObject *Py_UNUSED(ignored))
959{
960 PyObject *tuple, *num;
961 long long value;
962
963 tuple = PyTuple_New(1);
964 if (tuple == NULL)
965 return NULL;
966
967 num = PyLong_FromLong(42);
968 if (num == NULL)
969 return NULL;
970
971 PyTuple_SET_ITEM(tuple, 0, num);
972
973 value = -1;
974 if (!PyArg_ParseTuple(tuple, "L:test_L_code", &value)) {
975 return NULL;
976 }
977 if (value != 42)
978 return raiseTestError("test_L_code",
979 "L code returned wrong value for long 42");
980
981 Py_DECREF(num);
982 num = PyLong_FromLong(42);
983 if (num == NULL)
984 return NULL;
985
986 PyTuple_SET_ITEM(tuple, 0, num);
987
988 value = -1;
989 if (!PyArg_ParseTuple(tuple, "L:test_L_code", &value)) {
990 return NULL;
991 }
992 if (value != 42)
993 return raiseTestError("test_L_code",
994 "L code returned wrong value for int 42");
995
996 Py_DECREF(tuple);
997 Py_RETURN_NONE;
998}
999
1000static PyObject *
1001return_none(void *unused)
1002{
1003 Py_RETURN_NONE;
1004}
1005
1006static PyObject *
1007raise_error(void *unused)
1008{
1009 PyErr_SetNone(PyExc_ValueError);
1010 return NULL;
1011}
1012
1013static int
1014test_buildvalue_N_error(const char *fmt)
1015{
1016 PyObject *arg, *res;
1017
1018 arg = PyList_New(0);
1019 if (arg == NULL) {
1020 return -1;
1021 }
1022
1023 Py_INCREF(arg);
1024 res = Py_BuildValue(fmt, return_none, NULL, arg);
1025 if (res == NULL) {
1026 return -1;
1027 }
1028 Py_DECREF(res);
1029 if (Py_REFCNT(arg) != 1) {
1030 PyErr_Format(TestError, "test_buildvalue_N: "
1031 "arg was not decrefed in successful "
1032 "Py_BuildValue(\"%s\")", fmt);
1033 return -1;
1034 }
1035
1036 Py_INCREF(arg);
1037 res = Py_BuildValue(fmt, raise_error, NULL, arg);
1038 if (res != NULL || !PyErr_Occurred()) {
1039 PyErr_Format(TestError, "test_buildvalue_N: "
1040 "Py_BuildValue(\"%s\") didn't complain", fmt);
1041 return -1;
1042 }
1043 PyErr_Clear();
1044 if (Py_REFCNT(arg) != 1) {
1045 PyErr_Format(TestError, "test_buildvalue_N: "
1046 "arg was not decrefed in failed "
1047 "Py_BuildValue(\"%s\")", fmt);
1048 return -1;
1049 }
1050 Py_DECREF(arg);
1051 return 0;
1052}
1053
1054static PyObject *
1055test_buildvalue_N(PyObject *self, PyObject *Py_UNUSED(ignored))
1056{
1057 PyObject *arg, *res;
1058
1059 arg = PyList_New(0);
1060 if (arg == NULL) {
1061 return NULL;
1062 }
1063 Py_INCREF(arg);
1064 res = Py_BuildValue("N", arg);
1065 if (res == NULL) {
1066 return NULL;
1067 }
1068 if (res != arg) {
1069 return raiseTestError("test_buildvalue_N",
1070 "Py_BuildValue(\"N\") returned wrong result");
1071 }
1072 if (Py_REFCNT(arg) != 2) {
1073 return raiseTestError("test_buildvalue_N",
1074 "arg was not decrefed in Py_BuildValue(\"N\")");
1075 }
1076 Py_DECREF(res);
1077 Py_DECREF(arg);
1078
1079 if (test_buildvalue_N_error("O&N") < 0)
1080 return NULL;
1081 if (test_buildvalue_N_error("(O&N)") < 0)
1082 return NULL;
1083 if (test_buildvalue_N_error("[O&N]") < 0)
1084 return NULL;
1085 if (test_buildvalue_N_error("{O&N}") < 0)
1086 return NULL;
1087 if (test_buildvalue_N_error("{()O&(())N}") < 0)
1088 return NULL;
1089
1090 Py_RETURN_NONE;
1091}
1092
1093
1094static PyObject *
1095test_get_statictype_slots(PyObject *self, PyObject *Py_UNUSED(ignored))
1096{
1097 newfunc tp_new = PyType_GetSlot(&PyLong_Type, Py_tp_new);
1098 if (PyLong_Type.tp_new != tp_new) {
1099 PyErr_SetString(PyExc_AssertionError, "mismatch: tp_new of long");
1100 return NULL;
1101 }
1102
1103 reprfunc tp_repr = PyType_GetSlot(&PyLong_Type, Py_tp_repr);
1104 if (PyLong_Type.tp_repr != tp_repr) {
1105 PyErr_SetString(PyExc_AssertionError, "mismatch: tp_repr of long");
1106 return NULL;
1107 }
1108
1109 ternaryfunc tp_call = PyType_GetSlot(&PyLong_Type, Py_tp_call);
1110 if (tp_call != NULL) {
1111 PyErr_SetString(PyExc_AssertionError, "mismatch: tp_call of long");
1112 return NULL;
1113 }
1114
1115 binaryfunc nb_add = PyType_GetSlot(&PyLong_Type, Py_nb_add);
1116 if (PyLong_Type.tp_as_number->nb_add != nb_add) {
1117 PyErr_SetString(PyExc_AssertionError, "mismatch: nb_add of long");
1118 return NULL;
1119 }
1120
1121 lenfunc mp_length = PyType_GetSlot(&PyLong_Type, Py_mp_length);
1122 if (mp_length != NULL) {
1123 PyErr_SetString(PyExc_AssertionError, "mismatch: mp_length of long");
1124 return NULL;
1125 }
1126
1127 void *over_value = PyType_GetSlot(&PyLong_Type, Py_bf_releasebuffer + 1);
1128 if (over_value != NULL) {
1129 PyErr_SetString(PyExc_AssertionError, "mismatch: max+1 of long");
1130 return NULL;
1131 }
1132
1133 tp_new = PyType_GetSlot(&PyLong_Type, 0);
1134 if (tp_new != NULL) {
1135 PyErr_SetString(PyExc_AssertionError, "mismatch: slot 0 of long");
1136 return NULL;
1137 }
1138 if (PyErr_ExceptionMatches(PyExc_SystemError)) {
1139 // This is the right exception
1140 PyErr_Clear();
1141 }
1142 else {
1143 return NULL;
1144 }
1145
1146 Py_RETURN_NONE;
1147}
1148
1149
1150static PyObject *
1151get_args(PyObject *self, PyObject *args)
1152{
1153 if (args == NULL) {
1154 args = Py_None;
1155 }
1156 Py_INCREF(args);
1157 return args;
1158}
1159
1160static PyObject *
1161get_kwargs(PyObject *self, PyObject *args, PyObject *kwargs)
1162{
1163 if (kwargs == NULL) {
1164 kwargs = Py_None;
1165 }
1166 Py_INCREF(kwargs);
1167 return kwargs;
1168}
1169
1170/* Test tuple argument processing */
1171static PyObject *
1172getargs_tuple(PyObject *self, PyObject *args)
1173{
1174 int a, b, c;
1175 if (!PyArg_ParseTuple(args, "i(ii)", &a, &b, &c))
1176 return NULL;
1177 return Py_BuildValue("iii", a, b, c);
1178}
1179
1180/* test PyArg_ParseTupleAndKeywords */
1181static PyObject *
1182getargs_keywords(PyObject *self, PyObject *args, PyObject *kwargs)
1183{
1184 static char *keywords[] = {"arg1","arg2","arg3","arg4","arg5", NULL};
1185 static const char fmt[] = "(ii)i|(i(ii))(iii)i";
1186 int int_args[10]={-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
1187
1188 if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,
1189 &int_args[0], &int_args[1], &int_args[2], &int_args[3], &int_args[4],
1190 &int_args[5], &int_args[6], &int_args[7], &int_args[8], &int_args[9]))
1191 return NULL;
1192 return Py_BuildValue("iiiiiiiiii",
1193 int_args[0], int_args[1], int_args[2], int_args[3], int_args[4],
1194 int_args[5], int_args[6], int_args[7], int_args[8], int_args[9]);
1195}
1196
1197/* test PyArg_ParseTupleAndKeywords keyword-only arguments */
1198static PyObject *
1199getargs_keyword_only(PyObject *self, PyObject *args, PyObject *kwargs)
1200{
1201 static char *keywords[] = {"required", "optional", "keyword_only", NULL};
1202 int required = -1;
1203 int optional = -1;
1204 int keyword_only = -1;
1205
1206 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|i$i", keywords,
1207 &required, &optional, &keyword_only))
1208 return NULL;
1209 return Py_BuildValue("iii", required, optional, keyword_only);
1210}
1211
1212/* test PyArg_ParseTupleAndKeywords positional-only arguments */
1213static PyObject *
1214getargs_positional_only_and_keywords(PyObject *self, PyObject *args, PyObject *kwargs)
1215{
1216 static char *keywords[] = {"", "", "keyword", NULL};
1217 int required = -1;
1218 int optional = -1;
1219 int keyword = -1;
1220
1221 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|ii", keywords,
1222 &required, &optional, &keyword))
1223 return NULL;
1224 return Py_BuildValue("iii", required, optional, keyword);
1225}
1226
1227/* Functions to call PyArg_ParseTuple with integer format codes,
1228 and return the result.
1229*/
1230static PyObject *
1231getargs_b(PyObject *self, PyObject *args)
1232{
1233 unsigned char value;
1234 if (!PyArg_ParseTuple(args, "b", &value))
1235 return NULL;
1236 return PyLong_FromUnsignedLong((unsigned long)value);
1237}
1238
1239static PyObject *
1240getargs_B(PyObject *self, PyObject *args)
1241{
1242 unsigned char value;
1243 if (!PyArg_ParseTuple(args, "B", &value))
1244 return NULL;
1245 return PyLong_FromUnsignedLong((unsigned long)value);
1246}
1247
1248static PyObject *
1249getargs_h(PyObject *self, PyObject *args)
1250{
1251 short value;
1252 if (!PyArg_ParseTuple(args, "h", &value))
1253 return NULL;
1254 return PyLong_FromLong((long)value);
1255}
1256
1257static PyObject *
1258getargs_H(PyObject *self, PyObject *args)
1259{
1260 unsigned short value;
1261 if (!PyArg_ParseTuple(args, "H", &value))
1262 return NULL;
1263 return PyLong_FromUnsignedLong((unsigned long)value);
1264}
1265
1266static PyObject *
1267getargs_I(PyObject *self, PyObject *args)
1268{
1269 unsigned int value;
1270 if (!PyArg_ParseTuple(args, "I", &value))
1271 return NULL;
1272 return PyLong_FromUnsignedLong((unsigned long)value);
1273}
1274
1275static PyObject *
1276getargs_k(PyObject *self, PyObject *args)
1277{
1278 unsigned long value;
1279 if (!PyArg_ParseTuple(args, "k", &value))
1280 return NULL;
1281 return PyLong_FromUnsignedLong(value);
1282}
1283
1284static PyObject *
1285getargs_i(PyObject *self, PyObject *args)
1286{
1287 int value;
1288 if (!PyArg_ParseTuple(args, "i", &value))
1289 return NULL;
1290 return PyLong_FromLong((long)value);
1291}
1292
1293static PyObject *
1294getargs_l(PyObject *self, PyObject *args)
1295{
1296 long value;
1297 if (!PyArg_ParseTuple(args, "l", &value))
1298 return NULL;
1299 return PyLong_FromLong(value);
1300}
1301
1302static PyObject *
1303getargs_n(PyObject *self, PyObject *args)
1304{
1305 Py_ssize_t value;
1306 if (!PyArg_ParseTuple(args, "n", &value))
1307 return NULL;
1308 return PyLong_FromSsize_t(value);
1309}
1310
1311static PyObject *
1312getargs_p(PyObject *self, PyObject *args)
1313{
1314 int value;
1315 if (!PyArg_ParseTuple(args, "p", &value))
1316 return NULL;
1317 return PyLong_FromLong(value);
1318}
1319
1320static PyObject *
1321getargs_L(PyObject *self, PyObject *args)
1322{
1323 long long value;
1324 if (!PyArg_ParseTuple(args, "L", &value))
1325 return NULL;
1326 return PyLong_FromLongLong(value);
1327}
1328
1329static PyObject *
1330getargs_K(PyObject *self, PyObject *args)
1331{
1332 unsigned long long value;
1333 if (!PyArg_ParseTuple(args, "K", &value))
1334 return NULL;
1335 return PyLong_FromUnsignedLongLong(value);
1336}
1337
1338/* This function not only tests the 'k' getargs code, but also the
1339 PyLong_AsUnsignedLongMask() function. */
1340static PyObject *
1341test_k_code(PyObject *self, PyObject *Py_UNUSED(ignored))
1342{
1343 PyObject *tuple, *num;
1344 unsigned long value;
1345
1346 tuple = PyTuple_New(1);
1347 if (tuple == NULL)
1348 return NULL;
1349
1350 /* a number larger than ULONG_MAX even on 64-bit platforms */
1351 num = PyLong_FromString("FFFFFFFFFFFFFFFFFFFFFFFF", NULL, 16);
1352 if (num == NULL)
1353 return NULL;
1354
1355 value = PyLong_AsUnsignedLongMask(num);
1356 if (value != ULONG_MAX)
1357 return raiseTestError("test_k_code",
1358 "PyLong_AsUnsignedLongMask() returned wrong value for long 0xFFF...FFF");
1359
1360 PyTuple_SET_ITEM(tuple, 0, num);
1361
1362 value = 0;
1363 if (!PyArg_ParseTuple(tuple, "k:test_k_code", &value)) {
1364 return NULL;
1365 }
1366 if (value != ULONG_MAX)
1367 return raiseTestError("test_k_code",
1368 "k code returned wrong value for long 0xFFF...FFF");
1369
1370 Py_DECREF(num);
1371 num = PyLong_FromString("-FFFFFFFF000000000000000042", NULL, 16);
1372 if (num == NULL)
1373 return NULL;
1374
1375 value = PyLong_AsUnsignedLongMask(num);
1376 if (value != (unsigned long)-0x42)
1377 return raiseTestError("test_k_code",
1378 "PyLong_AsUnsignedLongMask() returned wrong "
1379 "value for long -0xFFF..000042");
1380
1381 PyTuple_SET_ITEM(tuple, 0, num);
1382
1383 value = 0;
1384 if (!PyArg_ParseTuple(tuple, "k:test_k_code", &value)) {
1385 return NULL;
1386 }
1387 if (value != (unsigned long)-0x42)
1388 return raiseTestError("test_k_code",
1389 "k code returned wrong value for long -0xFFF..000042");
1390
1391 Py_DECREF(tuple);
1392 Py_RETURN_NONE;
1393}
1394
1395static PyObject *
1396getargs_f(PyObject *self, PyObject *args)
1397{
1398 float f;
1399 if (!PyArg_ParseTuple(args, "f", &f))
1400 return NULL;
1401 return PyFloat_FromDouble(f);
1402}
1403
1404static PyObject *
1405getargs_d(PyObject *self, PyObject *args)
1406{
1407 double d;
1408 if (!PyArg_ParseTuple(args, "d", &d))
1409 return NULL;
1410 return PyFloat_FromDouble(d);
1411}
1412
1413static PyObject *
1414getargs_D(PyObject *self, PyObject *args)
1415{
1416 Py_complex cval;
1417 if (!PyArg_ParseTuple(args, "D", &cval))
1418 return NULL;
1419 return PyComplex_FromCComplex(cval);
1420}
1421
1422static PyObject *
1423getargs_S(PyObject *self, PyObject *args)
1424{
1425 PyObject *obj;
1426 if (!PyArg_ParseTuple(args, "S", &obj))
1427 return NULL;
1428 Py_INCREF(obj);
1429 return obj;
1430}
1431
1432static PyObject *
1433getargs_Y(PyObject *self, PyObject *args)
1434{
1435 PyObject *obj;
1436 if (!PyArg_ParseTuple(args, "Y", &obj))
1437 return NULL;
1438 Py_INCREF(obj);
1439 return obj;
1440}
1441
1442static PyObject *
1443getargs_U(PyObject *self, PyObject *args)
1444{
1445 PyObject *obj;
1446 if (!PyArg_ParseTuple(args, "U", &obj))
1447 return NULL;
1448 Py_INCREF(obj);
1449 return obj;
1450}
1451
1452static PyObject *
1453getargs_c(PyObject *self, PyObject *args)
1454{
1455 char c;
1456 if (!PyArg_ParseTuple(args, "c", &c))
1457 return NULL;
1458 return PyLong_FromLong((unsigned char)c);
1459}
1460
1461static PyObject *
1462getargs_C(PyObject *self, PyObject *args)
1463{
1464 int c;
1465 if (!PyArg_ParseTuple(args, "C", &c))
1466 return NULL;
1467 return PyLong_FromLong(c);
1468}
1469
1470static PyObject *
1471getargs_s(PyObject *self, PyObject *args)
1472{
1473 char *str;
1474 if (!PyArg_ParseTuple(args, "s", &str))
1475 return NULL;
1476 return PyBytes_FromString(str);
1477}
1478
1479static PyObject *
1480getargs_s_star(PyObject *self, PyObject *args)
1481{
1482 Py_buffer buffer;
1483 PyObject *bytes;
1484 if (!PyArg_ParseTuple(args, "s*", &buffer))
1485 return NULL;
1486 bytes = PyBytes_FromStringAndSize(buffer.buf, buffer.len);
1487 PyBuffer_Release(&buffer);
1488 return bytes;
1489}
1490
1491static PyObject *
1492getargs_s_hash(PyObject *self, PyObject *args)
1493{
1494 char *str;
1495 Py_ssize_t size;
1496 if (!PyArg_ParseTuple(args, "s#", &str, &size))
1497 return NULL;
1498 return PyBytes_FromStringAndSize(str, size);
1499}
1500
1501static PyObject *
1502getargs_z(PyObject *self, PyObject *args)
1503{
1504 char *str;
1505 if (!PyArg_ParseTuple(args, "z", &str))
1506 return NULL;
1507 if (str != NULL)
1508 return PyBytes_FromString(str);
1509 else
1510 Py_RETURN_NONE;
1511}
1512
1513static PyObject *
1514getargs_z_star(PyObject *self, PyObject *args)
1515{
1516 Py_buffer buffer;
1517 PyObject *bytes;
1518 if (!PyArg_ParseTuple(args, "z*", &buffer))
1519 return NULL;
1520 if (buffer.buf != NULL)
1521 bytes = PyBytes_FromStringAndSize(buffer.buf, buffer.len);
1522 else {
1523 Py_INCREF(Py_None);
1524 bytes = Py_None;
1525 }
1526 PyBuffer_Release(&buffer);
1527 return bytes;
1528}
1529
1530static PyObject *
1531getargs_z_hash(PyObject *self, PyObject *args)
1532{
1533 char *str;
1534 Py_ssize_t size;
1535 if (!PyArg_ParseTuple(args, "z#", &str, &size))
1536 return NULL;
1537 if (str != NULL)
1538 return PyBytes_FromStringAndSize(str, size);
1539 else
1540 Py_RETURN_NONE;
1541}
1542
1543static PyObject *
1544getargs_y(PyObject *self, PyObject *args)
1545{
1546 char *str;
1547 if (!PyArg_ParseTuple(args, "y", &str))
1548 return NULL;
1549 return PyBytes_FromString(str);
1550}
1551
1552static PyObject *
1553getargs_y_star(PyObject *self, PyObject *args)
1554{
1555 Py_buffer buffer;
1556 PyObject *bytes;
1557 if (!PyArg_ParseTuple(args, "y*", &buffer))
1558 return NULL;
1559 bytes = PyBytes_FromStringAndSize(buffer.buf, buffer.len);
1560 PyBuffer_Release(&buffer);
1561 return bytes;
1562}
1563
1564static PyObject *
1565getargs_y_hash(PyObject *self, PyObject *args)
1566{
1567 char *str;
1568 Py_ssize_t size;
1569 if (!PyArg_ParseTuple(args, "y#", &str, &size))
1570 return NULL;
1571 return PyBytes_FromStringAndSize(str, size);
1572}
1573
1574static PyObject *
1575getargs_u(PyObject *self, PyObject *args)
1576{
1577 Py_UNICODE *str;
1578 if (!PyArg_ParseTuple(args, "u", &str))
1579 return NULL;
1580 return PyUnicode_FromWideChar(str, -1);
1581}
1582
1583static PyObject *
1584getargs_u_hash(PyObject *self, PyObject *args)
1585{
1586 Py_UNICODE *str;
1587 Py_ssize_t size;
1588 if (!PyArg_ParseTuple(args, "u#", &str, &size))
1589 return NULL;
1590 return PyUnicode_FromWideChar(str, size);
1591}
1592
1593static PyObject *
1594getargs_Z(PyObject *self, PyObject *args)
1595{
1596 Py_UNICODE *str;
1597 if (!PyArg_ParseTuple(args, "Z", &str))
1598 return NULL;
1599 if (str != NULL) {
1600 return PyUnicode_FromWideChar(str, -1);
1601 } else
1602 Py_RETURN_NONE;
1603}
1604
1605static PyObject *
1606getargs_Z_hash(PyObject *self, PyObject *args)
1607{
1608 Py_UNICODE *str;
1609 Py_ssize_t size;
1610 if (!PyArg_ParseTuple(args, "Z#", &str, &size))
1611 return NULL;
1612 if (str != NULL)
1613 return PyUnicode_FromWideChar(str, size);
1614 else
1615 Py_RETURN_NONE;
1616}
1617
1618static PyObject *
1619getargs_es(PyObject *self, PyObject *args)
1620{
1621 PyObject *arg, *result;
1622 const char *encoding = NULL;
1623 char *str;
1624
1625 if (!PyArg_ParseTuple(args, "O|s", &arg, &encoding))
1626 return NULL;
1627 if (!PyArg_Parse(arg, "es", encoding, &str))
1628 return NULL;
1629 result = PyBytes_FromString(str);
1630 PyMem_Free(str);
1631 return result;
1632}
1633
1634static PyObject *
1635getargs_et(PyObject *self, PyObject *args)
1636{
1637 PyObject *arg, *result;
1638 const char *encoding = NULL;
1639 char *str;
1640
1641 if (!PyArg_ParseTuple(args, "O|s", &arg, &encoding))
1642 return NULL;
1643 if (!PyArg_Parse(arg, "et", encoding, &str))
1644 return NULL;
1645 result = PyBytes_FromString(str);
1646 PyMem_Free(str);
1647 return result;
1648}
1649
1650static PyObject *
1651getargs_es_hash(PyObject *self, PyObject *args)
1652{
1653 PyObject *arg, *result;
1654 const char *encoding = NULL;
1655 PyByteArrayObject *buffer = NULL;
1656 char *str = NULL;
1657 Py_ssize_t size;
1658
1659 if (!PyArg_ParseTuple(args, "O|sY", &arg, &encoding, &buffer))
1660 return NULL;
1661 if (buffer != NULL) {
1662 str = PyByteArray_AS_STRING(buffer);
1663 size = PyByteArray_GET_SIZE(buffer);
1664 }
1665 if (!PyArg_Parse(arg, "es#", encoding, &str, &size))
1666 return NULL;
1667 result = PyBytes_FromStringAndSize(str, size);
1668 if (buffer == NULL)
1669 PyMem_Free(str);
1670 return result;
1671}
1672
1673static PyObject *
1674getargs_et_hash(PyObject *self, PyObject *args)
1675{
1676 PyObject *arg, *result;
1677 const char *encoding = NULL;
1678 PyByteArrayObject *buffer = NULL;
1679 char *str = NULL;
1680 Py_ssize_t size;
1681
1682 if (!PyArg_ParseTuple(args, "O|sY", &arg, &encoding, &buffer))
1683 return NULL;
1684 if (buffer != NULL) {
1685 str = PyByteArray_AS_STRING(buffer);
1686 size = PyByteArray_GET_SIZE(buffer);
1687 }
1688 if (!PyArg_Parse(arg, "et#", encoding, &str, &size))
1689 return NULL;
1690 result = PyBytes_FromStringAndSize(str, size);
1691 if (buffer == NULL)
1692 PyMem_Free(str);
1693 return result;
1694}
1695
1696/* Test the s and z codes for PyArg_ParseTuple.
1697*/
1698static PyObject *
1699test_s_code(PyObject *self, PyObject *Py_UNUSED(ignored))
1700{
1701 /* Unicode strings should be accepted */
1702 PyObject *tuple, *obj;
1703 char *value;
1704
1705 tuple = PyTuple_New(1);
1706 if (tuple == NULL)
1707 return NULL;
1708
1709 obj = PyUnicode_Decode("t\xeate", strlen("t\xeate"),
1710 "latin-1", NULL);
1711 if (obj == NULL)
1712 return NULL;
1713
1714 PyTuple_SET_ITEM(tuple, 0, obj);
1715
1716 /* These two blocks used to raise a TypeError:
1717 * "argument must be string without null bytes, not str"
1718 */
1719 if (!PyArg_ParseTuple(tuple, "s:test_s_code1", &value)) {
1720 return NULL;
1721 }
1722
1723 if (!PyArg_ParseTuple(tuple, "z:test_s_code2", &value)) {
1724 return NULL;
1725 }
1726
1727 Py_DECREF(tuple);
1728 Py_RETURN_NONE;
1729}
1730
1731static PyObject *
1732parse_tuple_and_keywords(PyObject *self, PyObject *args)
1733{
1734 PyObject *sub_args;
1735 PyObject *sub_kwargs;
1736 const char *sub_format;
1737 PyObject *sub_keywords;
1738
1739 Py_ssize_t i, size;
1740 char *keywords[8 + 1]; /* space for NULL at end */
1741 PyObject *o;
1742 PyObject *converted[8];
1743
1744 int result;
1745 PyObject *return_value = NULL;
1746
1747 double buffers[8][4]; /* double ensures alignment where necessary */
1748
1749 if (!PyArg_ParseTuple(args, "OOsO:parse_tuple_and_keywords",
1750 &sub_args, &sub_kwargs,
1751 &sub_format, &sub_keywords))
1752 return NULL;
1753
1754 if (!(PyList_CheckExact(sub_keywords) || PyTuple_CheckExact(sub_keywords))) {
1755 PyErr_SetString(PyExc_ValueError,
1756 "parse_tuple_and_keywords: sub_keywords must be either list or tuple");
1757 return NULL;
1758 }
1759
1760 memset(buffers, 0, sizeof(buffers));
1761 memset(converted, 0, sizeof(converted));
1762 memset(keywords, 0, sizeof(keywords));
1763
1764 size = PySequence_Fast_GET_SIZE(sub_keywords);
1765 if (size > 8) {
1766 PyErr_SetString(PyExc_ValueError,
1767 "parse_tuple_and_keywords: too many keywords in sub_keywords");
1768 goto exit;
1769 }
1770
1771 for (i = 0; i < size; i++) {
1772 o = PySequence_Fast_GET_ITEM(sub_keywords, i);
1773 if (!PyUnicode_FSConverter(o, (void *)(converted + i))) {
1774 PyErr_Format(PyExc_ValueError,
1775 "parse_tuple_and_keywords: could not convert keywords[%zd] to narrow string", i);
1776 goto exit;
1777 }
1778 keywords[i] = PyBytes_AS_STRING(converted[i]);
1779 }
1780
1781 result = PyArg_ParseTupleAndKeywords(sub_args, sub_kwargs,
1782 sub_format, keywords,
1783 buffers + 0, buffers + 1, buffers + 2, buffers + 3,
1784 buffers + 4, buffers + 5, buffers + 6, buffers + 7);
1785
1786 if (result) {
1787 return_value = Py_None;
1788 Py_INCREF(Py_None);
1789 }
1790
1791exit:
1792 size = sizeof(converted) / sizeof(converted[0]);
1793 for (i = 0; i < size; i++) {
1794 Py_XDECREF(converted[i]);
1795 }
1796 return return_value;
1797}
1798
1799static volatile int x;
1800
1801#if USE_UNICODE_WCHAR_CACHE
1802/* Ignore use of deprecated APIs */
1803_Py_COMP_DIAG_PUSH
1804_Py_COMP_DIAG_IGNORE_DEPR_DECLS
1805
1806/* Test the u and u# codes for PyArg_ParseTuple. May leak memory in case
1807 of an error.
1808*/
1809static PyObject *
1810test_u_code(PyObject *self, PyObject *Py_UNUSED(ignored))
1811{
1812 PyObject *tuple, *obj;
1813 Py_UNICODE *value;
1814 Py_ssize_t len;
1815
1816 /* issue4122: Undefined reference to _Py_ascii_whitespace on Windows */
1817 /* Just use the macro and check that it compiles */
1818 x = Py_UNICODE_ISSPACE(25);
1819
1820 tuple = PyTuple_New(1);
1821 if (tuple == NULL)
1822 return NULL;
1823
1824 obj = PyUnicode_Decode("test", strlen("test"),
1825 "ascii", NULL);
1826 if (obj == NULL)
1827 return NULL;
1828
1829 PyTuple_SET_ITEM(tuple, 0, obj);
1830
1831 value = 0;
1832 if (!PyArg_ParseTuple(tuple, "u:test_u_code", &value)) {
1833 return NULL;
1834 }
1835 if (value != PyUnicode_AS_UNICODE(obj))
1836 return raiseTestError("test_u_code",
1837 "u code returned wrong value for u'test'");
1838 value = 0;
1839 if (!PyArg_ParseTuple(tuple, "u#:test_u_code", &value, &len)) {
1840 return NULL;
1841 }
1842 if (value != PyUnicode_AS_UNICODE(obj) ||
1843 len != PyUnicode_GET_SIZE(obj))
1844 return raiseTestError("test_u_code",
1845 "u# code returned wrong values for u'test'");
1846
1847 Py_DECREF(tuple);
1848 Py_RETURN_NONE;
1849}
1850
1851/* Test Z and Z# codes for PyArg_ParseTuple */
1852static PyObject *
1853test_Z_code(PyObject *self, PyObject *Py_UNUSED(ignored))
1854{
1855 PyObject *tuple, *obj;
1856 const Py_UNICODE *value1, *value2;
1857 Py_ssize_t len1, len2;
1858
1859 tuple = PyTuple_New(2);
1860 if (tuple == NULL)
1861 return NULL;
1862
1863 obj = PyUnicode_FromString("test");
1864 PyTuple_SET_ITEM(tuple, 0, obj);
1865 Py_INCREF(Py_None);
1866 PyTuple_SET_ITEM(tuple, 1, Py_None);
1867
1868 /* swap values on purpose */
1869 value1 = NULL;
1870 value2 = PyUnicode_AS_UNICODE(obj);
1871
1872 /* Test Z for both values */
1873 if (!PyArg_ParseTuple(tuple, "ZZ:test_Z_code", &value1, &value2)) {
1874 return NULL;
1875 }
1876 if (value1 != PyUnicode_AS_UNICODE(obj))
1877 return raiseTestError("test_Z_code",
1878 "Z code returned wrong value for 'test'");
1879 if (value2 != NULL)
1880 return raiseTestError("test_Z_code",
1881 "Z code returned wrong value for None");
1882
1883 value1 = NULL;
1884 value2 = PyUnicode_AS_UNICODE(obj);
1885 len1 = -1;
1886 len2 = -1;
1887
1888 /* Test Z# for both values */
1889 if (!PyArg_ParseTuple(tuple, "Z#Z#:test_Z_code", &value1, &len1,
1890 &value2, &len2))
1891 {
1892 return NULL;
1893 }
1894 if (value1 != PyUnicode_AS_UNICODE(obj) ||
1895 len1 != PyUnicode_GET_SIZE(obj))
1896 return raiseTestError("test_Z_code",
1897 "Z# code returned wrong values for 'test'");
1898 if (value2 != NULL ||
1899 len2 != 0)
1900 return raiseTestError("test_Z_code",
1901 "Z# code returned wrong values for None'");
1902
1903 Py_DECREF(tuple);
1904 Py_RETURN_NONE;
1905}
1906_Py_COMP_DIAG_POP
1907#endif /* USE_UNICODE_WCHAR_CACHE */
1908
1909static PyObject *
1910test_widechar(PyObject *self, PyObject *Py_UNUSED(ignored))
1911{
1912#if defined(SIZEOF_WCHAR_T) && (SIZEOF_WCHAR_T == 4)
1913 const wchar_t wtext[2] = {(wchar_t)0x10ABCDu};
1914 size_t wtextlen = 1;
1915 const wchar_t invalid[1] = {(wchar_t)0x110000u};
1916#else
1917 const wchar_t wtext[3] = {(wchar_t)0xDBEAu, (wchar_t)0xDFCDu};
1918 size_t wtextlen = 2;
1919#endif
1920 PyObject *wide, *utf8;
1921
1922 wide = PyUnicode_FromWideChar(wtext, wtextlen);
1923 if (wide == NULL)
1924 return NULL;
1925
1926 utf8 = PyUnicode_FromString("\xf4\x8a\xaf\x8d");
1927 if (utf8 == NULL) {
1928 Py_DECREF(wide);
1929 return NULL;
1930 }
1931
1932 if (PyUnicode_GET_LENGTH(wide) != PyUnicode_GET_LENGTH(utf8)) {
1933 Py_DECREF(wide);
1934 Py_DECREF(utf8);
1935 return raiseTestError("test_widechar",
1936 "wide string and utf8 string "
1937 "have different length");
1938 }
1939 if (PyUnicode_Compare(wide, utf8)) {
1940 Py_DECREF(wide);
1941 Py_DECREF(utf8);
1942 if (PyErr_Occurred())
1943 return NULL;
1944 return raiseTestError("test_widechar",
1945 "wide string and utf8 string "
1946 "are different");
1947 }
1948
1949 Py_DECREF(wide);
1950 Py_DECREF(utf8);
1951
1952#if defined(SIZEOF_WCHAR_T) && (SIZEOF_WCHAR_T == 4)
1953 wide = PyUnicode_FromWideChar(invalid, 1);
1954 if (wide == NULL)
1955 PyErr_Clear();
1956 else
1957 return raiseTestError("test_widechar",
1958 "PyUnicode_FromWideChar(L\"\\U00110000\", 1) didn't fail");
1959
1960#if USE_UNICODE_WCHAR_CACHE
1961/* Ignore use of deprecated APIs */
1962_Py_COMP_DIAG_PUSH
1963_Py_COMP_DIAG_IGNORE_DEPR_DECLS
1964 wide = PyUnicode_FromUnicode(invalid, 1);
1965 if (wide == NULL)
1966 PyErr_Clear();
1967 else
1968 return raiseTestError("test_widechar",
1969 "PyUnicode_FromUnicode(L\"\\U00110000\", 1) didn't fail");
1970
1971 wide = PyUnicode_FromUnicode(NULL, 1);
1972 if (wide == NULL)
1973 return NULL;
1974 PyUnicode_AS_UNICODE(wide)[0] = invalid[0];
1975 if (_PyUnicode_Ready(wide) < 0) {
1976 Py_DECREF(wide);
1977 PyErr_Clear();
1978 }
1979 else {
1980 Py_DECREF(wide);
1981 return raiseTestError("test_widechar",
1982 "PyUnicode_Ready() didn't fail");
1983 }
1984_Py_COMP_DIAG_POP
1985#endif /* USE_UNICODE_WCHAR_CACHE */
1986#endif
1987
1988 Py_RETURN_NONE;
1989}
1990
1991static PyObject *
1992unicode_aswidechar(PyObject *self, PyObject *args)
1993{
1994 PyObject *unicode, *result;
1995 Py_ssize_t buflen, size;
1996 wchar_t *buffer;
1997
1998 if (!PyArg_ParseTuple(args, "Un", &unicode, &buflen))
1999 return NULL;
2000 buffer = PyMem_New(wchar_t, buflen);
2001 if (buffer == NULL)
2002 return PyErr_NoMemory();
2003
2004 size = PyUnicode_AsWideChar(unicode, buffer, buflen);
2005 if (size == -1) {
2006 PyMem_Free(buffer);
2007 return NULL;
2008 }
2009
2010 if (size < buflen)
2011 buflen = size + 1;
2012 else
2013 buflen = size;
2014 result = PyUnicode_FromWideChar(buffer, buflen);
2015 PyMem_Free(buffer);
2016 if (result == NULL)
2017 return NULL;
2018
2019 return Py_BuildValue("(Nn)", result, size);
2020}
2021
2022static PyObject *
2023unicode_aswidecharstring(PyObject *self, PyObject *args)
2024{
2025 PyObject *unicode, *result;
2026 Py_ssize_t size;
2027 wchar_t *buffer;
2028
2029 if (!PyArg_ParseTuple(args, "U", &unicode))
2030 return NULL;
2031
2032 buffer = PyUnicode_AsWideCharString(unicode, &size);
2033 if (buffer == NULL)
2034 return NULL;
2035
2036 result = PyUnicode_FromWideChar(buffer, size + 1);
2037 PyMem_Free(buffer);
2038 if (result == NULL)
2039 return NULL;
2040 return Py_BuildValue("(Nn)", result, size);
2041}
2042
2043static PyObject *
2044unicode_asucs4(PyObject *self, PyObject *args)
2045{
2046 PyObject *unicode, *result;
2047 Py_UCS4 *buffer;
2048 int copy_null;
2049 Py_ssize_t str_len, buf_len;
2050
2051 if (!PyArg_ParseTuple(args, "Unp:unicode_asucs4", &unicode, &str_len, &copy_null)) {
2052 return NULL;
2053 }
2054
2055 buf_len = str_len + 1;
2056 buffer = PyMem_NEW(Py_UCS4, buf_len);
2057 if (buffer == NULL) {
2058 return PyErr_NoMemory();
2059 }
2060 memset(buffer, 0, sizeof(Py_UCS4)*buf_len);
2061 buffer[str_len] = 0xffffU;
2062
2063 if (!PyUnicode_AsUCS4(unicode, buffer, buf_len, copy_null)) {
2064 PyMem_Free(buffer);
2065 return NULL;
2066 }
2067
2068 result = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, buffer, buf_len);
2069 PyMem_Free(buffer);
2070 return result;
2071}
2072
2073static PyObject *
2074unicode_asutf8(PyObject *self, PyObject *args)
2075{
2076 PyObject *unicode;
2077 const char *buffer;
2078
2079 if (!PyArg_ParseTuple(args, "U", &unicode)) {
2080 return NULL;
2081 }
2082
2083 buffer = PyUnicode_AsUTF8(unicode);
2084 if (buffer == NULL) {
2085 return NULL;
2086 }
2087
2088 return PyBytes_FromString(buffer);
2089}
2090
2091static PyObject *
2092unicode_asutf8andsize(PyObject *self, PyObject *args)
2093{
2094 PyObject *unicode, *result;
2095 const char *buffer;
2096 Py_ssize_t utf8_len;
2097
2098 if(!PyArg_ParseTuple(args, "U", &unicode)) {
2099 return NULL;
2100 }
2101
2102 buffer = PyUnicode_AsUTF8AndSize(unicode, &utf8_len);
2103 if (buffer == NULL) {
2104 return NULL;
2105 }
2106
2107 result = PyBytes_FromString(buffer);
2108 if (result == NULL) {
2109 return NULL;
2110 }
2111
2112 return Py_BuildValue("(Nn)", result, utf8_len);
2113}
2114
2115static PyObject *
2116unicode_findchar(PyObject *self, PyObject *args)
2117{
2118 PyObject *str;
2119 int direction;
2120 unsigned int ch;
2121 Py_ssize_t result;
2122 Py_ssize_t start, end;
2123
2124 if (!PyArg_ParseTuple(args, "UInni:unicode_findchar", &str, &ch,
2125 &start, &end, &direction)) {
2126 return NULL;
2127 }
2128
2129 result = PyUnicode_FindChar(str, (Py_UCS4)ch, start, end, direction);
2130 if (result == -2)
2131 return NULL;
2132 else
2133 return PyLong_FromSsize_t(result);
2134}
2135
2136static PyObject *
2137unicode_copycharacters(PyObject *self, PyObject *args)
2138{
2139 PyObject *from, *to, *to_copy;
2140 Py_ssize_t from_start, to_start, how_many, copied;
2141
2142 if (!PyArg_ParseTuple(args, "UnOnn:unicode_copycharacters", &to, &to_start,
2143 &from, &from_start, &how_many)) {
2144 return NULL;
2145 }
2146
2147 if (!(to_copy = PyUnicode_New(PyUnicode_GET_LENGTH(to),
2148 PyUnicode_MAX_CHAR_VALUE(to)))) {
2149 return NULL;
2150 }
2151 if (PyUnicode_Fill(to_copy, 0, PyUnicode_GET_LENGTH(to_copy), 0U) < 0) {
2152 Py_DECREF(to_copy);
2153 return NULL;
2154 }
2155
2156 if ((copied = PyUnicode_CopyCharacters(to_copy, to_start, from,
2157 from_start, how_many)) < 0) {
2158 Py_DECREF(to_copy);
2159 return NULL;
2160 }
2161
2162 return Py_BuildValue("(Nn)", to_copy, copied);
2163}
2164
2165#if USE_UNICODE_WCHAR_CACHE
2166/* Ignore use of deprecated APIs */
2167_Py_COMP_DIAG_PUSH
2168_Py_COMP_DIAG_IGNORE_DEPR_DECLS
2169
2170static PyObject *
2171unicode_encodedecimal(PyObject *self, PyObject *args)
2172{
2173 Py_UNICODE *unicode;
2174 Py_ssize_t length;
2175 char *errors = NULL;
2176 PyObject *decimal;
2177 Py_ssize_t decimal_length, new_length;
2178 int res;
2179
2180 if (!PyArg_ParseTuple(args, "u#|s", &unicode, &length, &errors))
2181 return NULL;
2182
2183 decimal_length = length * 7; /* len('&#8364;') */
2184 decimal = PyBytes_FromStringAndSize(NULL, decimal_length);
2185 if (decimal == NULL)
2186 return NULL;
2187
2188 res = PyUnicode_EncodeDecimal(unicode, length,
2189 PyBytes_AS_STRING(decimal),
2190 errors);
2191 if (res < 0) {
2192 Py_DECREF(decimal);
2193 return NULL;
2194 }
2195
2196 new_length = strlen(PyBytes_AS_STRING(decimal));
2197 assert(new_length <= decimal_length);
2198 res = _PyBytes_Resize(&decimal, new_length);
2199 if (res < 0)
2200 return NULL;
2201
2202 return decimal;
2203}
2204
2205static PyObject *
2206unicode_transformdecimaltoascii(PyObject *self, PyObject *args)
2207{
2208 Py_UNICODE *unicode;
2209 Py_ssize_t length;
2210 if (!PyArg_ParseTuple(args, "u#|s", &unicode, &length))
2211 return NULL;
2212 return PyUnicode_TransformDecimalToASCII(unicode, length);
2213}
2214
2215static PyObject *
2216unicode_legacy_string(PyObject *self, PyObject *args)
2217{
2218 Py_UNICODE *data;
2219 Py_ssize_t len;
2220 PyObject *u;
2221
2222 if (!PyArg_ParseTuple(args, "u#", &data, &len))
2223 return NULL;
2224
2225 u = PyUnicode_FromUnicode(NULL, len);
2226 if (u == NULL)
2227 return NULL;
2228
2229 memcpy(PyUnicode_AS_UNICODE(u), data, len * sizeof(Py_UNICODE));
2230
2231 if (len > 0) { /* The empty string is always ready. */
2232 assert(!PyUnicode_IS_READY(u));
2233 }
2234
2235 return u;
2236}
2237_Py_COMP_DIAG_POP
2238#endif /* USE_UNICODE_WCHAR_CACHE */
2239
2240static PyObject *
2241getargs_w_star(PyObject *self, PyObject *args)
2242{
2243 Py_buffer buffer;
2244 PyObject *result;
2245 char *str;
2246
2247 if (!PyArg_ParseTuple(args, "w*:getargs_w_star", &buffer))
2248 return NULL;
2249
2250 if (2 <= buffer.len) {
2251 str = buffer.buf;
2252 str[0] = '[';
2253 str[buffer.len-1] = ']';
2254 }
2255
2256 result = PyBytes_FromStringAndSize(buffer.buf, buffer.len);
2257 PyBuffer_Release(&buffer);
2258 return result;
2259}
2260
2261
2262static PyObject *
2263test_empty_argparse(PyObject *self, PyObject *Py_UNUSED(ignored))
2264{
2265 /* Test that formats can begin with '|'. See issue #4720. */
2266 PyObject *tuple, *dict = NULL;
2267 static char *kwlist[] = {NULL};
2268 int result;
2269 tuple = PyTuple_New(0);
2270 if (!tuple)
2271 return NULL;
2272 if (!(result = PyArg_ParseTuple(tuple, "|:test_empty_argparse"))) {
2273 goto done;
2274 }
2275 dict = PyDict_New();
2276 if (!dict)
2277 goto done;
2278 result = PyArg_ParseTupleAndKeywords(tuple, dict, "|:test_empty_argparse", kwlist);
2279 done:
2280 Py_DECREF(tuple);
2281 Py_XDECREF(dict);
2282 if (!result) {
2283 return NULL;
2284 }
2285 else {
2286 Py_RETURN_NONE;
2287 }
2288}
2289
2290static PyObject *
2291codec_incrementalencoder(PyObject *self, PyObject *args)
2292{
2293 const char *encoding, *errors = NULL;
2294 if (!PyArg_ParseTuple(args, "s|s:test_incrementalencoder",
2295 &encoding, &errors))
2296 return NULL;
2297 return PyCodec_IncrementalEncoder(encoding, errors);
2298}
2299
2300static PyObject *
2301codec_incrementaldecoder(PyObject *self, PyObject *args)
2302{
2303 const char *encoding, *errors = NULL;
2304 if (!PyArg_ParseTuple(args, "s|s:test_incrementaldecoder",
2305 &encoding, &errors))
2306 return NULL;
2307 return PyCodec_IncrementalDecoder(encoding, errors);
2308}
2309
2310
2311/* Simple test of _PyLong_NumBits and _PyLong_Sign. */
2312static PyObject *
2313test_long_numbits(PyObject *self, PyObject *Py_UNUSED(ignored))
2314{
2315 struct triple {
2316 long input;
2317 size_t nbits;
2318 int sign;
2319 } testcases[] = {{0, 0, 0},
2320 {1L, 1, 1},
2321 {-1L, 1, -1},
2322 {2L, 2, 1},
2323 {-2L, 2, -1},
2324 {3L, 2, 1},
2325 {-3L, 2, -1},
2326 {4L, 3, 1},
2327 {-4L, 3, -1},
2328 {0x7fffL, 15, 1}, /* one Python int digit */
2329 {-0x7fffL, 15, -1},
2330 {0xffffL, 16, 1},
2331 {-0xffffL, 16, -1},
2332 {0xfffffffL, 28, 1},
2333 {-0xfffffffL, 28, -1}};
2334 size_t i;
2335
2336 for (i = 0; i < Py_ARRAY_LENGTH(testcases); ++i) {
2337 size_t nbits;
2338 int sign;
2339 PyObject *plong;
2340
2341 plong = PyLong_FromLong(testcases[i].input);
2342 if (plong == NULL)
2343 return NULL;
2344 nbits = _PyLong_NumBits(plong);
2345 sign = _PyLong_Sign(plong);
2346
2347 Py_DECREF(plong);
2348 if (nbits != testcases[i].nbits)
2349 return raiseTestError("test_long_numbits",
2350 "wrong result for _PyLong_NumBits");
2351 if (sign != testcases[i].sign)
2352 return raiseTestError("test_long_numbits",
2353 "wrong result for _PyLong_Sign");
2354 }
2355 Py_RETURN_NONE;
2356}
2357
2358static PyObject *
2359pyobject_repr_from_null(PyObject *self, PyObject *Py_UNUSED(ignored))
2360{
2361 return PyObject_Repr(NULL);
2362}
2363
2364static PyObject *
2365pyobject_str_from_null(PyObject *self, PyObject *Py_UNUSED(ignored))
2366{
2367 return PyObject_Str(NULL);
2368}
2369
2370static PyObject *
2371pyobject_bytes_from_null(PyObject *self, PyObject *Py_UNUSED(ignored))
2372{
2373 return PyObject_Bytes(NULL);
2374}
2375
2376static PyObject *
2377raise_exception(PyObject *self, PyObject *args)
2378{
2379 PyObject *exc;
2380 PyObject *exc_args, *v;
2381 int num_args, i;
2382
2383 if (!PyArg_ParseTuple(args, "Oi:raise_exception",
2384 &exc, &num_args))
2385 return NULL;
2386
2387 exc_args = PyTuple_New(num_args);
2388 if (exc_args == NULL)
2389 return NULL;
2390 for (i = 0; i < num_args; ++i) {
2391 v = PyLong_FromLong(i);
2392 if (v == NULL) {
2393 Py_DECREF(exc_args);
2394 return NULL;
2395 }
2396 PyTuple_SET_ITEM(exc_args, i, v);
2397 }
2398 PyErr_SetObject(exc, exc_args);
2399 Py_DECREF(exc_args);
2400 return NULL;
2401}
2402
2403static PyObject *
2404set_errno(PyObject *self, PyObject *args)
2405{
2406 int new_errno;
2407
2408 if (!PyArg_ParseTuple(args, "i:set_errno", &new_errno))
2409 return NULL;
2410
2411 errno = new_errno;
2412 Py_RETURN_NONE;
2413}
2414
2415static PyObject *
2416test_set_exc_info(PyObject *self, PyObject *args)
2417{
2418 PyObject *orig_exc;
2419 PyObject *new_type, *new_value, *new_tb;
2420 PyObject *type, *value, *tb;
2421 if (!PyArg_ParseTuple(args, "OOO:test_set_exc_info",
2422 &new_type, &new_value, &new_tb))
2423 return NULL;
2424
2425 PyErr_GetExcInfo(&type, &value, &tb);
2426
2427 Py_INCREF(new_type);
2428 Py_INCREF(new_value);
2429 Py_INCREF(new_tb);
2430 PyErr_SetExcInfo(new_type, new_value, new_tb);
2431
2432 orig_exc = PyTuple_Pack(3, type ? type : Py_None, value ? value : Py_None, tb ? tb : Py_None);
2433 Py_XDECREF(type);
2434 Py_XDECREF(value);
2435 Py_XDECREF(tb);
2436 return orig_exc;
2437}
2438
2439static int test_run_counter = 0;
2440
2441static PyObject *
2442test_datetime_capi(PyObject *self, PyObject *args) {
2443 if (PyDateTimeAPI) {
2444 if (test_run_counter) {
2445 /* Probably regrtest.py -R */
2446 Py_RETURN_NONE;
2447 }
2448 else {
2449 PyErr_SetString(PyExc_AssertionError,
2450 "PyDateTime_CAPI somehow initialized");
2451 return NULL;
2452 }
2453 }
2454 test_run_counter++;
2455 PyDateTime_IMPORT;
2456
2457 if (PyDateTimeAPI)
2458 Py_RETURN_NONE;
2459 else
2460 return NULL;
2461}
2462
2463/* Functions exposing the C API type checking for testing */
2464#define MAKE_DATETIME_CHECK_FUNC(check_method, exact_method) \
2465 PyObject *obj; \
2466 int exact = 0; \
2467 if (!PyArg_ParseTuple(args, "O|p", &obj, &exact)) { \
2468 return NULL; \
2469 } \
2470 int rv = exact?exact_method(obj):check_method(obj); \
2471 if (rv) { \
2472 Py_RETURN_TRUE; \
2473 } else { \
2474 Py_RETURN_FALSE; \
2475 }
2476
2477static PyObject *
2478datetime_check_date(PyObject *self, PyObject *args) {
2479 MAKE_DATETIME_CHECK_FUNC(PyDate_Check, PyDate_CheckExact)
2480}
2481
2482static PyObject *
2483datetime_check_time(PyObject *self, PyObject *args) {
2484 MAKE_DATETIME_CHECK_FUNC(PyTime_Check, PyTime_CheckExact)
2485}
2486
2487static PyObject *
2488datetime_check_datetime(PyObject *self, PyObject *args) {
2489 MAKE_DATETIME_CHECK_FUNC(PyDateTime_Check, PyDateTime_CheckExact)
2490}
2491
2492static PyObject *
2493datetime_check_delta(PyObject *self, PyObject *args) {
2494 MAKE_DATETIME_CHECK_FUNC(PyDelta_Check, PyDelta_CheckExact)
2495}
2496
2497static PyObject *
2498datetime_check_tzinfo(PyObject *self, PyObject *args) {
2499 MAKE_DATETIME_CHECK_FUNC(PyTZInfo_Check, PyTZInfo_CheckExact)
2500}
2501
2502
2503/* Makes three variations on timezone representing UTC-5:
2504 1. timezone with offset and name from PyDateTimeAPI
2505 2. timezone with offset and name from PyTimeZone_FromOffsetAndName
2506 3. timezone with offset (no name) from PyTimeZone_FromOffset
2507*/
2508static PyObject *
2509make_timezones_capi(PyObject *self, PyObject *args) {
2510 PyObject *offset = PyDelta_FromDSU(0, -18000, 0);
2511 PyObject *name = PyUnicode_FromString("EST");
2512
2513 PyObject *est_zone_capi = PyDateTimeAPI->TimeZone_FromTimeZone(offset, name);
2514 PyObject *est_zone_macro = PyTimeZone_FromOffsetAndName(offset, name);
2515 PyObject *est_zone_macro_noname = PyTimeZone_FromOffset(offset);
2516
2517 Py_DecRef(offset);
2518 Py_DecRef(name);
2519
2520 PyObject *rv = PyTuple_New(3);
2521
2522 PyTuple_SET_ITEM(rv, 0, est_zone_capi);
2523 PyTuple_SET_ITEM(rv, 1, est_zone_macro);
2524 PyTuple_SET_ITEM(rv, 2, est_zone_macro_noname);
2525
2526 return rv;
2527}
2528
2529static PyObject *
2530get_timezones_offset_zero(PyObject *self, PyObject *args) {
2531 PyObject *offset = PyDelta_FromDSU(0, 0, 0);
2532 PyObject *name = PyUnicode_FromString("");
2533
2534 // These two should return the UTC singleton
2535 PyObject *utc_singleton_0 = PyTimeZone_FromOffset(offset);
2536 PyObject *utc_singleton_1 = PyTimeZone_FromOffsetAndName(offset, NULL);
2537
2538 // This one will return +00:00 zone, but not the UTC singleton
2539 PyObject *non_utc_zone = PyTimeZone_FromOffsetAndName(offset, name);
2540
2541 Py_DecRef(offset);
2542 Py_DecRef(name);
2543
2544 PyObject *rv = PyTuple_New(3);
2545 PyTuple_SET_ITEM(rv, 0, utc_singleton_0);
2546 PyTuple_SET_ITEM(rv, 1, utc_singleton_1);
2547 PyTuple_SET_ITEM(rv, 2, non_utc_zone);
2548
2549 return rv;
2550}
2551
2552static PyObject *
2553get_timezone_utc_capi(PyObject* self, PyObject *args) {
2554 int macro = 0;
2555 if (!PyArg_ParseTuple(args, "|p", &macro)) {
2556 return NULL;
2557 }
2558 if (macro) {
2559 Py_INCREF(PyDateTime_TimeZone_UTC);
2560 return PyDateTime_TimeZone_UTC;
2561 } else {
2562 Py_INCREF(PyDateTimeAPI->TimeZone_UTC);
2563 return PyDateTimeAPI->TimeZone_UTC;
2564 }
2565}
2566
2567static PyObject *
2568get_date_fromdate(PyObject *self, PyObject *args)
2569{
2570 PyObject *rv = NULL;
2571 int macro;
2572 int year, month, day;
2573
2574 if (!PyArg_ParseTuple(args, "piii", &macro, &year, &month, &day)) {
2575 return NULL;
2576 }
2577
2578 if (macro) {
2579 rv = PyDate_FromDate(year, month, day);
2580 }
2581 else {
2582 rv = PyDateTimeAPI->Date_FromDate(
2583 year, month, day,
2584 PyDateTimeAPI->DateType);
2585 }
2586 return rv;
2587}
2588
2589static PyObject *
2590get_datetime_fromdateandtime(PyObject *self, PyObject *args)
2591{
2592 PyObject *rv = NULL;
2593 int macro;
2594 int year, month, day;
2595 int hour, minute, second, microsecond;
2596
2597 if (!PyArg_ParseTuple(args, "piiiiiii",
2598 &macro,
2599 &year, &month, &day,
2600 &hour, &minute, &second, &microsecond)) {
2601 return NULL;
2602 }
2603
2604 if (macro) {
2605 rv = PyDateTime_FromDateAndTime(
2606 year, month, day,
2607 hour, minute, second, microsecond);
2608 }
2609 else {
2610 rv = PyDateTimeAPI->DateTime_FromDateAndTime(
2611 year, month, day,
2612 hour, minute, second, microsecond,
2613 Py_None,
2614 PyDateTimeAPI->DateTimeType);
2615 }
2616 return rv;
2617}
2618
2619static PyObject *
2620get_datetime_fromdateandtimeandfold(PyObject *self, PyObject *args)
2621{
2622 PyObject *rv = NULL;
2623 int macro;
2624 int year, month, day;
2625 int hour, minute, second, microsecond, fold;
2626
2627 if (!PyArg_ParseTuple(args, "piiiiiiii",
2628 &macro,
2629 &year, &month, &day,
2630 &hour, &minute, &second, &microsecond,
2631 &fold)) {
2632 return NULL;
2633 }
2634
2635 if (macro) {
2636 rv = PyDateTime_FromDateAndTimeAndFold(
2637 year, month, day,
2638 hour, minute, second, microsecond,
2639 fold);
2640 }
2641 else {
2642 rv = PyDateTimeAPI->DateTime_FromDateAndTimeAndFold(
2643 year, month, day,
2644 hour, minute, second, microsecond,
2645 Py_None,
2646 fold,
2647 PyDateTimeAPI->DateTimeType);
2648 }
2649 return rv;
2650}
2651
2652static PyObject *
2653get_time_fromtime(PyObject *self, PyObject *args)
2654{
2655 PyObject *rv = NULL;
2656 int macro;
2657 int hour, minute, second, microsecond;
2658
2659 if (!PyArg_ParseTuple(args, "piiii",
2660 &macro,
2661 &hour, &minute, &second, &microsecond)) {
2662 return NULL;
2663 }
2664
2665 if (macro) {
2666 rv = PyTime_FromTime(hour, minute, second, microsecond);
2667 }
2668 else {
2669 rv = PyDateTimeAPI->Time_FromTime(
2670 hour, minute, second, microsecond,
2671 Py_None,
2672 PyDateTimeAPI->TimeType);
2673 }
2674 return rv;
2675}
2676
2677static PyObject *
2678get_time_fromtimeandfold(PyObject *self, PyObject *args)
2679{
2680 PyObject *rv = NULL;
2681 int macro;
2682 int hour, minute, second, microsecond, fold;
2683
2684 if (!PyArg_ParseTuple(args, "piiiii",
2685 &macro,
2686 &hour, &minute, &second, &microsecond,
2687 &fold)) {
2688 return NULL;
2689 }
2690
2691 if (macro) {
2692 rv = PyTime_FromTimeAndFold(hour, minute, second, microsecond, fold);
2693 }
2694 else {
2695 rv = PyDateTimeAPI->Time_FromTimeAndFold(
2696 hour, minute, second, microsecond,
2697 Py_None,
2698 fold,
2699 PyDateTimeAPI->TimeType);
2700 }
2701 return rv;
2702}
2703
2704static PyObject *
2705get_delta_fromdsu(PyObject *self, PyObject *args)
2706{
2707 PyObject *rv = NULL;
2708 int macro;
2709 int days, seconds, microseconds;
2710
2711 if (!PyArg_ParseTuple(args, "piii",
2712 &macro,
2713 &days, &seconds, &microseconds)) {
2714 return NULL;
2715 }
2716
2717 if (macro) {
2718 rv = PyDelta_FromDSU(days, seconds, microseconds);
2719 }
2720 else {
2721 rv = PyDateTimeAPI->Delta_FromDelta(
2722 days, seconds, microseconds, 1,
2723 PyDateTimeAPI->DeltaType);
2724 }
2725
2726 return rv;
2727}
2728
2729static PyObject *
2730get_date_fromtimestamp(PyObject* self, PyObject *args)
2731{
2732 PyObject *tsargs = NULL, *ts = NULL, *rv = NULL;
2733 int macro = 0;
2734
2735 if (!PyArg_ParseTuple(args, "O|p", &ts, &macro)) {
2736 return NULL;
2737 }
2738
2739 // Construct the argument tuple
2740 if ((tsargs = PyTuple_Pack(1, ts)) == NULL) {
2741 return NULL;
2742 }
2743
2744 // Pass along to the API function
2745 if (macro) {
2746 rv = PyDate_FromTimestamp(tsargs);
2747 }
2748 else {
2749 rv = PyDateTimeAPI->Date_FromTimestamp(
2750 (PyObject *)PyDateTimeAPI->DateType, tsargs
2751 );
2752 }
2753
2754 Py_DECREF(tsargs);
2755 return rv;
2756}
2757
2758static PyObject *
2759get_datetime_fromtimestamp(PyObject* self, PyObject *args)
2760{
2761 int macro = 0;
2762 int usetz = 0;
2763 PyObject *tsargs = NULL, *ts = NULL, *tzinfo = Py_None, *rv = NULL;
2764 if (!PyArg_ParseTuple(args, "OO|pp", &ts, &tzinfo, &usetz, &macro)) {
2765 return NULL;
2766 }
2767
2768 // Construct the argument tuple
2769 if (usetz) {
2770 tsargs = PyTuple_Pack(2, ts, tzinfo);
2771 }
2772 else {
2773 tsargs = PyTuple_Pack(1, ts);
2774 }
2775
2776 if (tsargs == NULL) {
2777 return NULL;
2778 }
2779
2780 // Pass along to the API function
2781 if (macro) {
2782 rv = PyDateTime_FromTimestamp(tsargs);
2783 }
2784 else {
2785 rv = PyDateTimeAPI->DateTime_FromTimestamp(
2786 (PyObject *)PyDateTimeAPI->DateTimeType, tsargs, NULL
2787 );
2788 }
2789
2790 Py_DECREF(tsargs);
2791 return rv;
2792}
2793
2794static PyObject *
2795test_PyDateTime_GET(PyObject *self, PyObject *obj)
2796{
2797 int year, month, day;
2798
2799 year = PyDateTime_GET_YEAR(obj);
2800 month = PyDateTime_GET_MONTH(obj);
2801 day = PyDateTime_GET_DAY(obj);
2802
2803 return Py_BuildValue("(lll)", year, month, day);
2804}
2805
2806static PyObject *
2807test_PyDateTime_DATE_GET(PyObject *self, PyObject *obj)
2808{
2809 int hour, minute, second, microsecond;
2810
2811 hour = PyDateTime_DATE_GET_HOUR(obj);
2812 minute = PyDateTime_DATE_GET_MINUTE(obj);
2813 second = PyDateTime_DATE_GET_SECOND(obj);
2814 microsecond = PyDateTime_DATE_GET_MICROSECOND(obj);
2815 PyObject *tzinfo = PyDateTime_DATE_GET_TZINFO(obj);
2816
2817 return Py_BuildValue("(llllO)", hour, minute, second, microsecond, tzinfo);
2818}
2819
2820static PyObject *
2821test_PyDateTime_TIME_GET(PyObject *self, PyObject *obj)
2822{
2823 int hour, minute, second, microsecond;
2824
2825 hour = PyDateTime_TIME_GET_HOUR(obj);
2826 minute = PyDateTime_TIME_GET_MINUTE(obj);
2827 second = PyDateTime_TIME_GET_SECOND(obj);
2828 microsecond = PyDateTime_TIME_GET_MICROSECOND(obj);
2829 PyObject *tzinfo = PyDateTime_TIME_GET_TZINFO(obj);
2830
2831 return Py_BuildValue("(llllO)", hour, minute, second, microsecond, tzinfo);
2832}
2833
2834static PyObject *
2835test_PyDateTime_DELTA_GET(PyObject *self, PyObject *obj)
2836{
2837 int days, seconds, microseconds;
2838
2839 days = PyDateTime_DELTA_GET_DAYS(obj);
2840 seconds = PyDateTime_DELTA_GET_SECONDS(obj);
2841 microseconds = PyDateTime_DELTA_GET_MICROSECONDS(obj);
2842
2843 return Py_BuildValue("(lll)", days, seconds, microseconds);
2844}
2845
2846/* test_thread_state spawns a thread of its own, and that thread releases
2847 * `thread_done` when it's finished. The driver code has to know when the
2848 * thread finishes, because the thread uses a PyObject (the callable) that
2849 * may go away when the driver finishes. The former lack of this explicit
2850 * synchronization caused rare segfaults, so rare that they were seen only
2851 * on a Mac buildbot (although they were possible on any box).
2852 */
2853static PyThread_type_lock thread_done = NULL;
2854
2855static int
2856_make_call(void *callable)
2857{
2858 PyObject *rc;
2859 int success;
2860 PyGILState_STATE s = PyGILState_Ensure();
2861 rc = _PyObject_CallNoArg((PyObject *)callable);
2862 success = (rc != NULL);
2863 Py_XDECREF(rc);
2864 PyGILState_Release(s);
2865 return success;
2866}
2867
2868/* Same thing, but releases `thread_done` when it returns. This variant
2869 * should be called only from threads spawned by test_thread_state().
2870 */
2871static void
2872_make_call_from_thread(void *callable)
2873{
2874 _make_call(callable);
2875 PyThread_release_lock(thread_done);
2876}
2877
2878static PyObject *
2879test_thread_state(PyObject *self, PyObject *args)
2880{
2881 PyObject *fn;
2882 int success = 1;
2883
2884 if (!PyArg_ParseTuple(args, "O:test_thread_state", &fn))
2885 return NULL;
2886
2887 if (!PyCallable_Check(fn)) {
2888 PyErr_Format(PyExc_TypeError, "'%s' object is not callable",
2889 Py_TYPE(fn)->tp_name);
2890 return NULL;
2891 }
2892
2893 thread_done = PyThread_allocate_lock();
2894 if (thread_done == NULL)
2895 return PyErr_NoMemory();
2896 PyThread_acquire_lock(thread_done, 1);
2897
2898 /* Start a new thread with our callback. */
2899 PyThread_start_new_thread(_make_call_from_thread, fn);
2900 /* Make the callback with the thread lock held by this thread */
2901 success &= _make_call(fn);
2902 /* Do it all again, but this time with the thread-lock released */
2903 Py_BEGIN_ALLOW_THREADS
2904 success &= _make_call(fn);
2905 PyThread_acquire_lock(thread_done, 1); /* wait for thread to finish */
2906 Py_END_ALLOW_THREADS
2907
2908 /* And once more with and without a thread
2909 XXX - should use a lock and work out exactly what we are trying
2910 to test <wink>
2911 */
2912 Py_BEGIN_ALLOW_THREADS
2913 PyThread_start_new_thread(_make_call_from_thread, fn);
2914 success &= _make_call(fn);
2915 PyThread_acquire_lock(thread_done, 1); /* wait for thread to finish */
2916 Py_END_ALLOW_THREADS
2917
2918 /* Release lock we acquired above. This is required on HP-UX. */
2919 PyThread_release_lock(thread_done);
2920
2921 PyThread_free_lock(thread_done);
2922 if (!success)
2923 return NULL;
2924 Py_RETURN_NONE;
2925}
2926
2927/* test Py_AddPendingCalls using threads */
2928static int _pending_callback(void *arg)
2929{
2930 /* we assume the argument is callable object to which we own a reference */
2931 PyObject *callable = (PyObject *)arg;
2932 PyObject *r = _PyObject_CallNoArg(callable);
2933 Py_DECREF(callable);
2934 Py_XDECREF(r);
2935 return r != NULL ? 0 : -1;
2936}
2937
2938/* The following requests n callbacks to _pending_callback. It can be
2939 * run from any python thread.
2940 */
2941static PyObject *
2942pending_threadfunc(PyObject *self, PyObject *arg)
2943{
2944 PyObject *callable;
2945 int r;
2946 if (PyArg_ParseTuple(arg, "O", &callable) == 0)
2947 return NULL;
2948
2949 /* create the reference for the callbackwhile we hold the lock */
2950 Py_INCREF(callable);
2951
2952 Py_BEGIN_ALLOW_THREADS
2953 r = Py_AddPendingCall(&_pending_callback, callable);
2954 Py_END_ALLOW_THREADS
2955
2956 if (r<0) {
2957 Py_DECREF(callable); /* unsuccessful add, destroy the extra reference */
2958 Py_RETURN_FALSE;
2959 }
2960 Py_RETURN_TRUE;
2961}
2962
2963/* Some tests of PyUnicode_FromFormat(). This needs more tests. */
2964static PyObject *
2965test_string_from_format(PyObject *self, PyObject *Py_UNUSED(ignored))
2966{
2967 PyObject *result;
2968 char *msg;
2969
2970#define CHECK_1_FORMAT(FORMAT, TYPE) \
2971 result = PyUnicode_FromFormat(FORMAT, (TYPE)1); \
2972 if (result == NULL) \
2973 return NULL; \
2974 if (!_PyUnicode_EqualToASCIIString(result, "1")) { \
2975 msg = FORMAT " failed at 1"; \
2976 goto Fail; \
2977 } \
2978 Py_DECREF(result)
2979
2980 CHECK_1_FORMAT("%d", int);
2981 CHECK_1_FORMAT("%ld", long);
2982 /* The z width modifier was added in Python 2.5. */
2983 CHECK_1_FORMAT("%zd", Py_ssize_t);
2984
2985 /* The u type code was added in Python 2.5. */
2986 CHECK_1_FORMAT("%u", unsigned int);
2987 CHECK_1_FORMAT("%lu", unsigned long);
2988 CHECK_1_FORMAT("%zu", size_t);
2989
2990 /* "%lld" and "%llu" support added in Python 2.7. */
2991 CHECK_1_FORMAT("%llu", unsigned long long);
2992 CHECK_1_FORMAT("%lld", long long);
2993
2994 Py_RETURN_NONE;
2995
2996 Fail:
2997 Py_XDECREF(result);
2998 return raiseTestError("test_string_from_format", msg);
2999
3000#undef CHECK_1_FORMAT
3001}
3002
3003
3004static PyObject *
3005test_unicode_compare_with_ascii(PyObject *self, PyObject *Py_UNUSED(ignored)) {
3006 PyObject *py_s = PyUnicode_FromStringAndSize("str\0", 4);
3007 int result;
3008 if (py_s == NULL)
3009 return NULL;
3010 result = PyUnicode_CompareWithASCIIString(py_s, "str");
3011 Py_DECREF(py_s);
3012 if (!result) {
3013 PyErr_SetString(TestError, "Python string ending in NULL "
3014 "should not compare equal to c string.");
3015 return NULL;
3016 }
3017 Py_RETURN_NONE;
3018}
3019
3020/* This is here to provide a docstring for test_descr. */
3021static PyObject *
3022test_with_docstring(PyObject *self, PyObject *Py_UNUSED(ignored))
3023{
3024 Py_RETURN_NONE;
3025}
3026
3027/* Test PyOS_string_to_double. */
3028static PyObject *
3029test_string_to_double(PyObject *self, PyObject *Py_UNUSED(ignored)) {
3030 double result;
3031 const char *msg;
3032
3033#define CHECK_STRING(STR, expected) \
3034 result = PyOS_string_to_double(STR, NULL, NULL); \
3035 if (result == -1.0 && PyErr_Occurred()) \
3036 return NULL; \
3037 if (result != (double)expected) { \
3038 msg = "conversion of " STR " to float failed"; \
3039 goto fail; \
3040 }
3041
3042#define CHECK_INVALID(STR) \
3043 result = PyOS_string_to_double(STR, NULL, NULL); \
3044 if (result == -1.0 && PyErr_Occurred()) { \
3045 if (PyErr_ExceptionMatches(PyExc_ValueError)) \
3046 PyErr_Clear(); \
3047 else \
3048 return NULL; \
3049 } \
3050 else { \
3051 msg = "conversion of " STR " didn't raise ValueError"; \
3052 goto fail; \
3053 }
3054
3055 CHECK_STRING("0.1", 0.1);
3056 CHECK_STRING("1.234", 1.234);
3057 CHECK_STRING("-1.35", -1.35);
3058 CHECK_STRING(".1e01", 1.0);
3059 CHECK_STRING("2.e-2", 0.02);
3060
3061 CHECK_INVALID(" 0.1");
3062 CHECK_INVALID("\t\n-3");
3063 CHECK_INVALID(".123 ");
3064 CHECK_INVALID("3\n");
3065 CHECK_INVALID("123abc");
3066
3067 Py_RETURN_NONE;
3068 fail:
3069 return raiseTestError("test_string_to_double", msg);
3070#undef CHECK_STRING
3071#undef CHECK_INVALID
3072}
3073
3074
3075/* Coverage testing of capsule objects. */
3076
3077static const char *capsule_name = "capsule name";
3078static char *capsule_pointer = "capsule pointer";
3079static char *capsule_context = "capsule context";
3080static const char *capsule_error = NULL;
3081static int
3082capsule_destructor_call_count = 0;
3083
3084static void
3085capsule_destructor(PyObject *o) {
3086 capsule_destructor_call_count++;
3087 if (PyCapsule_GetContext(o) != capsule_context) {
3088 capsule_error = "context did not match in destructor!";
3089 } else if (PyCapsule_GetDestructor(o) != capsule_destructor) {
3090 capsule_error = "destructor did not match in destructor! (woah!)";
3091 } else if (PyCapsule_GetName(o) != capsule_name) {
3092 capsule_error = "name did not match in destructor!";
3093 } else if (PyCapsule_GetPointer(o, capsule_name) != capsule_pointer) {
3094 capsule_error = "pointer did not match in destructor!";
3095 }
3096}
3097
3098typedef struct {
3099 char *name;
3100 char *module;
3101 char *attribute;
3102} known_capsule;
3103
3104static PyObject *
3105test_capsule(PyObject *self, PyObject *Py_UNUSED(ignored))
3106{
3107 PyObject *object;
3108 const char *error = NULL;
3109 void *pointer;
3110 void *pointer2;
3111 known_capsule known_capsules[] = {
3112 #define KNOWN_CAPSULE(module, name) { module "." name, module, name }
3113 KNOWN_CAPSULE("_socket", "CAPI"),
3114 KNOWN_CAPSULE("_curses", "_C_API"),
3115 KNOWN_CAPSULE("datetime", "datetime_CAPI"),
3116 { NULL, NULL },
3117 };
3118 known_capsule *known = &known_capsules[0];
3119
3120#define FAIL(x) { error = (x); goto exit; }
3121
3122#define CHECK_DESTRUCTOR \
3123 if (capsule_error) { \
3124 FAIL(capsule_error); \
3125 } \
3126 else if (!capsule_destructor_call_count) { \
3127 FAIL("destructor not called!"); \
3128 } \
3129 capsule_destructor_call_count = 0; \
3130
3131 object = PyCapsule_New(capsule_pointer, capsule_name, capsule_destructor);
3132 PyCapsule_SetContext(object, capsule_context);
3133 capsule_destructor(object);
3134 CHECK_DESTRUCTOR;
3135 Py_DECREF(object);
3136 CHECK_DESTRUCTOR;
3137
3138 object = PyCapsule_New(known, "ignored", NULL);
3139 PyCapsule_SetPointer(object, capsule_pointer);
3140 PyCapsule_SetName(object, capsule_name);
3141 PyCapsule_SetDestructor(object, capsule_destructor);
3142 PyCapsule_SetContext(object, capsule_context);
3143 capsule_destructor(object);
3144 CHECK_DESTRUCTOR;
3145 /* intentionally access using the wrong name */
3146 pointer2 = PyCapsule_GetPointer(object, "the wrong name");
3147 if (!PyErr_Occurred()) {
3148 FAIL("PyCapsule_GetPointer should have failed but did not!");
3149 }
3150 PyErr_Clear();
3151 if (pointer2) {
3152 if (pointer2 == capsule_pointer) {
3153 FAIL("PyCapsule_GetPointer should not have"
3154 " returned the internal pointer!");
3155 } else {
3156 FAIL("PyCapsule_GetPointer should have "
3157 "returned NULL pointer but did not!");
3158 }
3159 }
3160 PyCapsule_SetDestructor(object, NULL);
3161 Py_DECREF(object);
3162 if (capsule_destructor_call_count) {
3163 FAIL("destructor called when it should not have been!");
3164 }
3165
3166 for (known = &known_capsules[0]; known->module != NULL; known++) {
3167 /* yeah, ordinarily I wouldn't do this either,
3168 but it's fine for this test harness.
3169 */
3170 static char buffer[256];
3171#undef FAIL
3172#define FAIL(x) \
3173 { \
3174 sprintf(buffer, "%s module: \"%s\" attribute: \"%s\"", \
3175 x, known->module, known->attribute); \
3176 error = buffer; \
3177 goto exit; \
3178 } \
3179
3180 PyObject *module = PyImport_ImportModule(known->module);
3181 if (module) {
3182 pointer = PyCapsule_Import(known->name, 0);
3183 if (!pointer) {
3184 Py_DECREF(module);
3185 FAIL("PyCapsule_GetPointer returned NULL unexpectedly!");
3186 }
3187 object = PyObject_GetAttrString(module, known->attribute);
3188 if (!object) {
3189 Py_DECREF(module);
3190 return NULL;
3191 }
3192 pointer2 = PyCapsule_GetPointer(object,
3193 "weebles wobble but they don't fall down");
3194 if (!PyErr_Occurred()) {
3195 Py_DECREF(object);
3196 Py_DECREF(module);
3197 FAIL("PyCapsule_GetPointer should have failed but did not!");
3198 }
3199 PyErr_Clear();
3200 if (pointer2) {
3201 Py_DECREF(module);
3202 Py_DECREF(object);
3203 if (pointer2 == pointer) {
3204 FAIL("PyCapsule_GetPointer should not have"
3205 " returned its internal pointer!");
3206 } else {
3207 FAIL("PyCapsule_GetPointer should have"
3208 " returned NULL pointer but did not!");
3209 }
3210 }
3211 Py_DECREF(object);
3212 Py_DECREF(module);
3213 }
3214 else
3215 PyErr_Clear();
3216 }
3217
3218 exit:
3219 if (error) {
3220 return raiseTestError("test_capsule", error);
3221 }
3222 Py_RETURN_NONE;
3223#undef FAIL
3224}
3225
3226#ifdef HAVE_GETTIMEOFDAY
3227/* Profiling of integer performance */
3228static void print_delta(int test, struct timeval *s, struct timeval *e)
3229{
3230 e->tv_sec -= s->tv_sec;
3231 e->tv_usec -= s->tv_usec;
3232 if (e->tv_usec < 0) {
3233 e->tv_sec -=1;
3234 e->tv_usec += 1000000;
3235 }
3236 printf("Test %d: %d.%06ds\n", test, (int)e->tv_sec, (int)e->tv_usec);
3237}
3238
3239static PyObject *
3240profile_int(PyObject *self, PyObject* args)
3241{
3242 int i, k;
3243 struct timeval start, stop;
3244 PyObject *single, **multiple, *op1, *result;
3245
3246 /* Test 1: Allocate and immediately deallocate
3247 many small integers */
3248 gettimeofday(&start, NULL);
3249 for(k=0; k < 20000; k++)
3250 for(i=0; i < 1000; i++) {
3251 single = PyLong_FromLong(i);
3252 Py_DECREF(single);
3253 }
3254 gettimeofday(&stop, NULL);
3255 print_delta(1, &start, &stop);
3256
3257 /* Test 2: Allocate and immediately deallocate
3258 many large integers */
3259 gettimeofday(&start, NULL);
3260 for(k=0; k < 20000; k++)
3261 for(i=0; i < 1000; i++) {
3262 single = PyLong_FromLong(i+1000000);
3263 Py_DECREF(single);
3264 }
3265 gettimeofday(&stop, NULL);
3266 print_delta(2, &start, &stop);
3267
3268 /* Test 3: Allocate a few integers, then release
3269 them all simultaneously. */
3270 multiple = malloc(sizeof(PyObject*) * 1000);
3271 if (multiple == NULL)
3272 return PyErr_NoMemory();
3273 gettimeofday(&start, NULL);
3274 for(k=0; k < 20000; k++) {
3275 for(i=0; i < 1000; i++) {
3276 multiple[i] = PyLong_FromLong(i+1000000);
3277 }
3278 for(i=0; i < 1000; i++) {
3279 Py_DECREF(multiple[i]);
3280 }
3281 }
3282 gettimeofday(&stop, NULL);
3283 print_delta(3, &start, &stop);
3284 free(multiple);
3285
3286 /* Test 4: Allocate many integers, then release
3287 them all simultaneously. */
3288 multiple = malloc(sizeof(PyObject*) * 1000000);
3289 if (multiple == NULL)
3290 return PyErr_NoMemory();
3291 gettimeofday(&start, NULL);
3292 for(k=0; k < 20; k++) {
3293 for(i=0; i < 1000000; i++) {
3294 multiple[i] = PyLong_FromLong(i+1000000);
3295 }
3296 for(i=0; i < 1000000; i++) {
3297 Py_DECREF(multiple[i]);
3298 }
3299 }
3300 gettimeofday(&stop, NULL);
3301 print_delta(4, &start, &stop);
3302 free(multiple);
3303
3304 /* Test 5: Allocate many integers < 32000 */
3305 multiple = malloc(sizeof(PyObject*) * 1000000);
3306 if (multiple == NULL)
3307 return PyErr_NoMemory();
3308 gettimeofday(&start, NULL);
3309 for(k=0; k < 10; k++) {
3310 for(i=0; i < 1000000; i++) {
3311 multiple[i] = PyLong_FromLong(i+1000);
3312 }
3313 for(i=0; i < 1000000; i++) {
3314 Py_DECREF(multiple[i]);
3315 }
3316 }
3317 gettimeofday(&stop, NULL);
3318 print_delta(5, &start, &stop);
3319 free(multiple);
3320
3321 /* Test 6: Perform small int addition */
3322 op1 = PyLong_FromLong(1);
3323 gettimeofday(&start, NULL);
3324 for(i=0; i < 10000000; i++) {
3325 result = PyNumber_Add(op1, op1);
3326 Py_DECREF(result);
3327 }
3328 gettimeofday(&stop, NULL);
3329 Py_DECREF(op1);
3330 print_delta(6, &start, &stop);
3331
3332 /* Test 7: Perform medium int addition */
3333 op1 = PyLong_FromLong(1000);
3334 if (op1 == NULL)
3335 return NULL;
3336 gettimeofday(&start, NULL);
3337 for(i=0; i < 10000000; i++) {
3338 result = PyNumber_Add(op1, op1);
3339 Py_XDECREF(result);
3340 }
3341 gettimeofday(&stop, NULL);
3342 Py_DECREF(op1);
3343 print_delta(7, &start, &stop);
3344
3345 Py_RETURN_NONE;
3346}
3347#endif
3348
3349/* To test the format of tracebacks as printed out. */
3350static PyObject *
3351traceback_print(PyObject *self, PyObject *args)
3352{
3353 PyObject *file;
3354 PyObject *traceback;
3355 int result;
3356
3357 if (!PyArg_ParseTuple(args, "OO:traceback_print",
3358 &traceback, &file))
3359 return NULL;
3360
3361 result = PyTraceBack_Print(traceback, file);
3362 if (result < 0)
3363 return NULL;
3364 Py_RETURN_NONE;
3365}
3366
3367/* To test the format of exceptions as printed out. */
3368static PyObject *
3369exception_print(PyObject *self, PyObject *args)
3370{
3371 PyObject *value;
3372 PyObject *tb;
3373
3374 if (!PyArg_ParseTuple(args, "O:exception_print",
3375 &value))
3376 return NULL;
3377 if (!PyExceptionInstance_Check(value)) {
3378 PyErr_Format(PyExc_TypeError, "an exception instance is required");
3379 return NULL;
3380 }
3381
3382 tb = PyException_GetTraceback(value);
3383 PyErr_Display((PyObject *) Py_TYPE(value), value, tb);
3384 Py_XDECREF(tb);
3385
3386 Py_RETURN_NONE;
3387}
3388
3389
3390
3391
3392/* reliably raise a MemoryError */
3393static PyObject *
3394raise_memoryerror(PyObject *self, PyObject *Py_UNUSED(ignored))
3395{
3396 PyErr_NoMemory();
3397 return NULL;
3398}
3399
3400/* Issue 6012 */
3401static PyObject *str1, *str2;
3402static int
3403failing_converter(PyObject *obj, void *arg)
3404{
3405 /* Clone str1, then let the conversion fail. */
3406 assert(str1);
3407 str2 = str1;
3408 Py_INCREF(str2);
3409 return 0;
3410}
3411static PyObject*
3412argparsing(PyObject *o, PyObject *args)
3413{
3414 PyObject *res;
3415 str1 = str2 = NULL;
3416 if (!PyArg_ParseTuple(args, "O&O&",
3417 PyUnicode_FSConverter, &str1,
3418 failing_converter, &str2)) {
3419 if (!str2)
3420 /* argument converter not called? */
3421 return NULL;
3422 /* Should be 1 */
3423 res = PyLong_FromSsize_t(Py_REFCNT(str2));
3424 Py_DECREF(str2);
3425 PyErr_Clear();
3426 return res;
3427 }
3428 Py_RETURN_NONE;
3429}
3430
3431/* To test that the result of PyCode_NewEmpty has the right members. */
3432static PyObject *
3433code_newempty(PyObject *self, PyObject *args)
3434{
3435 const char *filename;
3436 const char *funcname;
3437 int firstlineno;
3438
3439 if (!PyArg_ParseTuple(args, "ssi:code_newempty",
3440 &filename, &funcname, &firstlineno))
3441 return NULL;
3442
3443 return (PyObject *)PyCode_NewEmpty(filename, funcname, firstlineno);
3444}
3445
3446/* Test PyErr_NewExceptionWithDoc (also exercise PyErr_NewException).
3447 Run via Lib/test/test_exceptions.py */
3448static PyObject *
3449make_exception_with_doc(PyObject *self, PyObject *args, PyObject *kwargs)
3450{
3451 const char *name;
3452 const char *doc = NULL;
3453 PyObject *base = NULL;
3454 PyObject *dict = NULL;
3455
3456 static char *kwlist[] = {"name", "doc", "base", "dict", NULL};
3457
3458 if (!PyArg_ParseTupleAndKeywords(args, kwargs,
3459 "s|sOO:make_exception_with_doc", kwlist,
3460 &name, &doc, &base, &dict))
3461 return NULL;
3462
3463 return PyErr_NewExceptionWithDoc(name, doc, base, dict);
3464}
3465
3466static PyObject *
3467make_memoryview_from_NULL_pointer(PyObject *self, PyObject *Py_UNUSED(ignored))
3468{
3469 Py_buffer info;
3470 if (PyBuffer_FillInfo(&info, NULL, NULL, 1, 1, PyBUF_FULL_RO) < 0)
3471 return NULL;
3472 return PyMemoryView_FromBuffer(&info);
3473}
3474
3475static PyObject *
3476test_from_contiguous(PyObject* self, PyObject *Py_UNUSED(ignored))
3477{
3478 int data[9] = {-1,-1,-1,-1,-1,-1,-1,-1,-1};
3479 int init[5] = {0, 1, 2, 3, 4};
3480 Py_ssize_t itemsize = sizeof(int);
3481 Py_ssize_t shape = 5;
3482 Py_ssize_t strides = 2 * itemsize;
3483 Py_buffer view = {
3484 data,
3485 NULL,
3486 5 * itemsize,
3487 itemsize,
3488 1,
3489 1,
3490 NULL,
3491 &shape,
3492 &strides,
3493 NULL,
3494 NULL
3495 };
3496 int *ptr;
3497 int i;
3498
3499 PyBuffer_FromContiguous(&view, init, view.len, 'C');
3500 ptr = view.buf;
3501 for (i = 0; i < 5; i++) {
3502 if (ptr[2*i] != i) {
3503 PyErr_SetString(TestError,
3504 "test_from_contiguous: incorrect result");
3505 return NULL;
3506 }
3507 }
3508
3509 view.buf = &data[8];
3510 view.strides[0] = -2 * itemsize;
3511
3512 PyBuffer_FromContiguous(&view, init, view.len, 'C');
3513 ptr = view.buf;
3514 for (i = 0; i < 5; i++) {
3515 if (*(ptr-2*i) != i) {
3516 PyErr_SetString(TestError,
3517 "test_from_contiguous: incorrect result");
3518 return NULL;
3519 }
3520 }
3521
3522 Py_RETURN_NONE;
3523}
3524
3525#if (defined(__linux__) || defined(__FreeBSD__)) && defined(__GNUC__)
3526extern PyTypeObject _PyBytesIOBuffer_Type;
3527
3528static PyObject *
3529test_pep3118_obsolete_write_locks(PyObject* self, PyObject *Py_UNUSED(ignored))
3530{
3531 PyTypeObject *type = &_PyBytesIOBuffer_Type;
3532 PyObject *b;
3533 char *dummy[1];
3534 int ret, match;
3535
3536 /* PyBuffer_FillInfo() */
3537 ret = PyBuffer_FillInfo(NULL, NULL, dummy, 1, 0, PyBUF_SIMPLE);
3538 match = PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_BufferError);
3539 PyErr_Clear();
3540 if (ret != -1 || match == 0)
3541 goto error;
3542
3543 /* bytesiobuf_getbuffer() */
3544 b = type->tp_alloc(type, 0);
3545 if (b == NULL) {
3546 return NULL;
3547 }
3548
3549 ret = PyObject_GetBuffer(b, NULL, PyBUF_SIMPLE);
3550 Py_DECREF(b);
3551 match = PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_BufferError);
3552 PyErr_Clear();
3553 if (ret != -1 || match == 0)
3554 goto error;
3555
3556 Py_RETURN_NONE;
3557
3558error:
3559 PyErr_SetString(TestError,
3560 "test_pep3118_obsolete_write_locks: failure");
3561 return NULL;
3562}
3563#endif
3564
3565/* This tests functions that historically supported write locks. It is
3566 wrong to call getbuffer() with view==NULL and a compliant getbufferproc
3567 is entitled to segfault in that case. */
3568static PyObject *
3569getbuffer_with_null_view(PyObject* self, PyObject *obj)
3570{
3571 if (PyObject_GetBuffer(obj, NULL, PyBUF_SIMPLE) < 0)
3572 return NULL;
3573
3574 Py_RETURN_NONE;
3575}
3576
3577/* PyBuffer_SizeFromFormat() */
3578static PyObject *
3579test_PyBuffer_SizeFromFormat(PyObject *self, PyObject *args)
3580{
3581 const char *format;
3582 Py_ssize_t result;
3583
3584 if (!PyArg_ParseTuple(args, "s:test_PyBuffer_SizeFromFormat",
3585 &format)) {
3586 return NULL;
3587 }
3588
3589 result = PyBuffer_SizeFromFormat(format);
3590 if (result == -1) {
3591 return NULL;
3592 }
3593
3594 return PyLong_FromSsize_t(result);
3595}
3596
3597/* Test that the fatal error from not having a current thread doesn't
3598 cause an infinite loop. Run via Lib/test/test_capi.py */
3599static PyObject *
3600crash_no_current_thread(PyObject *self, PyObject *Py_UNUSED(ignored))
3601{
3602 Py_BEGIN_ALLOW_THREADS
3603 /* Using PyThreadState_Get() directly allows the test to pass in
3604 !pydebug mode. However, the test only actually tests anything
3605 in pydebug mode, since that's where the infinite loop was in
3606 the first place. */
3607 PyThreadState_Get();
3608 Py_END_ALLOW_THREADS
3609 return NULL;
3610}
3611
3612/* To run some code in a sub-interpreter. */
3613static PyObject *
3614run_in_subinterp(PyObject *self, PyObject *args)
3615{
3616 const char *code;
3617 int r;
3618 PyThreadState *substate, *mainstate;
3619 /* only initialise 'cflags.cf_flags' to test backwards compatibility */
3620 PyCompilerFlags cflags = {0};
3621
3622 if (!PyArg_ParseTuple(args, "s:run_in_subinterp",
3623 &code))
3624 return NULL;
3625
3626 mainstate = PyThreadState_Get();
3627
3628 PyThreadState_Swap(NULL);
3629
3630 substate = Py_NewInterpreter();
3631 if (substate == NULL) {
3632 /* Since no new thread state was created, there is no exception to
3633 propagate; raise a fresh one after swapping in the old thread
3634 state. */
3635 PyThreadState_Swap(mainstate);
3636 PyErr_SetString(PyExc_RuntimeError, "sub-interpreter creation failed");
3637 return NULL;
3638 }
3639 r = PyRun_SimpleStringFlags(code, &cflags);
3640 Py_EndInterpreter(substate);
3641
3642 PyThreadState_Swap(mainstate);
3643
3644 return PyLong_FromLong(r);
3645}
3646
3647static int
3648check_time_rounding(int round)
3649{
3650 if (round != _PyTime_ROUND_FLOOR
3651 && round != _PyTime_ROUND_CEILING
3652 && round != _PyTime_ROUND_HALF_EVEN
3653 && round != _PyTime_ROUND_UP) {
3654 PyErr_SetString(PyExc_ValueError, "invalid rounding");
3655 return -1;
3656 }
3657 return 0;
3658}
3659
3660static PyObject *
3661test_pytime_object_to_time_t(PyObject *self, PyObject *args)
3662{
3663 PyObject *obj;
3664 time_t sec;
3665 int round;
3666 if (!PyArg_ParseTuple(args, "Oi:pytime_object_to_time_t", &obj, &round))
3667 return NULL;
3668 if (check_time_rounding(round) < 0)
3669 return NULL;
3670 if (_PyTime_ObjectToTime_t(obj, &sec, round) == -1)
3671 return NULL;
3672 return _PyLong_FromTime_t(sec);
3673}
3674
3675static PyObject *
3676test_pytime_object_to_timeval(PyObject *self, PyObject *args)
3677{
3678 PyObject *obj;
3679 time_t sec;
3680 long usec;
3681 int round;
3682 if (!PyArg_ParseTuple(args, "Oi:pytime_object_to_timeval", &obj, &round))
3683 return NULL;
3684 if (check_time_rounding(round) < 0)
3685 return NULL;
3686 if (_PyTime_ObjectToTimeval(obj, &sec, &usec, round) == -1)
3687 return NULL;
3688 return Py_BuildValue("Nl", _PyLong_FromTime_t(sec), usec);
3689}
3690
3691static PyObject *
3692test_pytime_object_to_timespec(PyObject *self, PyObject *args)
3693{
3694 PyObject *obj;
3695 time_t sec;
3696 long nsec;
3697 int round;
3698 if (!PyArg_ParseTuple(args, "Oi:pytime_object_to_timespec", &obj, &round))
3699 return NULL;
3700 if (check_time_rounding(round) < 0)
3701 return NULL;
3702 if (_PyTime_ObjectToTimespec(obj, &sec, &nsec, round) == -1)
3703 return NULL;
3704 return Py_BuildValue("Nl", _PyLong_FromTime_t(sec), nsec);
3705}
3706
3707static void
3708slot_tp_del(PyObject *self)
3709{
3710 _Py_IDENTIFIER(__tp_del__);
3711 PyObject *del, *res;
3712 PyObject *error_type, *error_value, *error_traceback;
3713
3714 /* Temporarily resurrect the object. */
3715 assert(Py_REFCNT(self) == 0);
3716 Py_SET_REFCNT(self, 1);
3717
3718 /* Save the current exception, if any. */
3719 PyErr_Fetch(&error_type, &error_value, &error_traceback);
3720
3721 /* Execute __del__ method, if any. */
3722 del = _PyObject_LookupSpecial(self, &PyId___tp_del__);
3723 if (del != NULL) {
3724 res = _PyObject_CallNoArg(del);
3725 if (res == NULL)
3726 PyErr_WriteUnraisable(del);
3727 else
3728 Py_DECREF(res);
3729 Py_DECREF(del);
3730 }
3731
3732 /* Restore the saved exception. */
3733 PyErr_Restore(error_type, error_value, error_traceback);
3734
3735 /* Undo the temporary resurrection; can't use DECREF here, it would
3736 * cause a recursive call.
3737 */
3738 assert(Py_REFCNT(self) > 0);
3739 Py_SET_REFCNT(self, Py_REFCNT(self) - 1);
3740 if (Py_REFCNT(self) == 0) {
3741 /* this is the normal path out */
3742 return;
3743 }
3744
3745 /* __del__ resurrected it! Make it look like the original Py_DECREF
3746 * never happened.
3747 */
3748 {
3749 Py_ssize_t refcnt = Py_REFCNT(self);
3750 _Py_NewReference(self);
3751 Py_SET_REFCNT(self, refcnt);
3752 }
3753 assert(!PyType_IS_GC(Py_TYPE(self)) || PyObject_GC_IsTracked(self));
3754 /* If Py_REF_DEBUG macro is defined, _Py_NewReference() increased
3755 _Py_RefTotal, so we need to undo that. */
3756#ifdef Py_REF_DEBUG
3757 _Py_RefTotal--;
3758#endif
3759}
3760
3761static PyObject *
3762with_tp_del(PyObject *self, PyObject *args)
3763{
3764 PyObject *obj;
3765 PyTypeObject *tp;
3766
3767 if (!PyArg_ParseTuple(args, "O:with_tp_del", &obj))
3768 return NULL;
3769 tp = (PyTypeObject *) obj;
3770 if (!PyType_Check(obj) || !PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE)) {
3771 PyErr_Format(PyExc_TypeError,
3772 "heap type expected, got %R", obj);
3773 return NULL;
3774 }
3775 tp->tp_del = slot_tp_del;
3776 Py_INCREF(obj);
3777 return obj;
3778}
3779
3780static PyObject *
3781without_gc(PyObject *Py_UNUSED(self), PyObject *obj)
3782{
3783 PyTypeObject *tp = (PyTypeObject*)obj;
3784 if (!PyType_Check(obj) || !PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE)) {
3785 return PyErr_Format(PyExc_TypeError, "heap type expected, got %R", obj);
3786 }
3787 if (PyType_IS_GC(tp)) {
3788 // Don't try this at home, kids:
3789 tp->tp_flags -= Py_TPFLAGS_HAVE_GC;
3790 tp->tp_free = PyObject_Del;
3791 tp->tp_traverse = NULL;
3792 tp->tp_clear = NULL;
3793 }
3794 assert(!PyType_IS_GC(tp));
3795 Py_INCREF(obj);
3796 return obj;
3797}
3798
3799static PyMethodDef ml;
3800
3801static PyObject *
3802create_cfunction(PyObject *self, PyObject *args)
3803{
3804 return PyCFunction_NewEx(&ml, self, NULL);
3805}
3806
3807static PyMethodDef ml = {
3808 "create_cfunction",
3809 create_cfunction,
3810 METH_NOARGS,
3811 NULL
3812};
3813
3814static PyObject *
3815_test_incref(PyObject *ob)
3816{
3817 Py_INCREF(ob);
3818 return ob;
3819}
3820
3821static PyObject *
3822test_xincref_doesnt_leak(PyObject *ob, PyObject *Py_UNUSED(ignored))
3823{
3824 PyObject *obj = PyLong_FromLong(0);
3825 Py_XINCREF(_test_incref(obj));
3826 Py_DECREF(obj);
3827 Py_DECREF(obj);
3828 Py_DECREF(obj);
3829 Py_RETURN_NONE;
3830}
3831
3832static PyObject *
3833test_incref_doesnt_leak(PyObject *ob, PyObject *Py_UNUSED(ignored))
3834{
3835 PyObject *obj = PyLong_FromLong(0);
3836 Py_INCREF(_test_incref(obj));
3837 Py_DECREF(obj);
3838 Py_DECREF(obj);
3839 Py_DECREF(obj);
3840 Py_RETURN_NONE;
3841}
3842
3843static PyObject *
3844test_xdecref_doesnt_leak(PyObject *ob, PyObject *Py_UNUSED(ignored))
3845{
3846 Py_XDECREF(PyLong_FromLong(0));
3847 Py_RETURN_NONE;
3848}
3849
3850static PyObject *
3851test_decref_doesnt_leak(PyObject *ob, PyObject *Py_UNUSED(ignored))
3852{
3853 Py_DECREF(PyLong_FromLong(0));
3854 Py_RETURN_NONE;
3855}
3856
3857static PyObject *
3858test_structseq_newtype_doesnt_leak(PyObject *Py_UNUSED(self),
3859 PyObject *Py_UNUSED(args))
3860{
3861 PyStructSequence_Desc descr;
3862 PyStructSequence_Field descr_fields[3];
3863
3864 descr_fields[0] = (PyStructSequence_Field){"foo", "foo value"};
3865 descr_fields[1] = (PyStructSequence_Field){NULL, "some hidden value"};
3866 descr_fields[2] = (PyStructSequence_Field){0, NULL};
3867
3868 descr.name = "_testcapi.test_descr";
3869 descr.doc = "This is used to test for memory leaks in NewType";
3870 descr.fields = descr_fields;
3871 descr.n_in_sequence = 1;
3872
3873 PyTypeObject* structseq_type = PyStructSequence_NewType(&descr);
3874 assert(structseq_type != NULL);
3875 assert(PyType_Check(structseq_type));
3876 assert(PyType_FastSubclass(structseq_type, Py_TPFLAGS_TUPLE_SUBCLASS));
3877 Py_DECREF(structseq_type);
3878
3879 Py_RETURN_NONE;
3880}
3881
3882static PyObject *
3883test_structseq_newtype_null_descr_doc(PyObject *Py_UNUSED(self),
3884 PyObject *Py_UNUSED(args))
3885{
3886 PyStructSequence_Field descr_fields[1] = {
3887 (PyStructSequence_Field){NULL, NULL}
3888 };
3889 // Test specifically for NULL .doc field.
3890 PyStructSequence_Desc descr = {"_testcapi.test_descr", NULL, &descr_fields[0], 0};
3891
3892 PyTypeObject* structseq_type = PyStructSequence_NewType(&descr);
3893 assert(structseq_type != NULL);
3894 assert(PyType_Check(structseq_type));
3895 assert(PyType_FastSubclass(structseq_type, Py_TPFLAGS_TUPLE_SUBCLASS));
3896 Py_DECREF(structseq_type);
3897
3898 Py_RETURN_NONE;
3899}
3900
3901static PyObject *
3902test_incref_decref_API(PyObject *ob, PyObject *Py_UNUSED(ignored))
3903{
3904 PyObject *obj = PyLong_FromLong(0);
3905 Py_IncRef(obj);
3906 Py_DecRef(obj);
3907 Py_DecRef(obj);
3908 Py_RETURN_NONE;
3909}
3910
3911static PyObject *
3912test_pymem_alloc0(PyObject *self, PyObject *Py_UNUSED(ignored))
3913{
3914 void *ptr;
3915
3916 ptr = PyMem_RawMalloc(0);
3917 if (ptr == NULL) {
3918 PyErr_SetString(PyExc_RuntimeError, "PyMem_RawMalloc(0) returns NULL");
3919 return NULL;
3920 }
3921 PyMem_RawFree(ptr);
3922
3923 ptr = PyMem_RawCalloc(0, 0);
3924 if (ptr == NULL) {
3925 PyErr_SetString(PyExc_RuntimeError, "PyMem_RawCalloc(0, 0) returns NULL");
3926 return NULL;
3927 }
3928 PyMem_RawFree(ptr);
3929
3930 ptr = PyMem_Malloc(0);
3931 if (ptr == NULL) {
3932 PyErr_SetString(PyExc_RuntimeError, "PyMem_Malloc(0) returns NULL");
3933 return NULL;
3934 }
3935 PyMem_Free(ptr);
3936
3937 ptr = PyMem_Calloc(0, 0);
3938 if (ptr == NULL) {
3939 PyErr_SetString(PyExc_RuntimeError, "PyMem_Calloc(0, 0) returns NULL");
3940 return NULL;
3941 }
3942 PyMem_Free(ptr);
3943
3944 ptr = PyObject_Malloc(0);
3945 if (ptr == NULL) {
3946 PyErr_SetString(PyExc_RuntimeError, "PyObject_Malloc(0) returns NULL");
3947 return NULL;
3948 }
3949 PyObject_Free(ptr);
3950
3951 ptr = PyObject_Calloc(0, 0);
3952 if (ptr == NULL) {
3953 PyErr_SetString(PyExc_RuntimeError, "PyObject_Calloc(0, 0) returns NULL");
3954 return NULL;
3955 }
3956 PyObject_Free(ptr);
3957
3958 Py_RETURN_NONE;
3959}
3960
3961typedef struct {
3962 PyMemAllocatorEx alloc;
3963
3964 size_t malloc_size;
3965 size_t calloc_nelem;
3966 size_t calloc_elsize;
3967 void *realloc_ptr;
3968 size_t realloc_new_size;
3969 void *free_ptr;
3970 void *ctx;
3971} alloc_hook_t;
3972
3973static void* hook_malloc(void* ctx, size_t size)
3974{
3975 alloc_hook_t *hook = (alloc_hook_t *)ctx;
3976 hook->ctx = ctx;
3977 hook->malloc_size = size;
3978 return hook->alloc.malloc(hook->alloc.ctx, size);
3979}
3980
3981static void* hook_calloc(void* ctx, size_t nelem, size_t elsize)
3982{
3983 alloc_hook_t *hook = (alloc_hook_t *)ctx;
3984 hook->ctx = ctx;
3985 hook->calloc_nelem = nelem;
3986 hook->calloc_elsize = elsize;
3987 return hook->alloc.calloc(hook->alloc.ctx, nelem, elsize);
3988}
3989
3990static void* hook_realloc(void* ctx, void* ptr, size_t new_size)
3991{
3992 alloc_hook_t *hook = (alloc_hook_t *)ctx;
3993 hook->ctx = ctx;
3994 hook->realloc_ptr = ptr;
3995 hook->realloc_new_size = new_size;
3996 return hook->alloc.realloc(hook->alloc.ctx, ptr, new_size);
3997}
3998
3999static void hook_free(void *ctx, void *ptr)
4000{
4001 alloc_hook_t *hook = (alloc_hook_t *)ctx;
4002 hook->ctx = ctx;
4003 hook->free_ptr = ptr;
4004 hook->alloc.free(hook->alloc.ctx, ptr);
4005}
4006
4007static PyObject *
4008test_setallocators(PyMemAllocatorDomain domain)
4009{
4010 PyObject *res = NULL;
4011 const char *error_msg;
4012 alloc_hook_t hook;
4013 PyMemAllocatorEx alloc;
4014 size_t size, size2, nelem, elsize;
4015 void *ptr, *ptr2;
4016
4017 memset(&hook, 0, sizeof(hook));
4018
4019 alloc.ctx = &hook;
4020 alloc.malloc = &hook_malloc;
4021 alloc.calloc = &hook_calloc;
4022 alloc.realloc = &hook_realloc;
4023 alloc.free = &hook_free;
4024 PyMem_GetAllocator(domain, &hook.alloc);
4025 PyMem_SetAllocator(domain, &alloc);
4026
4027 /* malloc, realloc, free */
4028 size = 42;
4029 hook.ctx = NULL;
4030 switch(domain)
4031 {
4032 case PYMEM_DOMAIN_RAW: ptr = PyMem_RawMalloc(size); break;
4033 case PYMEM_DOMAIN_MEM: ptr = PyMem_Malloc(size); break;
4034 case PYMEM_DOMAIN_OBJ: ptr = PyObject_Malloc(size); break;
4035 default: ptr = NULL; break;
4036 }
4037
4038#define CHECK_CTX(FUNC) \
4039 if (hook.ctx != &hook) { \
4040 error_msg = FUNC " wrong context"; \
4041 goto fail; \
4042 } \
4043 hook.ctx = NULL; /* reset for next check */
4044
4045 if (ptr == NULL) {
4046 error_msg = "malloc failed";
4047 goto fail;
4048 }
4049 CHECK_CTX("malloc");
4050 if (hook.malloc_size != size) {
4051 error_msg = "malloc invalid size";
4052 goto fail;
4053 }
4054
4055 size2 = 200;
4056 switch(domain)
4057 {
4058 case PYMEM_DOMAIN_RAW: ptr2 = PyMem_RawRealloc(ptr, size2); break;
4059 case PYMEM_DOMAIN_MEM: ptr2 = PyMem_Realloc(ptr, size2); break;
4060 case PYMEM_DOMAIN_OBJ: ptr2 = PyObject_Realloc(ptr, size2); break;
4061 default: ptr2 = NULL; break;
4062 }
4063
4064 if (ptr2 == NULL) {
4065 error_msg = "realloc failed";
4066 goto fail;
4067 }
4068 CHECK_CTX("realloc");
4069 if (hook.realloc_ptr != ptr
4070 || hook.realloc_new_size != size2) {
4071 error_msg = "realloc invalid parameters";
4072 goto fail;
4073 }
4074
4075 switch(domain)
4076 {
4077 case PYMEM_DOMAIN_RAW: PyMem_RawFree(ptr2); break;
4078 case PYMEM_DOMAIN_MEM: PyMem_Free(ptr2); break;
4079 case PYMEM_DOMAIN_OBJ: PyObject_Free(ptr2); break;
4080 }
4081
4082 CHECK_CTX("free");
4083 if (hook.free_ptr != ptr2) {
4084 error_msg = "free invalid pointer";
4085 goto fail;
4086 }
4087
4088 /* calloc, free */
4089 nelem = 2;
4090 elsize = 5;
4091 switch(domain)
4092 {
4093 case PYMEM_DOMAIN_RAW: ptr = PyMem_RawCalloc(nelem, elsize); break;
4094 case PYMEM_DOMAIN_MEM: ptr = PyMem_Calloc(nelem, elsize); break;
4095 case PYMEM_DOMAIN_OBJ: ptr = PyObject_Calloc(nelem, elsize); break;
4096 default: ptr = NULL; break;
4097 }
4098
4099 if (ptr == NULL) {
4100 error_msg = "calloc failed";
4101 goto fail;
4102 }
4103 CHECK_CTX("calloc");
4104 if (hook.calloc_nelem != nelem || hook.calloc_elsize != elsize) {
4105 error_msg = "calloc invalid nelem or elsize";
4106 goto fail;
4107 }
4108
4109 hook.free_ptr = NULL;
4110 switch(domain)
4111 {
4112 case PYMEM_DOMAIN_RAW: PyMem_RawFree(ptr); break;
4113 case PYMEM_DOMAIN_MEM: PyMem_Free(ptr); break;
4114 case PYMEM_DOMAIN_OBJ: PyObject_Free(ptr); break;
4115 }
4116
4117 CHECK_CTX("calloc free");
4118 if (hook.free_ptr != ptr) {
4119 error_msg = "calloc free invalid pointer";
4120 goto fail;
4121 }
4122
4123 Py_INCREF(Py_None);
4124 res = Py_None;
4125 goto finally;
4126
4127fail:
4128 PyErr_SetString(PyExc_RuntimeError, error_msg);
4129
4130finally:
4131 PyMem_SetAllocator(domain, &hook.alloc);
4132 return res;
4133
4134#undef CHECK_CTX
4135}
4136
4137static PyObject *
4138test_pymem_setrawallocators(PyObject *self, PyObject *Py_UNUSED(ignored))
4139{
4140 return test_setallocators(PYMEM_DOMAIN_RAW);
4141}
4142
4143static PyObject *
4144test_pymem_setallocators(PyObject *self, PyObject *Py_UNUSED(ignored))
4145{
4146 return test_setallocators(PYMEM_DOMAIN_MEM);
4147}
4148
4149static PyObject *
4150test_pyobject_setallocators(PyObject *self, PyObject *Py_UNUSED(ignored))
4151{
4152 return test_setallocators(PYMEM_DOMAIN_OBJ);
4153}
4154
4155/* Most part of the following code is inherited from the pyfailmalloc project
4156 * written by Victor Stinner. */
4157static struct {
4158 int installed;
4159 PyMemAllocatorEx raw;
4160 PyMemAllocatorEx mem;
4161 PyMemAllocatorEx obj;
4162} FmHook;
4163
4164static struct {
4165 int start;
4166 int stop;
4167 Py_ssize_t count;
4168} FmData;
4169
4170static int
4171fm_nomemory(void)
4172{
4173 FmData.count++;
4174 if (FmData.count > FmData.start &&
4175 (FmData.stop <= 0 || FmData.count <= FmData.stop)) {
4176 return 1;
4177 }
4178 return 0;
4179}
4180
4181static void *
4182hook_fmalloc(void *ctx, size_t size)
4183{
4184 PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
4185 if (fm_nomemory()) {
4186 return NULL;
4187 }
4188 return alloc->malloc(alloc->ctx, size);
4189}
4190
4191static void *
4192hook_fcalloc(void *ctx, size_t nelem, size_t elsize)
4193{
4194 PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
4195 if (fm_nomemory()) {
4196 return NULL;
4197 }
4198 return alloc->calloc(alloc->ctx, nelem, elsize);
4199}
4200
4201static void *
4202hook_frealloc(void *ctx, void *ptr, size_t new_size)
4203{
4204 PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
4205 if (fm_nomemory()) {
4206 return NULL;
4207 }
4208 return alloc->realloc(alloc->ctx, ptr, new_size);
4209}
4210
4211static void
4212hook_ffree(void *ctx, void *ptr)
4213{
4214 PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;
4215 alloc->free(alloc->ctx, ptr);
4216}
4217
4218static void
4219fm_setup_hooks(void)
4220{
4221 PyMemAllocatorEx alloc;
4222
4223 if (FmHook.installed) {
4224 return;
4225 }
4226 FmHook.installed = 1;
4227
4228 alloc.malloc = hook_fmalloc;
4229 alloc.calloc = hook_fcalloc;
4230 alloc.realloc = hook_frealloc;
4231 alloc.free = hook_ffree;
4232 PyMem_GetAllocator(PYMEM_DOMAIN_RAW, &FmHook.raw);
4233 PyMem_GetAllocator(PYMEM_DOMAIN_MEM, &FmHook.mem);
4234 PyMem_GetAllocator(PYMEM_DOMAIN_OBJ, &FmHook.obj);
4235
4236 alloc.ctx = &FmHook.raw;
4237 PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &alloc);
4238
4239 alloc.ctx = &FmHook.mem;
4240 PyMem_SetAllocator(PYMEM_DOMAIN_MEM, &alloc);
4241
4242 alloc.ctx = &FmHook.obj;
4243 PyMem_SetAllocator(PYMEM_DOMAIN_OBJ, &alloc);
4244}
4245
4246static void
4247fm_remove_hooks(void)
4248{
4249 if (FmHook.installed) {
4250 FmHook.installed = 0;
4251 PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &FmHook.raw);
4252 PyMem_SetAllocator(PYMEM_DOMAIN_MEM, &FmHook.mem);
4253 PyMem_SetAllocator(PYMEM_DOMAIN_OBJ, &FmHook.obj);
4254 }
4255}
4256
4257static PyObject*
4258set_nomemory(PyObject *self, PyObject *args)
4259{
4260 /* Memory allocation fails after 'start' allocation requests, and until
4261 * 'stop' allocation requests except when 'stop' is negative or equal
4262 * to 0 (default) in which case allocation failures never stop. */
4263 FmData.count = 0;
4264 FmData.stop = 0;
4265 if (!PyArg_ParseTuple(args, "i|i", &FmData.start, &FmData.stop)) {
4266 return NULL;
4267 }
4268 fm_setup_hooks();
4269 Py_RETURN_NONE;
4270}
4271
4272static PyObject*
4273remove_mem_hooks(PyObject *self, PyObject *Py_UNUSED(ignored))
4274{
4275 fm_remove_hooks();
4276 Py_RETURN_NONE;
4277}
4278
4279PyDoc_STRVAR(docstring_empty,
4280""
4281);
4282
4283PyDoc_STRVAR(docstring_no_signature,
4284"This docstring has no signature."
4285);
4286
4287PyDoc_STRVAR(docstring_with_invalid_signature,
4288"docstring_with_invalid_signature($module, /, boo)\n"
4289"\n"
4290"This docstring has an invalid signature."
4291);
4292
4293PyDoc_STRVAR(docstring_with_invalid_signature2,
4294"docstring_with_invalid_signature2($module, /, boo)\n"
4295"\n"
4296"--\n"
4297"\n"
4298"This docstring also has an invalid signature."
4299);
4300
4301PyDoc_STRVAR(docstring_with_signature,
4302"docstring_with_signature($module, /, sig)\n"
4303"--\n"
4304"\n"
4305"This docstring has a valid signature."
4306);
4307
4308PyDoc_STRVAR(docstring_with_signature_but_no_doc,
4309"docstring_with_signature_but_no_doc($module, /, sig)\n"
4310"--\n"
4311"\n"
4312);
4313
4314PyDoc_STRVAR(docstring_with_signature_and_extra_newlines,
4315"docstring_with_signature_and_extra_newlines($module, /, parameter)\n"
4316"--\n"
4317"\n"
4318"\n"
4319"This docstring has a valid signature and some extra newlines."
4320);
4321
4322PyDoc_STRVAR(docstring_with_signature_with_defaults,
4323"docstring_with_signature_with_defaults(module, s='avocado',\n"
4324" b=b'bytes', d=3.14, i=35, n=None, t=True, f=False,\n"
4325" local=the_number_three, sys=sys.maxsize,\n"
4326" exp=sys.maxsize - 1)\n"
4327"--\n"
4328"\n"
4329"\n"
4330"\n"
4331"This docstring has a valid signature with parameters,\n"
4332"and the parameters take defaults of varying types."
4333);
4334
4335typedef struct {
4336 PyThread_type_lock start_event;
4337 PyThread_type_lock exit_event;
4338 PyObject *callback;
4339} test_c_thread_t;
4340
4341static void
4342temporary_c_thread(void *data)
4343{
4344 test_c_thread_t *test_c_thread = data;
4345 PyGILState_STATE state;
4346 PyObject *res;
4347
4348 PyThread_release_lock(test_c_thread->start_event);
4349
4350 /* Allocate a Python thread state for this thread */
4351 state = PyGILState_Ensure();
4352
4353 res = _PyObject_CallNoArg(test_c_thread->callback);
4354 Py_CLEAR(test_c_thread->callback);
4355
4356 if (res == NULL) {
4357 PyErr_Print();
4358 }
4359 else {
4360 Py_DECREF(res);
4361 }
4362
4363 /* Destroy the Python thread state for this thread */
4364 PyGILState_Release(state);
4365
4366 PyThread_release_lock(test_c_thread->exit_event);
4367
4368 PyThread_exit_thread();
4369}
4370
4371static PyObject *
4372call_in_temporary_c_thread(PyObject *self, PyObject *callback)
4373{
4374 PyObject *res = NULL;
4375 test_c_thread_t test_c_thread;
4376 long thread;
4377
4378 test_c_thread.start_event = PyThread_allocate_lock();
4379 test_c_thread.exit_event = PyThread_allocate_lock();
4380 test_c_thread.callback = NULL;
4381 if (!test_c_thread.start_event || !test_c_thread.exit_event) {
4382 PyErr_SetString(PyExc_RuntimeError, "could not allocate lock");
4383 goto exit;
4384 }
4385
4386 Py_INCREF(callback);
4387 test_c_thread.callback = callback;
4388
4389 PyThread_acquire_lock(test_c_thread.start_event, 1);
4390 PyThread_acquire_lock(test_c_thread.exit_event, 1);
4391
4392 thread = PyThread_start_new_thread(temporary_c_thread, &test_c_thread);
4393 if (thread == -1) {
4394 PyErr_SetString(PyExc_RuntimeError, "unable to start the thread");
4395 PyThread_release_lock(test_c_thread.start_event);
4396 PyThread_release_lock(test_c_thread.exit_event);
4397 goto exit;
4398 }
4399
4400 PyThread_acquire_lock(test_c_thread.start_event, 1);
4401 PyThread_release_lock(test_c_thread.start_event);
4402
4403 Py_BEGIN_ALLOW_THREADS
4404 PyThread_acquire_lock(test_c_thread.exit_event, 1);
4405 PyThread_release_lock(test_c_thread.exit_event);
4406 Py_END_ALLOW_THREADS
4407
4408 Py_INCREF(Py_None);
4409 res = Py_None;
4410
4411exit:
4412 Py_CLEAR(test_c_thread.callback);
4413 if (test_c_thread.start_event)
4414 PyThread_free_lock(test_c_thread.start_event);
4415 if (test_c_thread.exit_event)
4416 PyThread_free_lock(test_c_thread.exit_event);
4417 return res;
4418}
4419
4420/* marshal */
4421
4422static PyObject*
4423pymarshal_write_long_to_file(PyObject* self, PyObject *args)
4424{
4425 long value;
4426 PyObject *filename;
4427 int version;
4428 FILE *fp;
4429
4430 if (!PyArg_ParseTuple(args, "lOi:pymarshal_write_long_to_file",
4431 &value, &filename, &version))
4432 return NULL;
4433
4434 fp = _Py_fopen_obj(filename, "wb");
4435 if (fp == NULL) {
4436 PyErr_SetFromErrno(PyExc_OSError);
4437 return NULL;
4438 }
4439
4440 PyMarshal_WriteLongToFile(value, fp, version);
4441
4442 fclose(fp);
4443 if (PyErr_Occurred())
4444 return NULL;
4445 Py_RETURN_NONE;
4446}
4447
4448static PyObject*
4449pymarshal_write_object_to_file(PyObject* self, PyObject *args)
4450{
4451 PyObject *obj;
4452 PyObject *filename;
4453 int version;
4454 FILE *fp;
4455
4456 if (!PyArg_ParseTuple(args, "OOi:pymarshal_write_object_to_file",
4457 &obj, &filename, &version))
4458 return NULL;
4459
4460 fp = _Py_fopen_obj(filename, "wb");
4461 if (fp == NULL) {
4462 PyErr_SetFromErrno(PyExc_OSError);
4463 return NULL;
4464 }
4465
4466 PyMarshal_WriteObjectToFile(obj, fp, version);
4467
4468 fclose(fp);
4469 if (PyErr_Occurred())
4470 return NULL;
4471 Py_RETURN_NONE;
4472}
4473
4474static PyObject*
4475pymarshal_read_short_from_file(PyObject* self, PyObject *args)
4476{
4477 int value;
4478 long pos;
4479 PyObject *filename;
4480 FILE *fp;
4481
4482 if (!PyArg_ParseTuple(args, "O:pymarshal_read_short_from_file", &filename))
4483 return NULL;
4484
4485 fp = _Py_fopen_obj(filename, "rb");
4486 if (fp == NULL) {
4487 PyErr_SetFromErrno(PyExc_OSError);
4488 return NULL;
4489 }
4490
4491 value = PyMarshal_ReadShortFromFile(fp);
4492 pos = ftell(fp);
4493
4494 fclose(fp);
4495 if (PyErr_Occurred())
4496 return NULL;
4497 return Py_BuildValue("il", value, pos);
4498}
4499
4500static PyObject*
4501pymarshal_read_long_from_file(PyObject* self, PyObject *args)
4502{
4503 long value, pos;
4504 PyObject *filename;
4505 FILE *fp;
4506
4507 if (!PyArg_ParseTuple(args, "O:pymarshal_read_long_from_file", &filename))
4508 return NULL;
4509
4510 fp = _Py_fopen_obj(filename, "rb");
4511 if (fp == NULL) {
4512 PyErr_SetFromErrno(PyExc_OSError);
4513 return NULL;
4514 }
4515
4516 value = PyMarshal_ReadLongFromFile(fp);
4517 pos = ftell(fp);
4518
4519 fclose(fp);
4520 if (PyErr_Occurred())
4521 return NULL;
4522 return Py_BuildValue("ll", value, pos);
4523}
4524
4525static PyObject*
4526pymarshal_read_last_object_from_file(PyObject* self, PyObject *args)
4527{
4528 PyObject *obj;
4529 long pos;
4530 PyObject *filename;
4531 FILE *fp;
4532
4533 if (!PyArg_ParseTuple(args, "O:pymarshal_read_last_object_from_file", &filename))
4534 return NULL;
4535
4536 fp = _Py_fopen_obj(filename, "rb");
4537 if (fp == NULL) {
4538 PyErr_SetFromErrno(PyExc_OSError);
4539 return NULL;
4540 }
4541
4542 obj = PyMarshal_ReadLastObjectFromFile(fp);
4543 pos = ftell(fp);
4544
4545 fclose(fp);
4546 return Py_BuildValue("Nl", obj, pos);
4547}
4548
4549static PyObject*
4550pymarshal_read_object_from_file(PyObject* self, PyObject *args)
4551{
4552 PyObject *obj;
4553 long pos;
4554 PyObject *filename;
4555 FILE *fp;
4556
4557 if (!PyArg_ParseTuple(args, "O:pymarshal_read_object_from_file", &filename))
4558 return NULL;
4559
4560 fp = _Py_fopen_obj(filename, "rb");
4561 if (fp == NULL) {
4562 PyErr_SetFromErrno(PyExc_OSError);
4563 return NULL;
4564 }
4565
4566 obj = PyMarshal_ReadObjectFromFile(fp);
4567 pos = ftell(fp);
4568
4569 fclose(fp);
4570 return Py_BuildValue("Nl", obj, pos);
4571}
4572
4573static PyObject*
4574return_null_without_error(PyObject *self, PyObject *args)
4575{
4576 /* invalid call: return NULL without setting an error,
4577 * _Py_CheckFunctionResult() must detect such bug at runtime. */
4578 PyErr_Clear();
4579 return NULL;
4580}
4581
4582static PyObject*
4583return_result_with_error(PyObject *self, PyObject *args)
4584{
4585 /* invalid call: return a result with an error set,
4586 * _Py_CheckFunctionResult() must detect such bug at runtime. */
4587 PyErr_SetNone(PyExc_ValueError);
4588 Py_RETURN_NONE;
4589}
4590
4591static PyObject*
4592getitem_with_error(PyObject *self, PyObject *args)
4593{
4594 PyObject *map, *key;
4595 if (!PyArg_ParseTuple(args, "OO", &map, &key)) {
4596 return NULL;
4597 }
4598
4599 PyErr_SetString(PyExc_ValueError, "bug");
4600 return PyObject_GetItem(map, key);
4601}
4602
4603static PyObject *
4604test_pytime_fromseconds(PyObject *self, PyObject *args)
4605{
4606 int seconds;
4607 _PyTime_t ts;
4608
4609 if (!PyArg_ParseTuple(args, "i", &seconds))
4610 return NULL;
4611 ts = _PyTime_FromSeconds(seconds);
4612 return _PyTime_AsNanosecondsObject(ts);
4613}
4614
4615static PyObject *
4616test_pytime_fromsecondsobject(PyObject *self, PyObject *args)
4617{
4618 PyObject *obj;
4619 int round;
4620 _PyTime_t ts;
4621
4622 if (!PyArg_ParseTuple(args, "Oi", &obj, &round))
4623 return NULL;
4624 if (check_time_rounding(round) < 0)
4625 return NULL;
4626 if (_PyTime_FromSecondsObject(&ts, obj, round) == -1)
4627 return NULL;
4628 return _PyTime_AsNanosecondsObject(ts);
4629}
4630
4631static PyObject *
4632test_pytime_assecondsdouble(PyObject *self, PyObject *args)
4633{
4634 PyObject *obj;
4635 _PyTime_t ts;
4636 double d;
4637
4638 if (!PyArg_ParseTuple(args, "O", &obj)) {
4639 return NULL;
4640 }
4641 if (_PyTime_FromNanosecondsObject(&ts, obj) < 0) {
4642 return NULL;
4643 }
4644 d = _PyTime_AsSecondsDouble(ts);
4645 return PyFloat_FromDouble(d);
4646}
4647
4648static PyObject *
4649test_PyTime_AsTimeval(PyObject *self, PyObject *args)
4650{
4651 PyObject *obj;
4652 int round;
4653 _PyTime_t t;
4654 struct timeval tv;
4655 PyObject *seconds;
4656
4657 if (!PyArg_ParseTuple(args, "Oi", &obj, &round))
4658 return NULL;
4659 if (check_time_rounding(round) < 0) {
4660 return NULL;
4661 }
4662 if (_PyTime_FromNanosecondsObject(&t, obj) < 0) {
4663 return NULL;
4664 }
4665 if (_PyTime_AsTimeval(t, &tv, round) < 0) {
4666 return NULL;
4667 }
4668
4669 seconds = PyLong_FromLongLong(tv.tv_sec);
4670 if (seconds == NULL) {
4671 return NULL;
4672 }
4673 return Py_BuildValue("Nl", seconds, tv.tv_usec);
4674}
4675
4676#ifdef HAVE_CLOCK_GETTIME
4677static PyObject *
4678test_PyTime_AsTimespec(PyObject *self, PyObject *args)
4679{
4680 PyObject *obj;
4681 _PyTime_t t;
4682 struct timespec ts;
4683
4684 if (!PyArg_ParseTuple(args, "O", &obj)) {
4685 return NULL;
4686 }
4687 if (_PyTime_FromNanosecondsObject(&t, obj) < 0) {
4688 return NULL;
4689 }
4690 if (_PyTime_AsTimespec(t, &ts) == -1) {
4691 return NULL;
4692 }
4693 return Py_BuildValue("Nl", _PyLong_FromTime_t(ts.tv_sec), ts.tv_nsec);
4694}
4695#endif
4696
4697static PyObject *
4698test_PyTime_AsMilliseconds(PyObject *self, PyObject *args)
4699{
4700 PyObject *obj;
4701 int round;
4702 _PyTime_t t, ms;
4703
4704 if (!PyArg_ParseTuple(args, "Oi", &obj, &round)) {
4705 return NULL;
4706 }
4707 if (_PyTime_FromNanosecondsObject(&t, obj) < 0) {
4708 return NULL;
4709 }
4710 if (check_time_rounding(round) < 0) {
4711 return NULL;
4712 }
4713 ms = _PyTime_AsMilliseconds(t, round);
4714 /* This conversion rely on the fact that _PyTime_t is a number of
4715 nanoseconds */
4716 return _PyTime_AsNanosecondsObject(ms);
4717}
4718
4719static PyObject *
4720test_PyTime_AsMicroseconds(PyObject *self, PyObject *args)
4721{
4722 PyObject *obj;
4723 int round;
4724 _PyTime_t t, ms;
4725
4726 if (!PyArg_ParseTuple(args, "Oi", &obj, &round))
4727 return NULL;
4728 if (_PyTime_FromNanosecondsObject(&t, obj) < 0) {
4729 return NULL;
4730 }
4731 if (check_time_rounding(round) < 0) {
4732 return NULL;
4733 }
4734 ms = _PyTime_AsMicroseconds(t, round);
4735 /* This conversion rely on the fact that _PyTime_t is a number of
4736 nanoseconds */
4737 return _PyTime_AsNanosecondsObject(ms);
4738}
4739
4740static PyObject*
4741pymem_buffer_overflow(PyObject *self, PyObject *args)
4742{
4743 char *buffer;
4744
4745 /* Deliberate buffer overflow to check that PyMem_Free() detects
4746 the overflow when debug hooks are installed. */
4747 buffer = PyMem_Malloc(16);
4748 if (buffer == NULL) {
4749 PyErr_NoMemory();
4750 return NULL;
4751 }
4752 buffer[16] = 'x';
4753 PyMem_Free(buffer);
4754
4755 Py_RETURN_NONE;
4756}
4757
4758static PyObject*
4759pymem_api_misuse(PyObject *self, PyObject *args)
4760{
4761 char *buffer;
4762
4763 /* Deliberate misusage of Python allocators:
4764 allococate with PyMem but release with PyMem_Raw. */
4765 buffer = PyMem_Malloc(16);
4766 PyMem_RawFree(buffer);
4767
4768 Py_RETURN_NONE;
4769}
4770
4771static PyObject*
4772pymem_malloc_without_gil(PyObject *self, PyObject *args)
4773{
4774 char *buffer;
4775
4776 /* Deliberate bug to test debug hooks on Python memory allocators:
4777 call PyMem_Malloc() without holding the GIL */
4778 Py_BEGIN_ALLOW_THREADS
4779 buffer = PyMem_Malloc(10);
4780 Py_END_ALLOW_THREADS
4781
4782 PyMem_Free(buffer);
4783
4784 Py_RETURN_NONE;
4785}
4786
4787
4788static PyObject*
4789test_pymem_getallocatorsname(PyObject *self, PyObject *args)
4790{
4791 const char *name = _PyMem_GetCurrentAllocatorName();
4792 if (name == NULL) {
4793 PyErr_SetString(PyExc_RuntimeError, "cannot get allocators name");
4794 return NULL;
4795 }
4796 return PyUnicode_FromString(name);
4797}
4798
4799
4800static PyObject*
4801test_pyobject_is_freed(const char *test_name, PyObject *op)
4802{
4803 if (!_PyObject_IsFreed(op)) {
4804 return raiseTestError(test_name, "object is not seen as freed");
4805 }
4806 Py_RETURN_NONE;
4807}
4808
4809
4810static PyObject*
4811check_pyobject_null_is_freed(PyObject *self, PyObject *Py_UNUSED(args))
4812{
4813 PyObject *op = NULL;
4814 return test_pyobject_is_freed("check_pyobject_null_is_freed", op);
4815}
4816
4817
4818static PyObject*
4819check_pyobject_uninitialized_is_freed(PyObject *self, PyObject *Py_UNUSED(args))
4820{
4821 PyObject *op = (PyObject *)PyObject_Malloc(sizeof(PyObject));
4822 if (op == NULL) {
4823 return NULL;
4824 }
4825 /* Initialize reference count to avoid early crash in ceval or GC */
4826 Py_SET_REFCNT(op, 1);
4827 /* object fields like ob_type are uninitialized! */
4828 return test_pyobject_is_freed("check_pyobject_uninitialized_is_freed", op);
4829}
4830
4831
4832static PyObject*
4833check_pyobject_forbidden_bytes_is_freed(PyObject *self, PyObject *Py_UNUSED(args))
4834{
4835 /* Allocate an incomplete PyObject structure: truncate 'ob_type' field */
4836 PyObject *op = (PyObject *)PyObject_Malloc(offsetof(PyObject, ob_type));
4837 if (op == NULL) {
4838 return NULL;
4839 }
4840 /* Initialize reference count to avoid early crash in ceval or GC */
4841 Py_SET_REFCNT(op, 1);
4842 /* ob_type field is after the memory block: part of "forbidden bytes"
4843 when using debug hooks on memory allocators! */
4844 return test_pyobject_is_freed("check_pyobject_forbidden_bytes_is_freed", op);
4845}
4846
4847
4848static PyObject*
4849check_pyobject_freed_is_freed(PyObject *self, PyObject *Py_UNUSED(args))
4850{
4851 /* This test would fail if run with the address sanitizer */
4852#ifdef _Py_ADDRESS_SANITIZER
4853 Py_RETURN_NONE;
4854#else
4855 PyObject *op = _PyObject_CallNoArg((PyObject *)&PyBaseObject_Type);
4856 if (op == NULL) {
4857 return NULL;
4858 }
4859 Py_TYPE(op)->tp_dealloc(op);
4860 /* Reset reference count to avoid early crash in ceval or GC */
4861 Py_SET_REFCNT(op, 1);
4862 /* object memory is freed! */
4863 return test_pyobject_is_freed("check_pyobject_freed_is_freed", op);
4864#endif
4865}
4866
4867
4868static PyObject*
4869pyobject_malloc_without_gil(PyObject *self, PyObject *args)
4870{
4871 char *buffer;
4872
4873 /* Deliberate bug to test debug hooks on Python memory allocators:
4874 call PyObject_Malloc() without holding the GIL */
4875 Py_BEGIN_ALLOW_THREADS
4876 buffer = PyObject_Malloc(10);
4877 Py_END_ALLOW_THREADS
4878
4879 PyObject_Free(buffer);
4880
4881 Py_RETURN_NONE;
4882}
4883
4884static PyObject *
4885tracemalloc_track(PyObject *self, PyObject *args)
4886{
4887 unsigned int domain;
4888 PyObject *ptr_obj;
4889 void *ptr;
4890 Py_ssize_t size;
4891 int release_gil = 0;
4892 int res;
4893
4894 if (!PyArg_ParseTuple(args, "IOn|i", &domain, &ptr_obj, &size, &release_gil))
4895 return NULL;
4896 ptr = PyLong_AsVoidPtr(ptr_obj);
4897 if (PyErr_Occurred())
4898 return NULL;
4899
4900 if (release_gil) {
4901 Py_BEGIN_ALLOW_THREADS
4902 res = PyTraceMalloc_Track(domain, (uintptr_t)ptr, size);
4903 Py_END_ALLOW_THREADS
4904 }
4905 else {
4906 res = PyTraceMalloc_Track(domain, (uintptr_t)ptr, size);
4907 }
4908
4909 if (res < 0) {
4910 PyErr_SetString(PyExc_RuntimeError, "PyTraceMalloc_Track error");
4911 return NULL;
4912 }
4913
4914 Py_RETURN_NONE;
4915}
4916
4917static PyObject *
4918tracemalloc_untrack(PyObject *self, PyObject *args)
4919{
4920 unsigned int domain;
4921 PyObject *ptr_obj;
4922 void *ptr;
4923 int res;
4924
4925 if (!PyArg_ParseTuple(args, "IO", &domain, &ptr_obj))
4926 return NULL;
4927 ptr = PyLong_AsVoidPtr(ptr_obj);
4928 if (PyErr_Occurred())
4929 return NULL;
4930
4931 res = PyTraceMalloc_Untrack(domain, (uintptr_t)ptr);
4932 if (res < 0) {
4933 PyErr_SetString(PyExc_RuntimeError, "PyTraceMalloc_Untrack error");
4934 return NULL;
4935 }
4936
4937 Py_RETURN_NONE;
4938}
4939
4940static PyObject *
4941tracemalloc_get_traceback(PyObject *self, PyObject *args)
4942{
4943 unsigned int domain;
4944 PyObject *ptr_obj;
4945 void *ptr;
4946
4947 if (!PyArg_ParseTuple(args, "IO", &domain, &ptr_obj))
4948 return NULL;
4949 ptr = PyLong_AsVoidPtr(ptr_obj);
4950 if (PyErr_Occurred())
4951 return NULL;
4952
4953 return _PyTraceMalloc_GetTraceback(domain, (uintptr_t)ptr);
4954}
4955
4956static PyObject *
4957dict_get_version(PyObject *self, PyObject *args)
4958{
4959 PyDictObject *dict;
4960 uint64_t version;
4961
4962 if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &dict))
4963 return NULL;
4964
4965 version = dict->ma_version_tag;
4966
4967 Py_BUILD_ASSERT(sizeof(unsigned long long) >= sizeof(version));
4968 return PyLong_FromUnsignedLongLong((unsigned long long)version);
4969}
4970
4971
4972static PyObject *
4973raise_SIGINT_then_send_None(PyObject *self, PyObject *args)
4974{
4975 _Py_IDENTIFIER(send);
4976 PyGenObject *gen;
4977
4978 if (!PyArg_ParseTuple(args, "O!", &PyGen_Type, &gen))
4979 return NULL;
4980
4981 /* This is used in a test to check what happens if a signal arrives just
4982 as we're in the process of entering a yield from chain (see
4983 bpo-30039).
4984
4985 Needs to be done in C, because:
4986 - we don't have a Python wrapper for raise()
4987 - we need to make sure that the Python-level signal handler doesn't run
4988 *before* we enter the generator frame, which is impossible in Python
4989 because we check for signals before every bytecode operation.
4990 */
4991 raise(SIGINT);
4992 return _PyObject_CallMethodIdOneArg((PyObject *)gen, &PyId_send, Py_None);
4993}
4994
4995
4996static int
4997fastcall_args(PyObject *args, PyObject ***stack, Py_ssize_t *nargs)
4998{
4999 if (args == Py_None) {
5000 *stack = NULL;
5001 *nargs = 0;
5002 }
5003 else if (PyTuple_Check(args)) {
5004 *stack = ((PyTupleObject *)args)->ob_item;
5005 *nargs = PyTuple_GET_SIZE(args);
5006 }
5007 else {
5008 PyErr_SetString(PyExc_TypeError, "args must be None or a tuple");
5009 return -1;
5010 }
5011 return 0;
5012}
5013
5014
5015static PyObject *
5016test_pyobject_fastcall(PyObject *self, PyObject *args)
5017{
5018 PyObject *func, *func_args;
5019 PyObject **stack;
5020 Py_ssize_t nargs;
5021
5022 if (!PyArg_ParseTuple(args, "OO", &func, &func_args)) {
5023 return NULL;
5024 }
5025
5026 if (fastcall_args(func_args, &stack, &nargs) < 0) {
5027 return NULL;
5028 }
5029 return _PyObject_FastCall(func, stack, nargs);
5030}
5031
5032
5033static PyObject *
5034test_pyobject_fastcalldict(PyObject *self, PyObject *args)
5035{
5036 PyObject *func, *func_args, *kwargs;
5037 PyObject **stack;
5038 Py_ssize_t nargs;
5039
5040 if (!PyArg_ParseTuple(args, "OOO", &func, &func_args, &kwargs)) {
5041 return NULL;
5042 }
5043
5044 if (fastcall_args(func_args, &stack, &nargs) < 0) {
5045 return NULL;
5046 }
5047
5048 if (kwargs == Py_None) {
5049 kwargs = NULL;
5050 }
5051 else if (!PyDict_Check(kwargs)) {
5052 PyErr_SetString(PyExc_TypeError, "kwnames must be None or a dict");
5053 return NULL;
5054 }
5055
5056 return PyObject_VectorcallDict(func, stack, nargs, kwargs);
5057}
5058
5059
5060static PyObject *
5061test_pyobject_vectorcall(PyObject *self, PyObject *args)
5062{
5063 PyObject *func, *func_args, *kwnames = NULL;
5064 PyObject **stack;
5065 Py_ssize_t nargs, nkw;
5066
5067 if (!PyArg_ParseTuple(args, "OOO", &func, &func_args, &kwnames)) {
5068 return NULL;
5069 }
5070
5071 if (fastcall_args(func_args, &stack, &nargs) < 0) {
5072 return NULL;
5073 }
5074
5075 if (kwnames == Py_None) {
5076 kwnames = NULL;
5077 }
5078 else if (PyTuple_Check(kwnames)) {
5079 nkw = PyTuple_GET_SIZE(kwnames);
5080 if (nargs < nkw) {
5081 PyErr_SetString(PyExc_ValueError, "kwnames longer than args");
5082 return NULL;
5083 }
5084 nargs -= nkw;
5085 }
5086 else {
5087 PyErr_SetString(PyExc_TypeError, "kwnames must be None or a tuple");
5088 return NULL;
5089 }
5090 return PyObject_Vectorcall(func, stack, nargs, kwnames);
5091}
5092
5093
5094static PyObject *
5095test_pyvectorcall_call(PyObject *self, PyObject *args)
5096{
5097 PyObject *func;
5098 PyObject *argstuple;
5099 PyObject *kwargs = NULL;
5100
5101 if (!PyArg_ParseTuple(args, "OO|O", &func, &argstuple, &kwargs)) {
5102 return NULL;
5103 }
5104
5105 if (!PyTuple_Check(argstuple)) {
5106 PyErr_SetString(PyExc_TypeError, "args must be a tuple");
5107 return NULL;
5108 }
5109 if (kwargs != NULL && !PyDict_Check(kwargs)) {
5110 PyErr_SetString(PyExc_TypeError, "kwargs must be a dict");
5111 return NULL;
5112 }
5113
5114 return PyVectorcall_Call(func, argstuple, kwargs);
5115}
5116
5117
5118static PyObject*
5119stack_pointer(PyObject *self, PyObject *args)
5120{
5121 int v = 5;
5122 return PyLong_FromVoidPtr(&v);
5123}
5124
5125
5126#ifdef W_STOPCODE
5127static PyObject*
5128py_w_stopcode(PyObject *self, PyObject *args)
5129{
5130 int sig, status;
5131 if (!PyArg_ParseTuple(args, "i", &sig)) {
5132 return NULL;
5133 }
5134 status = W_STOPCODE(sig);
5135 return PyLong_FromLong(status);
5136}
5137#endif
5138
5139
5140static PyObject *
5141get_mapping_keys(PyObject* self, PyObject *obj)
5142{
5143 return PyMapping_Keys(obj);
5144}
5145
5146static PyObject *
5147get_mapping_values(PyObject* self, PyObject *obj)
5148{
5149 return PyMapping_Values(obj);
5150}
5151
5152static PyObject *
5153get_mapping_items(PyObject* self, PyObject *obj)
5154{
5155 return PyMapping_Items(obj);
5156}
5157
5158
5159static PyObject *
5160test_pythread_tss_key_state(PyObject *self, PyObject *args)
5161{
5162 Py_tss_t tss_key = Py_tss_NEEDS_INIT;
5163 if (PyThread_tss_is_created(&tss_key)) {
5164 return raiseTestError("test_pythread_tss_key_state",
5165 "TSS key not in an uninitialized state at "
5166 "creation time");
5167 }
5168 if (PyThread_tss_create(&tss_key) != 0) {
5169 PyErr_SetString(PyExc_RuntimeError, "PyThread_tss_create failed");
5170 return NULL;
5171 }
5172 if (!PyThread_tss_is_created(&tss_key)) {
5173 return raiseTestError("test_pythread_tss_key_state",
5174 "PyThread_tss_create succeeded, "
5175 "but with TSS key in an uninitialized state");
5176 }
5177 if (PyThread_tss_create(&tss_key) != 0) {
5178 return raiseTestError("test_pythread_tss_key_state",
5179 "PyThread_tss_create unsuccessful with "
5180 "an already initialized key");
5181 }
5182#define CHECK_TSS_API(expr) \
5183 (void)(expr); \
5184 if (!PyThread_tss_is_created(&tss_key)) { \
5185 return raiseTestError("test_pythread_tss_key_state", \
5186 "TSS key initialization state was not " \
5187 "preserved after calling " #expr); }
5188 CHECK_TSS_API(PyThread_tss_set(&tss_key, NULL));
5189 CHECK_TSS_API(PyThread_tss_get(&tss_key));
5190#undef CHECK_TSS_API
5191 PyThread_tss_delete(&tss_key);
5192 if (PyThread_tss_is_created(&tss_key)) {
5193 return raiseTestError("test_pythread_tss_key_state",
5194 "PyThread_tss_delete called, but did not "
5195 "set the key state to uninitialized");
5196 }
5197
5198 Py_tss_t *ptr_key = PyThread_tss_alloc();
5199 if (ptr_key == NULL) {
5200 PyErr_SetString(PyExc_RuntimeError, "PyThread_tss_alloc failed");
5201 return NULL;
5202 }
5203 if (PyThread_tss_is_created(ptr_key)) {
5204 return raiseTestError("test_pythread_tss_key_state",
5205 "TSS key not in an uninitialized state at "
5206 "allocation time");
5207 }
5208 PyThread_tss_free(ptr_key);
5209 ptr_key = NULL;
5210 Py_RETURN_NONE;
5211}
5212
5213
5214static PyObject*
5215new_hamt(PyObject *self, PyObject *args)
5216{
5217 return _PyContext_NewHamtForTests();
5218}
5219
5220
5221/* def bad_get(self, obj, cls):
5222 cls()
5223 return repr(self)
5224*/
5225static PyObject*
5226bad_get(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
5227{
5228 PyObject *self, *obj, *cls;
5229 if (!_PyArg_UnpackStack(args, nargs, "bad_get", 3, 3, &self, &obj, &cls)) {
5230 return NULL;
5231 }
5232
5233 PyObject *res = _PyObject_CallNoArg(cls);
5234 if (res == NULL) {
5235 return NULL;
5236 }
5237 Py_DECREF(res);
5238
5239 return PyObject_Repr(self);
5240}
5241
5242
5243static PyObject *
5244encode_locale_ex(PyObject *self, PyObject *args)
5245{
5246 PyObject *unicode;
5247 int current_locale = 0;
5248 wchar_t *wstr;
5249 PyObject *res = NULL;
5250 const char *errors = NULL;
5251
5252 if (!PyArg_ParseTuple(args, "U|is", &unicode, &current_locale, &errors)) {
5253 return NULL;
5254 }
5255 wstr = PyUnicode_AsWideCharString(unicode, NULL);
5256 if (wstr == NULL) {
5257 return NULL;
5258 }
5259 _Py_error_handler error_handler = _Py_GetErrorHandler(errors);
5260
5261 char *str = NULL;
5262 size_t error_pos;
5263 const char *reason = NULL;
5264 int ret = _Py_EncodeLocaleEx(wstr,
5265 &str, &error_pos, &reason,
5266 current_locale, error_handler);
5267 PyMem_Free(wstr);
5268
5269 switch(ret) {
5270 case 0:
5271 res = PyBytes_FromString(str);
5272 PyMem_RawFree(str);
5273 break;
5274 case -1:
5275 PyErr_NoMemory();
5276 break;
5277 case -2:
5278 PyErr_Format(PyExc_RuntimeError, "encode error: pos=%zu, reason=%s",
5279 error_pos, reason);
5280 break;
5281 case -3:
5282 PyErr_SetString(PyExc_ValueError, "unsupported error handler");
5283 break;
5284 default:
5285 PyErr_SetString(PyExc_ValueError, "unknown error code");
5286 break;
5287 }
5288 return res;
5289}
5290
5291
5292static PyObject *
5293decode_locale_ex(PyObject *self, PyObject *args)
5294{
5295 char *str;
5296 int current_locale = 0;
5297 PyObject *res = NULL;
5298 const char *errors = NULL;
5299
5300 if (!PyArg_ParseTuple(args, "y|is", &str, &current_locale, &errors)) {
5301 return NULL;
5302 }
5303 _Py_error_handler error_handler = _Py_GetErrorHandler(errors);
5304
5305 wchar_t *wstr = NULL;
5306 size_t wlen = 0;
5307 const char *reason = NULL;
5308 int ret = _Py_DecodeLocaleEx(str,
5309 &wstr, &wlen, &reason,
5310 current_locale, error_handler);
5311
5312 switch(ret) {
5313 case 0:
5314 res = PyUnicode_FromWideChar(wstr, wlen);
5315 PyMem_RawFree(wstr);
5316 break;
5317 case -1:
5318 PyErr_NoMemory();
5319 break;
5320 case -2:
5321 PyErr_Format(PyExc_RuntimeError, "decode error: pos=%zu, reason=%s",
5322 wlen, reason);
5323 break;
5324 case -3:
5325 PyErr_SetString(PyExc_ValueError, "unsupported error handler");
5326 break;
5327 default:
5328 PyErr_SetString(PyExc_ValueError, "unknown error code");
5329 break;
5330 }
5331 return res;
5332}
5333
5334
5335#ifdef Py_REF_DEBUG
5336static PyObject *
5337negative_refcount(PyObject *self, PyObject *Py_UNUSED(args))
5338{
5339 PyObject *obj = PyUnicode_FromString("negative_refcount");
5340 if (obj == NULL) {
5341 return NULL;
5342 }
5343 assert(Py_REFCNT(obj) == 1);
5344
5345 Py_SET_REFCNT(obj, 0);
5346 /* Py_DECREF() must call _Py_NegativeRefcount() and abort Python */
5347 Py_DECREF(obj);
5348
5349 Py_RETURN_NONE;
5350}
5351#endif
5352
5353
5354static PyObject*
5355test_write_unraisable_exc(PyObject *self, PyObject *args)
5356{
5357 PyObject *exc, *err_msg, *obj;
5358 if (!PyArg_ParseTuple(args, "OOO", &exc, &err_msg, &obj)) {
5359 return NULL;
5360 }
5361
5362 const char *err_msg_utf8;
5363 if (err_msg != Py_None) {
5364 err_msg_utf8 = PyUnicode_AsUTF8(err_msg);
5365 if (err_msg_utf8 == NULL) {
5366 return NULL;
5367 }
5368 }
5369 else {
5370 err_msg_utf8 = NULL;
5371 }
5372
5373 PyErr_SetObject((PyObject *)Py_TYPE(exc), exc);
5374 _PyErr_WriteUnraisableMsg(err_msg_utf8, obj);
5375 Py_RETURN_NONE;
5376}
5377
5378
5379static PyObject *
5380sequence_getitem(PyObject *self, PyObject *args)
5381{
5382 PyObject *seq;
5383 Py_ssize_t i;
5384 if (!PyArg_ParseTuple(args, "On", &seq, &i)) {
5385 return NULL;
5386 }
5387 return PySequence_GetItem(seq, i);
5388}
5389
5390
5391/* Functions for testing C calling conventions (METH_*) are named meth_*,
5392 * e.g. "meth_varargs" for METH_VARARGS.
5393 *
5394 * They all return a tuple of their C-level arguments, with None instead
5395 * of NULL and Python tuples instead of C arrays.
5396 */
5397
5398
5399static PyObject*
5400_null_to_none(PyObject* obj)
5401{
5402 if (obj == NULL) {
5403 Py_RETURN_NONE;
5404 }
5405 Py_INCREF(obj);
5406 return obj;
5407}
5408
5409static PyObject*
5410meth_varargs(PyObject* self, PyObject* args)
5411{
5412 return Py_BuildValue("NO", _null_to_none(self), args);
5413}
5414
5415static PyObject*
5416meth_varargs_keywords(PyObject* self, PyObject* args, PyObject* kwargs)
5417{
5418 return Py_BuildValue("NON", _null_to_none(self), args, _null_to_none(kwargs));
5419}
5420
5421static PyObject*
5422meth_o(PyObject* self, PyObject* obj)
5423{
5424 return Py_BuildValue("NO", _null_to_none(self), obj);
5425}
5426
5427static PyObject*
5428meth_noargs(PyObject* self, PyObject* ignored)
5429{
5430 return _null_to_none(self);
5431}
5432
5433static PyObject*
5434_fastcall_to_tuple(PyObject* const* args, Py_ssize_t nargs)
5435{
5436 PyObject *tuple = PyTuple_New(nargs);
5437 if (tuple == NULL) {
5438 return NULL;
5439 }
5440 for (Py_ssize_t i=0; i < nargs; i++) {
5441 Py_INCREF(args[i]);
5442 PyTuple_SET_ITEM(tuple, i, args[i]);
5443 }
5444 return tuple;
5445}
5446
5447static PyObject*
5448meth_fastcall(PyObject* self, PyObject* const* args, Py_ssize_t nargs)
5449{
5450 return Py_BuildValue(
5451 "NN", _null_to_none(self), _fastcall_to_tuple(args, nargs)
5452 );
5453}
5454
5455static PyObject*
5456meth_fastcall_keywords(PyObject* self, PyObject* const* args,
5457 Py_ssize_t nargs, PyObject* kwargs)
5458{
5459 PyObject *pyargs = _fastcall_to_tuple(args, nargs);
5460 if (pyargs == NULL) {
5461 return NULL;
5462 }
5463 PyObject *pykwargs = PyObject_Vectorcall((PyObject*)&PyDict_Type,
5464 args + nargs, 0, kwargs);
5465 return Py_BuildValue("NNN", _null_to_none(self), pyargs, pykwargs);
5466}
5467
5468
5469static PyObject*
5470pynumber_tobase(PyObject *module, PyObject *args)
5471{
5472 PyObject *obj;
5473 int base;
5474 if (!PyArg_ParseTuple(args, "Oi:pynumber_tobase",
5475 &obj, &base)) {
5476 return NULL;
5477 }
5478 return PyNumber_ToBase(obj, base);
5479}
5480
5481
5482static PyObject*
5483test_set_type_size(PyObject *self, PyObject *Py_UNUSED(ignored))
5484{
5485 PyObject *obj = PyList_New(0);
5486 if (obj == NULL) {
5487 return NULL;
5488 }
5489
5490 // Ensure that following tests don't modify the object,
5491 // to ensure that Py_DECREF() will not crash.
5492 assert(Py_TYPE(obj) == &PyList_Type);
5493 assert(Py_SIZE(obj) == 0);
5494
5495 // bpo-39573: Check that Py_TYPE() and Py_SIZE() can be used
5496 // as l-values to set an object type and size.
5497 Py_TYPE(obj) = &PyList_Type;
5498 Py_SIZE(obj) = 0;
5499
5500 Py_DECREF(obj);
5501 Py_RETURN_NONE;
5502}
5503
5504
5505#define TEST_REFCOUNT() \
5506 do { \
5507 PyObject *obj = PyList_New(0); \
5508 if (obj == NULL) { \
5509 return NULL; \
5510 } \
5511 assert(Py_REFCNT(obj) == 1); \
5512 \
5513 /* test Py_NewRef() */ \
5514 PyObject *ref = Py_NewRef(obj); \
5515 assert(ref == obj); \
5516 assert(Py_REFCNT(obj) == 2); \
5517 Py_DECREF(ref); \
5518 \
5519 /* test Py_XNewRef() */ \
5520 PyObject *xref = Py_XNewRef(obj); \
5521 assert(xref == obj); \
5522 assert(Py_REFCNT(obj) == 2); \
5523 Py_DECREF(xref); \
5524 \
5525 assert(Py_XNewRef(NULL) == NULL); \
5526 \
5527 Py_DECREF(obj); \
5528 Py_RETURN_NONE; \
5529 } while (0) \
5530
5531
5532// Test Py_NewRef() and Py_XNewRef() macros
5533static PyObject*
5534test_refcount_macros(PyObject *self, PyObject *Py_UNUSED(ignored))
5535{
5536 TEST_REFCOUNT();
5537}
5538
5539#undef Py_NewRef
5540#undef Py_XNewRef
5541
5542// Test Py_NewRef() and Py_XNewRef() functions, after undefining macros.
5543static PyObject*
5544test_refcount_funcs(PyObject *self, PyObject *Py_UNUSED(ignored))
5545{
5546 TEST_REFCOUNT();
5547}
5548
5549
5550// Test Py_Is() function
5551#define TEST_PY_IS() \
5552 do { \
5553 PyObject *o_none = Py_None; \
5554 PyObject *o_true = Py_True; \
5555 PyObject *o_false = Py_False; \
5556 PyObject *obj = PyList_New(0); \
5557 if (obj == NULL) { \
5558 return NULL; \
5559 } \
5560 \
5561 /* test Py_Is() */ \
5562 assert(Py_Is(obj, obj)); \
5563 assert(!Py_Is(obj, o_none)); \
5564 \
5565 /* test Py_None */ \
5566 assert(Py_Is(o_none, o_none)); \
5567 assert(!Py_Is(obj, o_none)); \
5568 \
5569 /* test Py_True */ \
5570 assert(Py_Is(o_true, o_true)); \
5571 assert(!Py_Is(o_false, o_true)); \
5572 assert(!Py_Is(obj, o_true)); \
5573 \
5574 /* test Py_False */ \
5575 assert(Py_Is(o_false, o_false)); \
5576 assert(!Py_Is(o_true, o_false)); \
5577 assert(!Py_Is(obj, o_false)); \
5578 \
5579 Py_DECREF(obj); \
5580 Py_RETURN_NONE; \
5581 } while (0)
5582
5583// Test Py_Is() macro
5584static PyObject*
5585test_py_is_macros(PyObject *self, PyObject *Py_UNUSED(ignored))
5586{
5587 TEST_PY_IS();
5588}
5589
5590#undef Py_Is
5591
5592// Test Py_Is() function, after undefining its macro.
5593static PyObject*
5594test_py_is_funcs(PyObject *self, PyObject *Py_UNUSED(ignored))
5595{
5596 TEST_PY_IS();
5597}
5598
5599
5600static PyObject *
5601test_fatal_error(PyObject *self, PyObject *args)
5602{
5603 char *message;
5604 int release_gil = 0;
5605 if (!PyArg_ParseTuple(args, "y|i:fatal_error", &message, &release_gil))
5606 return NULL;
5607 if (release_gil) {
5608 Py_BEGIN_ALLOW_THREADS
5609 Py_FatalError(message);
5610 Py_END_ALLOW_THREADS
5611 }
5612 else {
5613 Py_FatalError(message);
5614 }
5615 // Py_FatalError() does not return, but exits the process.
5616 Py_RETURN_NONE;
5617}
5618
5619
5620static PyObject *test_buildvalue_issue38913(PyObject *, PyObject *);
5621static PyObject *getargs_s_hash_int(PyObject *, PyObject *, PyObject*);
5622
5623static PyMethodDef TestMethods[] = {
5624 {"raise_exception", raise_exception, METH_VARARGS},
5625 {"raise_memoryerror", raise_memoryerror, METH_NOARGS},
5626 {"set_errno", set_errno, METH_VARARGS},
5627 {"test_config", test_config, METH_NOARGS},
5628 {"test_sizeof_c_types", test_sizeof_c_types, METH_NOARGS},
5629 {"test_datetime_capi", test_datetime_capi, METH_NOARGS},
5630 {"datetime_check_date", datetime_check_date, METH_VARARGS},
5631 {"datetime_check_time", datetime_check_time, METH_VARARGS},
5632 {"datetime_check_datetime", datetime_check_datetime, METH_VARARGS},
5633 {"datetime_check_delta", datetime_check_delta, METH_VARARGS},
5634 {"datetime_check_tzinfo", datetime_check_tzinfo, METH_VARARGS},
5635 {"make_timezones_capi", make_timezones_capi, METH_NOARGS},
5636 {"get_timezones_offset_zero", get_timezones_offset_zero, METH_NOARGS},
5637 {"get_timezone_utc_capi", get_timezone_utc_capi, METH_VARARGS},
5638 {"get_date_fromdate", get_date_fromdate, METH_VARARGS},
5639 {"get_datetime_fromdateandtime", get_datetime_fromdateandtime, METH_VARARGS},
5640 {"get_datetime_fromdateandtimeandfold", get_datetime_fromdateandtimeandfold, METH_VARARGS},
5641 {"get_time_fromtime", get_time_fromtime, METH_VARARGS},
5642 {"get_time_fromtimeandfold", get_time_fromtimeandfold, METH_VARARGS},
5643 {"get_delta_fromdsu", get_delta_fromdsu, METH_VARARGS},
5644 {"get_date_fromtimestamp", get_date_fromtimestamp, METH_VARARGS},
5645 {"get_datetime_fromtimestamp", get_datetime_fromtimestamp, METH_VARARGS},
5646 {"PyDateTime_GET", test_PyDateTime_GET, METH_O},
5647 {"PyDateTime_DATE_GET", test_PyDateTime_DATE_GET, METH_O},
5648 {"PyDateTime_TIME_GET", test_PyDateTime_TIME_GET, METH_O},
5649 {"PyDateTime_DELTA_GET", test_PyDateTime_DELTA_GET, METH_O},
5650 {"test_gc_control", test_gc_control, METH_NOARGS},
5651 {"test_list_api", test_list_api, METH_NOARGS},
5652 {"test_dict_iteration", test_dict_iteration, METH_NOARGS},
5653 {"dict_getitem_knownhash", dict_getitem_knownhash, METH_VARARGS},
5654 {"dict_hassplittable", dict_hassplittable, METH_O},
5655 {"test_lazy_hash_inheritance", test_lazy_hash_inheritance,METH_NOARGS},
5656 {"test_long_api", test_long_api, METH_NOARGS},
5657 {"test_xincref_doesnt_leak",test_xincref_doesnt_leak, METH_NOARGS},
5658 {"test_incref_doesnt_leak", test_incref_doesnt_leak, METH_NOARGS},
5659 {"test_xdecref_doesnt_leak",test_xdecref_doesnt_leak, METH_NOARGS},
5660 {"test_decref_doesnt_leak", test_decref_doesnt_leak, METH_NOARGS},
5661 {"test_structseq_newtype_doesnt_leak",
5662 test_structseq_newtype_doesnt_leak, METH_NOARGS},
5663 {"test_structseq_newtype_null_descr_doc",
5664 test_structseq_newtype_null_descr_doc, METH_NOARGS},
5665 {"test_incref_decref_API", test_incref_decref_API, METH_NOARGS},
5666 {"test_long_and_overflow", test_long_and_overflow, METH_NOARGS},
5667 {"test_long_as_double", test_long_as_double, METH_NOARGS},
5668 {"test_long_as_size_t", test_long_as_size_t, METH_NOARGS},
5669 {"test_long_as_unsigned_long_long_mask",
5670 test_long_as_unsigned_long_long_mask, METH_NOARGS},
5671 {"test_long_numbits", test_long_numbits, METH_NOARGS},
5672 {"test_k_code", test_k_code, METH_NOARGS},
5673 {"test_empty_argparse", test_empty_argparse, METH_NOARGS},
5674 {"parse_tuple_and_keywords", parse_tuple_and_keywords, METH_VARARGS},
5675 {"pyobject_repr_from_null", pyobject_repr_from_null, METH_NOARGS},
5676 {"pyobject_str_from_null", pyobject_str_from_null, METH_NOARGS},
5677 {"pyobject_bytes_from_null", pyobject_bytes_from_null, METH_NOARGS},
5678 {"test_string_from_format", (PyCFunction)test_string_from_format, METH_NOARGS},
5679 {"test_with_docstring", test_with_docstring, METH_NOARGS,
5680 PyDoc_STR("This is a pretty normal docstring.")},
5681 {"test_string_to_double", test_string_to_double, METH_NOARGS},
5682 {"test_unicode_compare_with_ascii", test_unicode_compare_with_ascii,
5683 METH_NOARGS},
5684 {"test_capsule", (PyCFunction)test_capsule, METH_NOARGS},
5685 {"test_from_contiguous", (PyCFunction)test_from_contiguous, METH_NOARGS},
5686#if (defined(__linux__) || defined(__FreeBSD__)) && defined(__GNUC__)
5687 {"test_pep3118_obsolete_write_locks", (PyCFunction)test_pep3118_obsolete_write_locks, METH_NOARGS},
5688#endif
5689 {"getbuffer_with_null_view", getbuffer_with_null_view, METH_O},
5690 {"PyBuffer_SizeFromFormat", test_PyBuffer_SizeFromFormat, METH_VARARGS},
5691 {"test_buildvalue_N", test_buildvalue_N, METH_NOARGS},
5692 {"test_buildvalue_issue38913", test_buildvalue_issue38913, METH_NOARGS},
5693 {"get_args", get_args, METH_VARARGS},
5694 {"test_get_statictype_slots", test_get_statictype_slots, METH_NOARGS},
5695 {"get_kwargs", (PyCFunction)(void(*)(void))get_kwargs,
5696 METH_VARARGS|METH_KEYWORDS},
5697 {"getargs_tuple", getargs_tuple, METH_VARARGS},
5698 {"getargs_keywords", (PyCFunction)(void(*)(void))getargs_keywords,
5699 METH_VARARGS|METH_KEYWORDS},
5700 {"getargs_keyword_only", (PyCFunction)(void(*)(void))getargs_keyword_only,
5701 METH_VARARGS|METH_KEYWORDS},
5702 {"getargs_positional_only_and_keywords",
5703 (PyCFunction)(void(*)(void))getargs_positional_only_and_keywords,
5704 METH_VARARGS|METH_KEYWORDS},
5705 {"getargs_b", getargs_b, METH_VARARGS},
5706 {"getargs_B", getargs_B, METH_VARARGS},
5707 {"getargs_h", getargs_h, METH_VARARGS},
5708 {"getargs_H", getargs_H, METH_VARARGS},
5709 {"getargs_I", getargs_I, METH_VARARGS},
5710 {"getargs_k", getargs_k, METH_VARARGS},
5711 {"getargs_i", getargs_i, METH_VARARGS},
5712 {"getargs_l", getargs_l, METH_VARARGS},
5713 {"getargs_n", getargs_n, METH_VARARGS},
5714 {"getargs_p", getargs_p, METH_VARARGS},
5715 {"getargs_L", getargs_L, METH_VARARGS},
5716 {"getargs_K", getargs_K, METH_VARARGS},
5717 {"test_longlong_api", test_longlong_api, METH_NOARGS},
5718 {"test_long_long_and_overflow",test_long_long_and_overflow, METH_NOARGS},
5719 {"test_L_code", test_L_code, METH_NOARGS},
5720 {"getargs_f", getargs_f, METH_VARARGS},
5721 {"getargs_d", getargs_d, METH_VARARGS},
5722 {"getargs_D", getargs_D, METH_VARARGS},
5723 {"getargs_S", getargs_S, METH_VARARGS},
5724 {"getargs_Y", getargs_Y, METH_VARARGS},
5725 {"getargs_U", getargs_U, METH_VARARGS},
5726 {"getargs_c", getargs_c, METH_VARARGS},
5727 {"getargs_C", getargs_C, METH_VARARGS},
5728 {"getargs_s", getargs_s, METH_VARARGS},
5729 {"getargs_s_star", getargs_s_star, METH_VARARGS},
5730 {"getargs_s_hash", getargs_s_hash, METH_VARARGS},
5731 {"getargs_s_hash_int", (PyCFunction)(void(*)(void))getargs_s_hash_int,
5732 METH_VARARGS|METH_KEYWORDS},
5733 {"getargs_z", getargs_z, METH_VARARGS},
5734 {"getargs_z_star", getargs_z_star, METH_VARARGS},
5735 {"getargs_z_hash", getargs_z_hash, METH_VARARGS},
5736 {"getargs_y", getargs_y, METH_VARARGS},
5737 {"getargs_y_star", getargs_y_star, METH_VARARGS},
5738 {"getargs_y_hash", getargs_y_hash, METH_VARARGS},
5739 {"getargs_u", getargs_u, METH_VARARGS},
5740 {"getargs_u_hash", getargs_u_hash, METH_VARARGS},
5741 {"getargs_Z", getargs_Z, METH_VARARGS},
5742 {"getargs_Z_hash", getargs_Z_hash, METH_VARARGS},
5743 {"getargs_w_star", getargs_w_star, METH_VARARGS},
5744 {"getargs_es", getargs_es, METH_VARARGS},
5745 {"getargs_et", getargs_et, METH_VARARGS},
5746 {"getargs_es_hash", getargs_es_hash, METH_VARARGS},
5747 {"getargs_et_hash", getargs_et_hash, METH_VARARGS},
5748 {"codec_incrementalencoder",
5749 (PyCFunction)codec_incrementalencoder, METH_VARARGS},
5750 {"codec_incrementaldecoder",
5751 (PyCFunction)codec_incrementaldecoder, METH_VARARGS},
5752 {"test_s_code", test_s_code, METH_NOARGS},
5753#if USE_UNICODE_WCHAR_CACHE
5754 {"test_u_code", test_u_code, METH_NOARGS},
5755 {"test_Z_code", test_Z_code, METH_NOARGS},
5756#endif /* USE_UNICODE_WCHAR_CACHE */
5757 {"test_widechar", test_widechar, METH_NOARGS},
5758 {"unicode_aswidechar", unicode_aswidechar, METH_VARARGS},
5759 {"unicode_aswidecharstring",unicode_aswidecharstring, METH_VARARGS},
5760 {"unicode_asucs4", unicode_asucs4, METH_VARARGS},
5761 {"unicode_asutf8", unicode_asutf8, METH_VARARGS},
5762 {"unicode_asutf8andsize", unicode_asutf8andsize, METH_VARARGS},
5763 {"unicode_findchar", unicode_findchar, METH_VARARGS},
5764 {"unicode_copycharacters", unicode_copycharacters, METH_VARARGS},
5765#if USE_UNICODE_WCHAR_CACHE
5766 {"unicode_encodedecimal", unicode_encodedecimal, METH_VARARGS},
5767 {"unicode_transformdecimaltoascii", unicode_transformdecimaltoascii, METH_VARARGS},
5768 {"unicode_legacy_string", unicode_legacy_string, METH_VARARGS},
5769#endif /* USE_UNICODE_WCHAR_CACHE */
5770 {"_test_thread_state", test_thread_state, METH_VARARGS},
5771 {"_pending_threadfunc", pending_threadfunc, METH_VARARGS},
5772#ifdef HAVE_GETTIMEOFDAY
5773 {"profile_int", profile_int, METH_NOARGS},
5774#endif
5775 {"traceback_print", traceback_print, METH_VARARGS},
5776 {"exception_print", exception_print, METH_VARARGS},
5777 {"set_exc_info", test_set_exc_info, METH_VARARGS},
5778 {"argparsing", argparsing, METH_VARARGS},
5779 {"code_newempty", code_newempty, METH_VARARGS},
5780 {"make_exception_with_doc", (PyCFunction)(void(*)(void))make_exception_with_doc,
5781 METH_VARARGS | METH_KEYWORDS},
5782 {"make_memoryview_from_NULL_pointer", make_memoryview_from_NULL_pointer,
5783 METH_NOARGS},
5784 {"crash_no_current_thread", crash_no_current_thread, METH_NOARGS},
5785 {"run_in_subinterp", run_in_subinterp, METH_VARARGS},
5786 {"pytime_object_to_time_t", test_pytime_object_to_time_t, METH_VARARGS},
5787 {"pytime_object_to_timeval", test_pytime_object_to_timeval, METH_VARARGS},
5788 {"pytime_object_to_timespec", test_pytime_object_to_timespec, METH_VARARGS},
5789 {"with_tp_del", with_tp_del, METH_VARARGS},
5790 {"create_cfunction", create_cfunction, METH_NOARGS},
5791 {"test_pymem_alloc0", test_pymem_alloc0, METH_NOARGS},
5792 {"test_pymem_setrawallocators",test_pymem_setrawallocators, METH_NOARGS},
5793 {"test_pymem_setallocators",test_pymem_setallocators, METH_NOARGS},
5794 {"test_pyobject_setallocators",test_pyobject_setallocators, METH_NOARGS},
5795 {"set_nomemory", (PyCFunction)set_nomemory, METH_VARARGS,
5796 PyDoc_STR("set_nomemory(start:int, stop:int = 0)")},
5797 {"remove_mem_hooks", remove_mem_hooks, METH_NOARGS,
5798 PyDoc_STR("Remove memory hooks.")},
5799 {"no_docstring",
5800 (PyCFunction)test_with_docstring, METH_NOARGS},
5801 {"docstring_empty",
5802 (PyCFunction)test_with_docstring, METH_NOARGS,
5803 docstring_empty},
5804 {"docstring_no_signature",
5805 (PyCFunction)test_with_docstring, METH_NOARGS,
5806 docstring_no_signature},
5807 {"docstring_with_invalid_signature",
5808 (PyCFunction)test_with_docstring, METH_NOARGS,
5809 docstring_with_invalid_signature},
5810 {"docstring_with_invalid_signature2",
5811 (PyCFunction)test_with_docstring, METH_NOARGS,
5812 docstring_with_invalid_signature2},
5813 {"docstring_with_signature",
5814 (PyCFunction)test_with_docstring, METH_NOARGS,
5815 docstring_with_signature},
5816 {"docstring_with_signature_but_no_doc",
5817 (PyCFunction)test_with_docstring, METH_NOARGS,
5818 docstring_with_signature_but_no_doc},
5819 {"docstring_with_signature_and_extra_newlines",
5820 (PyCFunction)test_with_docstring, METH_NOARGS,
5821 docstring_with_signature_and_extra_newlines},
5822 {"docstring_with_signature_with_defaults",
5823 (PyCFunction)test_with_docstring, METH_NOARGS,
5824 docstring_with_signature_with_defaults},
5825 {"call_in_temporary_c_thread", call_in_temporary_c_thread, METH_O,
5826 PyDoc_STR("set_error_class(error_class) -> None")},
5827 {"pymarshal_write_long_to_file",
5828 pymarshal_write_long_to_file, METH_VARARGS},
5829 {"pymarshal_write_object_to_file",
5830 pymarshal_write_object_to_file, METH_VARARGS},
5831 {"pymarshal_read_short_from_file",
5832 pymarshal_read_short_from_file, METH_VARARGS},
5833 {"pymarshal_read_long_from_file",
5834 pymarshal_read_long_from_file, METH_VARARGS},
5835 {"pymarshal_read_last_object_from_file",
5836 pymarshal_read_last_object_from_file, METH_VARARGS},
5837 {"pymarshal_read_object_from_file",
5838 pymarshal_read_object_from_file, METH_VARARGS},
5839 {"return_null_without_error", return_null_without_error, METH_NOARGS},
5840 {"return_result_with_error", return_result_with_error, METH_NOARGS},
5841 {"getitem_with_error", getitem_with_error, METH_VARARGS},
5842 {"Py_CompileString", pycompilestring, METH_O},
5843 {"PyTime_FromSeconds", test_pytime_fromseconds, METH_VARARGS},
5844 {"PyTime_FromSecondsObject", test_pytime_fromsecondsobject, METH_VARARGS},
5845 {"PyTime_AsSecondsDouble", test_pytime_assecondsdouble, METH_VARARGS},
5846 {"PyTime_AsTimeval", test_PyTime_AsTimeval, METH_VARARGS},
5847#ifdef HAVE_CLOCK_GETTIME
5848 {"PyTime_AsTimespec", test_PyTime_AsTimespec, METH_VARARGS},
5849#endif
5850 {"PyTime_AsMilliseconds", test_PyTime_AsMilliseconds, METH_VARARGS},
5851 {"PyTime_AsMicroseconds", test_PyTime_AsMicroseconds, METH_VARARGS},
5852 {"pymem_buffer_overflow", pymem_buffer_overflow, METH_NOARGS},
5853 {"pymem_api_misuse", pymem_api_misuse, METH_NOARGS},
5854 {"pymem_malloc_without_gil", pymem_malloc_without_gil, METH_NOARGS},
5855 {"pymem_getallocatorsname", test_pymem_getallocatorsname, METH_NOARGS},
5856 {"check_pyobject_null_is_freed", check_pyobject_null_is_freed, METH_NOARGS},
5857 {"check_pyobject_uninitialized_is_freed", check_pyobject_uninitialized_is_freed, METH_NOARGS},
5858 {"check_pyobject_forbidden_bytes_is_freed", check_pyobject_forbidden_bytes_is_freed, METH_NOARGS},
5859 {"check_pyobject_freed_is_freed", check_pyobject_freed_is_freed, METH_NOARGS},
5860 {"pyobject_malloc_without_gil", pyobject_malloc_without_gil, METH_NOARGS},
5861 {"tracemalloc_track", tracemalloc_track, METH_VARARGS},
5862 {"tracemalloc_untrack", tracemalloc_untrack, METH_VARARGS},
5863 {"tracemalloc_get_traceback", tracemalloc_get_traceback, METH_VARARGS},
5864 {"dict_get_version", dict_get_version, METH_VARARGS},
5865 {"raise_SIGINT_then_send_None", raise_SIGINT_then_send_None, METH_VARARGS},
5866 {"pyobject_fastcall", test_pyobject_fastcall, METH_VARARGS},
5867 {"pyobject_fastcalldict", test_pyobject_fastcalldict, METH_VARARGS},
5868 {"pyobject_vectorcall", test_pyobject_vectorcall, METH_VARARGS},
5869 {"pyvectorcall_call", test_pyvectorcall_call, METH_VARARGS},
5870 {"stack_pointer", stack_pointer, METH_NOARGS},
5871#ifdef W_STOPCODE
5872 {"W_STOPCODE", py_w_stopcode, METH_VARARGS},
5873#endif
5874 {"get_mapping_keys", get_mapping_keys, METH_O},
5875 {"get_mapping_values", get_mapping_values, METH_O},
5876 {"get_mapping_items", get_mapping_items, METH_O},
5877 {"test_pythread_tss_key_state", test_pythread_tss_key_state, METH_VARARGS},
5878 {"hamt", new_hamt, METH_NOARGS},
5879 {"bad_get", (PyCFunction)(void(*)(void))bad_get, METH_FASTCALL},
5880 {"EncodeLocaleEx", encode_locale_ex, METH_VARARGS},
5881 {"DecodeLocaleEx", decode_locale_ex, METH_VARARGS},
5882#ifdef Py_REF_DEBUG
5883 {"negative_refcount", negative_refcount, METH_NOARGS},
5884#endif
5885 {"write_unraisable_exc", test_write_unraisable_exc, METH_VARARGS},
5886 {"sequence_getitem", sequence_getitem, METH_VARARGS},
5887 {"meth_varargs", meth_varargs, METH_VARARGS},
5888 {"meth_varargs_keywords", (PyCFunction)(void(*)(void))meth_varargs_keywords, METH_VARARGS|METH_KEYWORDS},
5889 {"meth_o", meth_o, METH_O},
5890 {"meth_noargs", meth_noargs, METH_NOARGS},
5891 {"meth_fastcall", (PyCFunction)(void(*)(void))meth_fastcall, METH_FASTCALL},
5892 {"meth_fastcall_keywords", (PyCFunction)(void(*)(void))meth_fastcall_keywords, METH_FASTCALL|METH_KEYWORDS},
5893 {"pynumber_tobase", pynumber_tobase, METH_VARARGS},
5894 {"without_gc", without_gc, METH_O},
5895 {"test_set_type_size", test_set_type_size, METH_NOARGS},
5896 {"test_refcount_macros", test_refcount_macros, METH_NOARGS},
5897 {"test_refcount_funcs", test_refcount_funcs, METH_NOARGS},
5898 {"test_py_is_macros", test_py_is_macros, METH_NOARGS},
5899 {"test_py_is_funcs", test_py_is_funcs, METH_NOARGS},
5900 {"fatal_error", test_fatal_error, METH_VARARGS,
5901 PyDoc_STR("fatal_error(message, release_gil=False): call Py_FatalError(message)")},
5902 {NULL, NULL} /* sentinel */
5903};
5904
5905#define AddSym(d, n, f, v) {PyObject *o = f(v); PyDict_SetItemString(d, n, o); Py_DECREF(o);}
5906
5907typedef struct {
5908 char bool_member;
5909 char byte_member;
5910 unsigned char ubyte_member;
5911 short short_member;
5912 unsigned short ushort_member;
5913 int int_member;
5914 unsigned int uint_member;
5915 long long_member;
5916 unsigned long ulong_member;
5917 Py_ssize_t pyssizet_member;
5918 float float_member;
5919 double double_member;
5920 char inplace_member[6];
5921 long long longlong_member;
5922 unsigned long long ulonglong_member;
5923} all_structmembers;
5924
5925typedef struct {
5926 PyObject_HEAD
5927 all_structmembers structmembers;
5928} test_structmembers;
5929
5930static struct PyMemberDef test_members[] = {
5931 {"T_BOOL", T_BOOL, offsetof(test_structmembers, structmembers.bool_member), 0, NULL},
5932 {"T_BYTE", T_BYTE, offsetof(test_structmembers, structmembers.byte_member), 0, NULL},
5933 {"T_UBYTE", T_UBYTE, offsetof(test_structmembers, structmembers.ubyte_member), 0, NULL},
5934 {"T_SHORT", T_SHORT, offsetof(test_structmembers, structmembers.short_member), 0, NULL},
5935 {"T_USHORT", T_USHORT, offsetof(test_structmembers, structmembers.ushort_member), 0, NULL},
5936 {"T_INT", T_INT, offsetof(test_structmembers, structmembers.int_member), 0, NULL},
5937 {"T_UINT", T_UINT, offsetof(test_structmembers, structmembers.uint_member), 0, NULL},
5938 {"T_LONG", T_LONG, offsetof(test_structmembers, structmembers.long_member), 0, NULL},
5939 {"T_ULONG", T_ULONG, offsetof(test_structmembers, structmembers.ulong_member), 0, NULL},
5940 {"T_PYSSIZET", T_PYSSIZET, offsetof(test_structmembers, structmembers.pyssizet_member), 0, NULL},
5941 {"T_FLOAT", T_FLOAT, offsetof(test_structmembers, structmembers.float_member), 0, NULL},
5942 {"T_DOUBLE", T_DOUBLE, offsetof(test_structmembers, structmembers.double_member), 0, NULL},
5943 {"T_STRING_INPLACE", T_STRING_INPLACE, offsetof(test_structmembers, structmembers.inplace_member), 0, NULL},
5944 {"T_LONGLONG", T_LONGLONG, offsetof(test_structmembers, structmembers.longlong_member), 0, NULL},
5945 {"T_ULONGLONG", T_ULONGLONG, offsetof(test_structmembers, structmembers.ulonglong_member), 0, NULL},
5946 {NULL}
5947};
5948
5949
5950static PyObject *
5951test_structmembers_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
5952{
5953 static char *keywords[] = {
5954 "T_BOOL", "T_BYTE", "T_UBYTE", "T_SHORT", "T_USHORT",
5955 "T_INT", "T_UINT", "T_LONG", "T_ULONG", "T_PYSSIZET",
5956 "T_FLOAT", "T_DOUBLE", "T_STRING_INPLACE",
5957 "T_LONGLONG", "T_ULONGLONG",
5958 NULL};
5959 static const char fmt[] = "|bbBhHiIlknfds#LK";
5960 test_structmembers *ob;
5961 const char *s = NULL;
5962 Py_ssize_t string_len = 0;
5963 ob = PyObject_New(test_structmembers, type);
5964 if (ob == NULL)
5965 return NULL;
5966 memset(&ob->structmembers, 0, sizeof(all_structmembers));
5967 if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,
5968 &ob->structmembers.bool_member,
5969 &ob->structmembers.byte_member,
5970 &ob->structmembers.ubyte_member,
5971 &ob->structmembers.short_member,
5972 &ob->structmembers.ushort_member,
5973 &ob->structmembers.int_member,
5974 &ob->structmembers.uint_member,
5975 &ob->structmembers.long_member,
5976 &ob->structmembers.ulong_member,
5977 &ob->structmembers.pyssizet_member,
5978 &ob->structmembers.float_member,
5979 &ob->structmembers.double_member,
5980 &s, &string_len
5981 , &ob->structmembers.longlong_member,
5982 &ob->structmembers.ulonglong_member
5983 )) {
5984 Py_DECREF(ob);
5985 return NULL;
5986 }
5987 if (s != NULL) {
5988 if (string_len > 5) {
5989 Py_DECREF(ob);
5990 PyErr_SetString(PyExc_ValueError, "string too long");
5991 return NULL;
5992 }
5993 strcpy(ob->structmembers.inplace_member, s);
5994 }
5995 else {
5996 strcpy(ob->structmembers.inplace_member, "");
5997 }
5998 return (PyObject *)ob;
5999}
6000
6001static void
6002test_structmembers_free(PyObject *ob)
6003{
6004 PyObject_Free(ob);
6005}
6006
6007static PyTypeObject test_structmembersType = {
6008 PyVarObject_HEAD_INIT(NULL, 0)
6009 "test_structmembersType",
6010 sizeof(test_structmembers), /* tp_basicsize */
6011 0, /* tp_itemsize */
6012 test_structmembers_free, /* destructor tp_dealloc */
6013 0, /* tp_vectorcall_offset */
6014 0, /* tp_getattr */
6015 0, /* tp_setattr */
6016 0, /* tp_as_async */
6017 0, /* tp_repr */
6018 0, /* tp_as_number */
6019 0, /* tp_as_sequence */
6020 0, /* tp_as_mapping */
6021 0, /* tp_hash */
6022 0, /* tp_call */
6023 0, /* tp_str */
6024 PyObject_GenericGetAttr, /* tp_getattro */
6025 PyObject_GenericSetAttr, /* tp_setattro */
6026 0, /* tp_as_buffer */
6027 0, /* tp_flags */
6028 "Type containing all structmember types",
6029 0, /* traverseproc tp_traverse */
6030 0, /* tp_clear */
6031 0, /* tp_richcompare */
6032 0, /* tp_weaklistoffset */
6033 0, /* tp_iter */
6034 0, /* tp_iternext */
6035 0, /* tp_methods */
6036 test_members, /* tp_members */
6037 0,
6038 0,
6039 0,
6040 0,
6041 0,
6042 0,
6043 0,
6044 0,
6045 test_structmembers_new, /* tp_new */
6046};
6047
6048
6049typedef struct {
6050 PyObject_HEAD
6051} matmulObject;
6052
6053static PyObject *
6054matmulType_matmul(PyObject *self, PyObject *other)
6055{
6056 return Py_BuildValue("(sOO)", "matmul", self, other);
6057}
6058
6059static PyObject *
6060matmulType_imatmul(PyObject *self, PyObject *other)
6061{
6062 return Py_BuildValue("(sOO)", "imatmul", self, other);
6063}
6064
6065static void
6066matmulType_dealloc(PyObject *self)
6067{
6068 Py_TYPE(self)->tp_free(self);
6069}
6070
6071static PyNumberMethods matmulType_as_number = {
6072 0, /* nb_add */
6073 0, /* nb_subtract */
6074 0, /* nb_multiply */
6075 0, /* nb_remainde r*/
6076 0, /* nb_divmod */
6077 0, /* nb_power */
6078 0, /* nb_negative */
6079 0, /* tp_positive */
6080 0, /* tp_absolute */
6081 0, /* tp_bool */
6082 0, /* nb_invert */
6083 0, /* nb_lshift */
6084 0, /* nb_rshift */
6085 0, /* nb_and */
6086 0, /* nb_xor */
6087 0, /* nb_or */
6088 0, /* nb_int */
6089 0, /* nb_reserved */
6090 0, /* nb_float */
6091 0, /* nb_inplace_add */
6092 0, /* nb_inplace_subtract */
6093 0, /* nb_inplace_multiply */
6094 0, /* nb_inplace_remainder */
6095 0, /* nb_inplace_power */
6096 0, /* nb_inplace_lshift */
6097 0, /* nb_inplace_rshift */
6098 0, /* nb_inplace_and */
6099 0, /* nb_inplace_xor */
6100 0, /* nb_inplace_or */
6101 0, /* nb_floor_divide */
6102 0, /* nb_true_divide */
6103 0, /* nb_inplace_floor_divide */
6104 0, /* nb_inplace_true_divide */
6105 0, /* nb_index */
6106 matmulType_matmul, /* nb_matrix_multiply */
6107 matmulType_imatmul /* nb_matrix_inplace_multiply */
6108};
6109
6110static PyTypeObject matmulType = {
6111 PyVarObject_HEAD_INIT(NULL, 0)
6112 "matmulType",
6113 sizeof(matmulObject), /* tp_basicsize */
6114 0, /* tp_itemsize */
6115 matmulType_dealloc, /* destructor tp_dealloc */
6116 0, /* tp_vectorcall_offset */
6117 0, /* tp_getattr */
6118 0, /* tp_setattr */
6119 0, /* tp_as_async */
6120 0, /* tp_repr */
6121 &matmulType_as_number, /* tp_as_number */
6122 0, /* tp_as_sequence */
6123 0, /* tp_as_mapping */
6124 0, /* tp_hash */
6125 0, /* tp_call */
6126 0, /* tp_str */
6127 PyObject_GenericGetAttr, /* tp_getattro */
6128 PyObject_GenericSetAttr, /* tp_setattro */
6129 0, /* tp_as_buffer */
6130 0, /* tp_flags */
6131 "C level type with matrix operations defined",
6132 0, /* traverseproc tp_traverse */
6133 0, /* tp_clear */
6134 0, /* tp_richcompare */
6135 0, /* tp_weaklistoffset */
6136 0, /* tp_iter */
6137 0, /* tp_iternext */
6138 0, /* tp_methods */
6139 0, /* tp_members */
6140 0,
6141 0,
6142 0,
6143 0,
6144 0,
6145 0,
6146 0,
6147 0,
6148 PyType_GenericNew, /* tp_new */
6149 PyObject_Del, /* tp_free */
6150};
6151
6152typedef struct {
6153 PyObject_HEAD
6154} ipowObject;
6155
6156static PyObject *
6157ipowType_ipow(PyObject *self, PyObject *other, PyObject *mod)
6158{
6159 return Py_BuildValue("OO", other, mod);
6160}
6161
6162static PyNumberMethods ipowType_as_number = {
6163 .nb_inplace_power = ipowType_ipow
6164};
6165
6166static PyTypeObject ipowType = {
6167 PyVarObject_HEAD_INIT(NULL, 0)
6168 .tp_name = "ipowType",
6169 .tp_basicsize = sizeof(ipowObject),
6170 .tp_as_number = &ipowType_as_number,
6171 .tp_new = PyType_GenericNew
6172};
6173
6174typedef struct {
6175 PyObject_HEAD
6176 PyObject *ao_iterator;
6177} awaitObject;
6178
6179
6180static PyObject *
6181awaitObject_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
6182{
6183 PyObject *v;
6184 awaitObject *ao;
6185
6186 if (!PyArg_UnpackTuple(args, "awaitObject", 1, 1, &v))
6187 return NULL;
6188
6189 ao = (awaitObject *)type->tp_alloc(type, 0);
6190 if (ao == NULL) {
6191 return NULL;
6192 }
6193
6194 Py_INCREF(v);
6195 ao->ao_iterator = v;
6196
6197 return (PyObject *)ao;
6198}
6199
6200
6201static void
6202awaitObject_dealloc(awaitObject *ao)
6203{
6204 Py_CLEAR(ao->ao_iterator);
6205 Py_TYPE(ao)->tp_free(ao);
6206}
6207
6208
6209static PyObject *
6210awaitObject_await(awaitObject *ao)
6211{
6212 Py_INCREF(ao->ao_iterator);
6213 return ao->ao_iterator;
6214}
6215
6216static PyAsyncMethods awaitType_as_async = {
6217 (unaryfunc)awaitObject_await, /* am_await */
6218 0, /* am_aiter */
6219 0, /* am_anext */
6220 0, /* am_send */
6221};
6222
6223
6224static PyTypeObject awaitType = {
6225 PyVarObject_HEAD_INIT(NULL, 0)
6226 "awaitType",
6227 sizeof(awaitObject), /* tp_basicsize */
6228 0, /* tp_itemsize */
6229 (destructor)awaitObject_dealloc, /* destructor tp_dealloc */
6230 0, /* tp_vectorcall_offset */
6231 0, /* tp_getattr */
6232 0, /* tp_setattr */
6233 &awaitType_as_async, /* tp_as_async */
6234 0, /* tp_repr */
6235 0, /* tp_as_number */
6236 0, /* tp_as_sequence */
6237 0, /* tp_as_mapping */
6238 0, /* tp_hash */
6239 0, /* tp_call */
6240 0, /* tp_str */
6241 PyObject_GenericGetAttr, /* tp_getattro */
6242 PyObject_GenericSetAttr, /* tp_setattro */
6243 0, /* tp_as_buffer */
6244 0, /* tp_flags */
6245 "C level type with tp_as_async",
6246 0, /* traverseproc tp_traverse */
6247 0, /* tp_clear */
6248 0, /* tp_richcompare */
6249 0, /* tp_weaklistoffset */
6250 0, /* tp_iter */
6251 0, /* tp_iternext */
6252 0, /* tp_methods */
6253 0, /* tp_members */
6254 0,
6255 0,
6256 0,
6257 0,
6258 0,
6259 0,
6260 0,
6261 0,
6262 awaitObject_new, /* tp_new */
6263 PyObject_Del, /* tp_free */
6264};
6265
6266
6267static int recurse_infinitely_error_init(PyObject *, PyObject *, PyObject *);
6268
6269static PyTypeObject PyRecursingInfinitelyError_Type = {
6270 PyVarObject_HEAD_INIT(NULL, 0)
6271 "RecursingInfinitelyError", /* tp_name */
6272 sizeof(PyBaseExceptionObject), /* tp_basicsize */
6273 0, /* tp_itemsize */
6274 0, /* tp_dealloc */
6275 0, /* tp_vectorcall_offset */
6276 0, /* tp_getattr */
6277 0, /* tp_setattr */
6278 0, /* tp_as_async */
6279 0, /* tp_repr */
6280 0, /* tp_as_number */
6281 0, /* tp_as_sequence */
6282 0, /* tp_as_mapping */
6283 0, /* tp_hash */
6284 0, /* tp_call */
6285 0, /* tp_str */
6286 0, /* tp_getattro */
6287 0, /* tp_setattro */
6288 0, /* tp_as_buffer */
6289 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
6290 PyDoc_STR("Instantiating this exception starts infinite recursion."), /* tp_doc */
6291 0, /* tp_traverse */
6292 0, /* tp_clear */
6293 0, /* tp_richcompare */
6294 0, /* tp_weaklistoffset */
6295 0, /* tp_iter */
6296 0, /* tp_iternext */
6297 0, /* tp_methods */
6298 0, /* tp_members */
6299 0, /* tp_getset */
6300 0, /* tp_base */
6301 0, /* tp_dict */
6302 0, /* tp_descr_get */
6303 0, /* tp_descr_set */
6304 0, /* tp_dictoffset */
6305 (initproc)recurse_infinitely_error_init, /* tp_init */
6306 0, /* tp_alloc */
6307 0, /* tp_new */
6308};
6309
6310static int
6311recurse_infinitely_error_init(PyObject *self, PyObject *args, PyObject *kwds)
6312{
6313 PyObject *type = (PyObject *)&PyRecursingInfinitelyError_Type;
6314
6315 /* Instantiating this exception starts infinite recursion. */
6316 Py_INCREF(type);
6317 PyErr_SetObject(type, NULL);
6318 return -1;
6319}
6320
6321
6322/* Test bpo-35983: create a subclass of "list" which checks that instances
6323 * are not deallocated twice */
6324
6325typedef struct {
6326 PyListObject list;
6327 int deallocated;
6328} MyListObject;
6329
6330static PyObject *
6331MyList_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
6332{
6333 PyObject* op = PyList_Type.tp_new(type, args, kwds);
6334 ((MyListObject*)op)->deallocated = 0;
6335 return op;
6336}
6337
6338void
6339MyList_dealloc(MyListObject* op)
6340{
6341 if (op->deallocated) {
6342 /* We cannot raise exceptions here but we still want the testsuite
6343 * to fail when we hit this */
6344 Py_FatalError("MyList instance deallocated twice");
6345 }
6346 op->deallocated = 1;
6347 PyList_Type.tp_dealloc((PyObject *)op);
6348}
6349
6350static PyTypeObject MyList_Type = {
6351 PyVarObject_HEAD_INIT(NULL, 0)
6352 "MyList",
6353 sizeof(MyListObject),
6354 0,
6355 (destructor)MyList_dealloc, /* tp_dealloc */
6356 0, /* tp_vectorcall_offset */
6357 0, /* tp_getattr */
6358 0, /* tp_setattr */
6359 0, /* tp_as_async */
6360 0, /* tp_repr */
6361 0, /* tp_as_number */
6362 0, /* tp_as_sequence */
6363 0, /* tp_as_mapping */
6364 0, /* tp_hash */
6365 0, /* tp_call */
6366 0, /* tp_str */
6367 0, /* tp_getattro */
6368 0, /* tp_setattro */
6369 0, /* tp_as_buffer */
6370 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
6371 0, /* tp_doc */
6372 0, /* tp_traverse */
6373 0, /* tp_clear */
6374 0, /* tp_richcompare */
6375 0, /* tp_weaklistoffset */
6376 0, /* tp_iter */
6377 0, /* tp_iternext */
6378 0, /* tp_methods */
6379 0, /* tp_members */
6380 0, /* tp_getset */
6381 0, /* &PyList_Type */ /* tp_base */
6382 0, /* tp_dict */
6383 0, /* tp_descr_get */
6384 0, /* tp_descr_set */
6385 0, /* tp_dictoffset */
6386 0, /* tp_init */
6387 0, /* tp_alloc */
6388 MyList_new, /* tp_new */
6389};
6390
6391
6392/* Test PEP 560 */
6393
6394typedef struct {
6395 PyObject_HEAD
6396 PyObject *item;
6397} PyGenericAliasObject;
6398
6399static void
6400generic_alias_dealloc(PyGenericAliasObject *self)
6401{
6402 Py_CLEAR(self->item);
6403 Py_TYPE(self)->tp_free((PyObject *)self);
6404}
6405
6406static PyObject *
6407generic_alias_mro_entries(PyGenericAliasObject *self, PyObject *bases)
6408{
6409 return PyTuple_Pack(1, self->item);
6410}
6411
6412static PyMethodDef generic_alias_methods[] = {
6413 {"__mro_entries__", (PyCFunction)(void(*)(void))generic_alias_mro_entries, METH_O, NULL},
6414 {NULL} /* sentinel */
6415};
6416
6417static PyTypeObject GenericAlias_Type = {
6418 PyVarObject_HEAD_INIT(NULL, 0)
6419 "GenericAlias",
6420 sizeof(PyGenericAliasObject),
6421 0,
6422 .tp_dealloc = (destructor)generic_alias_dealloc,
6423 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6424 .tp_methods = generic_alias_methods,
6425};
6426
6427static PyObject *
6428generic_alias_new(PyObject *item)
6429{
6430 PyGenericAliasObject *o = PyObject_New(PyGenericAliasObject, &GenericAlias_Type);
6431 if (o == NULL) {
6432 return NULL;
6433 }
6434 Py_INCREF(item);
6435 o->item = item;
6436 return (PyObject*) o;
6437}
6438
6439typedef struct {
6440 PyObject_HEAD
6441} PyGenericObject;
6442
6443static PyObject *
6444generic_class_getitem(PyObject *type, PyObject *item)
6445{
6446 return generic_alias_new(item);
6447}
6448
6449static PyMethodDef generic_methods[] = {
6450 {"__class_getitem__", generic_class_getitem, METH_O|METH_CLASS, NULL},
6451 {NULL} /* sentinel */
6452};
6453
6454static PyTypeObject Generic_Type = {
6455 PyVarObject_HEAD_INIT(NULL, 0)
6456 "Generic",
6457 sizeof(PyGenericObject),
6458 0,
6459 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6460 .tp_methods = generic_methods,
6461};
6462
6463
6464/* Test PEP 590 */
6465
6466typedef struct {
6467 PyObject_HEAD
6468 vectorcallfunc vectorcall;
6469} MethodDescriptorObject;
6470
6471static PyObject *
6472MethodDescriptor_vectorcall(PyObject *callable, PyObject *const *args,
6473 size_t nargsf, PyObject *kwnames)
6474{
6475 /* True if using the vectorcall function in MethodDescriptorObject
6476 * but False for MethodDescriptor2Object */
6477 MethodDescriptorObject *md = (MethodDescriptorObject *)callable;
6478 return PyBool_FromLong(md->vectorcall != NULL);
6479}
6480
6481static PyObject *
6482MethodDescriptor_new(PyTypeObject* type, PyObject* args, PyObject *kw)
6483{
6484 MethodDescriptorObject *op = (MethodDescriptorObject *)type->tp_alloc(type, 0);
6485 op->vectorcall = MethodDescriptor_vectorcall;
6486 return (PyObject *)op;
6487}
6488
6489static PyObject *
6490func_descr_get(PyObject *func, PyObject *obj, PyObject *type)
6491{
6492 if (obj == Py_None || obj == NULL) {
6493 Py_INCREF(func);
6494 return func;
6495 }
6496 return PyMethod_New(func, obj);
6497}
6498
6499static PyObject *
6500nop_descr_get(PyObject *func, PyObject *obj, PyObject *type)
6501{
6502 Py_INCREF(func);
6503 return func;
6504}
6505
6506static PyObject *
6507call_return_args(PyObject *self, PyObject *args, PyObject *kwargs)
6508{
6509 Py_INCREF(args);
6510 return args;
6511}
6512
6513static PyTypeObject MethodDescriptorBase_Type = {
6514 PyVarObject_HEAD_INIT(NULL, 0)
6515 "MethodDescriptorBase",
6516 sizeof(MethodDescriptorObject),
6517 .tp_new = MethodDescriptor_new,
6518 .tp_call = PyVectorcall_Call,
6519 .tp_vectorcall_offset = offsetof(MethodDescriptorObject, vectorcall),
6520 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
6521 Py_TPFLAGS_METHOD_DESCRIPTOR | Py_TPFLAGS_HAVE_VECTORCALL,
6522 .tp_descr_get = func_descr_get,
6523};
6524
6525static PyTypeObject MethodDescriptorDerived_Type = {
6526 PyVarObject_HEAD_INIT(NULL, 0)
6527 "MethodDescriptorDerived",
6528 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6529};
6530
6531static PyTypeObject MethodDescriptorNopGet_Type = {
6532 PyVarObject_HEAD_INIT(NULL, 0)
6533 "MethodDescriptorNopGet",
6534 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6535 .tp_call = call_return_args,
6536 .tp_descr_get = nop_descr_get,
6537};
6538
6539typedef struct {
6540 MethodDescriptorObject base;
6541 vectorcallfunc vectorcall;
6542} MethodDescriptor2Object;
6543
6544static PyObject *
6545MethodDescriptor2_new(PyTypeObject* type, PyObject* args, PyObject *kw)
6546{
6547 MethodDescriptor2Object *op = PyObject_New(MethodDescriptor2Object, type);
6548 op->base.vectorcall = NULL;
6549 op->vectorcall = MethodDescriptor_vectorcall;
6550 return (PyObject *)op;
6551}
6552
6553static PyTypeObject MethodDescriptor2_Type = {
6554 PyVarObject_HEAD_INIT(NULL, 0)
6555 "MethodDescriptor2",
6556 sizeof(MethodDescriptor2Object),
6557 .tp_new = MethodDescriptor2_new,
6558 .tp_call = PyVectorcall_Call,
6559 .tp_vectorcall_offset = offsetof(MethodDescriptor2Object, vectorcall),
6560 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_VECTORCALL,
6561};
6562
6563PyDoc_STRVAR(heapdocctype__doc__,
6564"HeapDocCType(arg1, arg2)\n"
6565"--\n"
6566"\n"
6567"somedoc");
6568
6569typedef struct {
6570 PyObject_HEAD
6571} HeapDocCTypeObject;
6572
6573static PyType_Slot HeapDocCType_slots[] = {
6574 {Py_tp_doc, (char*)heapdocctype__doc__},
6575 {0},
6576};
6577
6578static PyType_Spec HeapDocCType_spec = {
6579 "_testcapi.HeapDocCType",
6580 sizeof(HeapDocCTypeObject),
6581 0,
6582 Py_TPFLAGS_DEFAULT,
6583 HeapDocCType_slots
6584};
6585
6586typedef struct {
6587 PyObject_HEAD
6588} NullTpDocTypeObject;
6589
6590static PyType_Slot NullTpDocType_slots[] = {
6591 {Py_tp_doc, NULL},
6592 {0, 0},
6593};
6594
6595static PyType_Spec NullTpDocType_spec = {
6596 "_testcapi.NullTpDocType",
6597 sizeof(NullTpDocTypeObject),
6598 0,
6599 Py_TPFLAGS_DEFAULT,
6600 NullTpDocType_slots
6601};
6602
6603
6604PyDoc_STRVAR(heapgctype__doc__,
6605"A heap type with GC, and with overridden dealloc.\n\n"
6606"The 'value' attribute is set to 10 in __init__.");
6607
6608typedef struct {
6609 PyObject_HEAD
6610 int value;
6611} HeapCTypeObject;
6612
6613static struct PyMemberDef heapctype_members[] = {
6614 {"value", T_INT, offsetof(HeapCTypeObject, value)},
6615 {NULL} /* Sentinel */
6616};
6617
6618static int
6619heapctype_init(PyObject *self, PyObject *args, PyObject *kwargs)
6620{
6621 ((HeapCTypeObject *)self)->value = 10;
6622 return 0;
6623}
6624
6625static int
6626heapgcctype_traverse(HeapCTypeObject *self, visitproc visit, void *arg)
6627{
6628 Py_VISIT(Py_TYPE(self));
6629 return 0;
6630}
6631
6632static void
6633heapgcctype_dealloc(HeapCTypeObject *self)
6634{
6635 PyTypeObject *tp = Py_TYPE(self);
6636 PyObject_GC_UnTrack(self);
6637 PyObject_GC_Del(self);
6638 Py_DECREF(tp);
6639}
6640
6641static PyType_Slot HeapGcCType_slots[] = {
6642 {Py_tp_init, heapctype_init},
6643 {Py_tp_members, heapctype_members},
6644 {Py_tp_dealloc, heapgcctype_dealloc},
6645 {Py_tp_traverse, heapgcctype_traverse},
6646 {Py_tp_doc, (char*)heapgctype__doc__},
6647 {0, 0},
6648};
6649
6650static PyType_Spec HeapGcCType_spec = {
6651 "_testcapi.HeapGcCType",
6652 sizeof(HeapCTypeObject),
6653 0,
6654 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
6655 HeapGcCType_slots
6656};
6657
6658PyDoc_STRVAR(heapctype__doc__,
6659"A heap type without GC, but with overridden dealloc.\n\n"
6660"The 'value' attribute is set to 10 in __init__.");
6661
6662static void
6663heapctype_dealloc(HeapCTypeObject *self)
6664{
6665 PyTypeObject *tp = Py_TYPE(self);
6666 PyObject_Free(self);
6667 Py_DECREF(tp);
6668}
6669
6670static PyType_Slot HeapCType_slots[] = {
6671 {Py_tp_init, heapctype_init},
6672 {Py_tp_members, heapctype_members},
6673 {Py_tp_dealloc, heapctype_dealloc},
6674 {Py_tp_doc, (char*)heapctype__doc__},
6675 {0, 0},
6676};
6677
6678static PyType_Spec HeapCType_spec = {
6679 "_testcapi.HeapCType",
6680 sizeof(HeapCTypeObject),
6681 0,
6682 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6683 HeapCType_slots
6684};
6685
6686PyDoc_STRVAR(heapctypesubclass__doc__,
6687"Subclass of HeapCType, without GC.\n\n"
6688"__init__ sets the 'value' attribute to 10 and 'value2' to 20.");
6689
6690typedef struct {
6691 HeapCTypeObject base;
6692 int value2;
6693} HeapCTypeSubclassObject;
6694
6695static int
6696heapctypesubclass_init(PyObject *self, PyObject *args, PyObject *kwargs)
6697{
6698 /* Call __init__ of the superclass */
6699 if (heapctype_init(self, args, kwargs) < 0) {
6700 return -1;
6701 }
6702 /* Initialize additional element */
6703 ((HeapCTypeSubclassObject *)self)->value2 = 20;
6704 return 0;
6705}
6706
6707static struct PyMemberDef heapctypesubclass_members[] = {
6708 {"value2", T_INT, offsetof(HeapCTypeSubclassObject, value2)},
6709 {NULL} /* Sentinel */
6710};
6711
6712static PyType_Slot HeapCTypeSubclass_slots[] = {
6713 {Py_tp_init, heapctypesubclass_init},
6714 {Py_tp_members, heapctypesubclass_members},
6715 {Py_tp_doc, (char*)heapctypesubclass__doc__},
6716 {0, 0},
6717};
6718
6719static PyType_Spec HeapCTypeSubclass_spec = {
6720 "_testcapi.HeapCTypeSubclass",
6721 sizeof(HeapCTypeSubclassObject),
6722 0,
6723 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6724 HeapCTypeSubclass_slots
6725};
6726
6727PyDoc_STRVAR(heapctypewithbuffer__doc__,
6728"Heap type with buffer support.\n\n"
6729"The buffer is set to [b'1', b'2', b'3', b'4']");
6730
6731typedef struct {
6732 HeapCTypeObject base;
6733 char buffer[4];
6734} HeapCTypeWithBufferObject;
6735
6736static int
6737heapctypewithbuffer_getbuffer(HeapCTypeWithBufferObject *self, Py_buffer *view, int flags)
6738{
6739 self->buffer[0] = '1';
6740 self->buffer[1] = '2';
6741 self->buffer[2] = '3';
6742 self->buffer[3] = '4';
6743 return PyBuffer_FillInfo(
6744 view, (PyObject*)self, (void *)self->buffer, 4, 1, flags);
6745}
6746
6747static void
6748heapctypewithbuffer_releasebuffer(HeapCTypeWithBufferObject *self, Py_buffer *view)
6749{
6750 assert(view->obj == (void*) self);
6751}
6752
6753static PyType_Slot HeapCTypeWithBuffer_slots[] = {
6754 {Py_bf_getbuffer, heapctypewithbuffer_getbuffer},
6755 {Py_bf_releasebuffer, heapctypewithbuffer_releasebuffer},
6756 {Py_tp_doc, (char*)heapctypewithbuffer__doc__},
6757 {0, 0},
6758};
6759
6760static PyType_Spec HeapCTypeWithBuffer_spec = {
6761 "_testcapi.HeapCTypeWithBuffer",
6762 sizeof(HeapCTypeWithBufferObject),
6763 0,
6764 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6765 HeapCTypeWithBuffer_slots
6766};
6767
6768PyDoc_STRVAR(heapctypesubclasswithfinalizer__doc__,
6769"Subclass of HeapCType with a finalizer that reassigns __class__.\n\n"
6770"__class__ is set to plain HeapCTypeSubclass during finalization.\n"
6771"__init__ sets the 'value' attribute to 10 and 'value2' to 20.");
6772
6773static int
6774heapctypesubclasswithfinalizer_init(PyObject *self, PyObject *args, PyObject *kwargs)
6775{
6776 PyTypeObject *base = (PyTypeObject *)PyType_GetSlot(Py_TYPE(self), Py_tp_base);
6777 initproc base_init = PyType_GetSlot(base, Py_tp_init);
6778 base_init(self, args, kwargs);
6779 return 0;
6780}
6781
6782static void
6783heapctypesubclasswithfinalizer_finalize(PyObject *self)
6784{
6785 PyObject *error_type, *error_value, *error_traceback, *m;
6786 PyObject *oldtype = NULL, *newtype = NULL, *refcnt = NULL;
6787
6788 /* Save the current exception, if any. */
6789 PyErr_Fetch(&error_type, &error_value, &error_traceback);
6790
6791 m = PyState_FindModule(&_testcapimodule);
6792 if (m == NULL) {
6793 goto cleanup_finalize;
6794 }
6795 oldtype = PyObject_GetAttrString(m, "HeapCTypeSubclassWithFinalizer");
6796 newtype = PyObject_GetAttrString(m, "HeapCTypeSubclass");
6797 if (oldtype == NULL || newtype == NULL) {
6798 goto cleanup_finalize;
6799 }
6800
6801 if (PyObject_SetAttrString(self, "__class__", newtype) < 0) {
6802 goto cleanup_finalize;
6803 }
6804 refcnt = PyLong_FromSsize_t(Py_REFCNT(oldtype));
6805 if (refcnt == NULL) {
6806 goto cleanup_finalize;
6807 }
6808 if (PyObject_SetAttrString(oldtype, "refcnt_in_del", refcnt) < 0) {
6809 goto cleanup_finalize;
6810 }
6811 Py_DECREF(refcnt);
6812 refcnt = PyLong_FromSsize_t(Py_REFCNT(newtype));
6813 if (refcnt == NULL) {
6814 goto cleanup_finalize;
6815 }
6816 if (PyObject_SetAttrString(newtype, "refcnt_in_del", refcnt) < 0) {
6817 goto cleanup_finalize;
6818 }
6819
6820cleanup_finalize:
6821 Py_XDECREF(oldtype);
6822 Py_XDECREF(newtype);
6823 Py_XDECREF(refcnt);
6824
6825 /* Restore the saved exception. */
6826 PyErr_Restore(error_type, error_value, error_traceback);
6827}
6828
6829static PyType_Slot HeapCTypeSubclassWithFinalizer_slots[] = {
6830 {Py_tp_init, heapctypesubclasswithfinalizer_init},
6831 {Py_tp_members, heapctypesubclass_members},
6832 {Py_tp_finalize, heapctypesubclasswithfinalizer_finalize},
6833 {Py_tp_doc, (char*)heapctypesubclasswithfinalizer__doc__},
6834 {0, 0},
6835};
6836
6837static PyType_Spec HeapCTypeSubclassWithFinalizer_spec = {
6838 "_testcapi.HeapCTypeSubclassWithFinalizer",
6839 sizeof(HeapCTypeSubclassObject),
6840 0,
6841 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_FINALIZE,
6842 HeapCTypeSubclassWithFinalizer_slots
6843};
6844
6845typedef struct {
6846 PyObject_HEAD
6847 PyObject *dict;
6848} HeapCTypeWithDictObject;
6849
6850static void
6851heapctypewithdict_dealloc(HeapCTypeWithDictObject* self)
6852{
6853
6854 PyTypeObject *tp = Py_TYPE(self);
6855 Py_XDECREF(self->dict);
6856 PyObject_Free(self);
6857 Py_DECREF(tp);
6858}
6859
6860static PyGetSetDef heapctypewithdict_getsetlist[] = {
6861 {"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict},
6862 {NULL} /* Sentinel */
6863};
6864
6865static struct PyMemberDef heapctypewithdict_members[] = {
6866 {"dictobj", T_OBJECT, offsetof(HeapCTypeWithDictObject, dict)},
6867 {"__dictoffset__", T_PYSSIZET, offsetof(HeapCTypeWithDictObject, dict), READONLY},
6868 {NULL} /* Sentinel */
6869};
6870
6871static PyType_Slot HeapCTypeWithDict_slots[] = {
6872 {Py_tp_members, heapctypewithdict_members},
6873 {Py_tp_getset, heapctypewithdict_getsetlist},
6874 {Py_tp_dealloc, heapctypewithdict_dealloc},
6875 {0, 0},
6876};
6877
6878static PyType_Spec HeapCTypeWithDict_spec = {
6879 "_testcapi.HeapCTypeWithDict",
6880 sizeof(HeapCTypeWithDictObject),
6881 0,
6882 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6883 HeapCTypeWithDict_slots
6884};
6885
6886static struct PyMemberDef heapctypewithnegativedict_members[] = {
6887 {"dictobj", T_OBJECT, offsetof(HeapCTypeWithDictObject, dict)},
6888 {"__dictoffset__", T_PYSSIZET, -(Py_ssize_t)sizeof(void*), READONLY},
6889 {NULL} /* Sentinel */
6890};
6891
6892static PyType_Slot HeapCTypeWithNegativeDict_slots[] = {
6893 {Py_tp_members, heapctypewithnegativedict_members},
6894 {Py_tp_getset, heapctypewithdict_getsetlist},
6895 {Py_tp_dealloc, heapctypewithdict_dealloc},
6896 {0, 0},
6897};
6898
6899static PyType_Spec HeapCTypeWithNegativeDict_spec = {
6900 "_testcapi.HeapCTypeWithNegativeDict",
6901 sizeof(HeapCTypeWithDictObject),
6902 0,
6903 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6904 HeapCTypeWithNegativeDict_slots
6905};
6906
6907typedef struct {
6908 PyObject_HEAD
6909 PyObject *weakreflist;
6910} HeapCTypeWithWeakrefObject;
6911
6912static struct PyMemberDef heapctypewithweakref_members[] = {
6913 {"weakreflist", T_OBJECT, offsetof(HeapCTypeWithWeakrefObject, weakreflist)},
6914 {"__weaklistoffset__", T_PYSSIZET,
6915 offsetof(HeapCTypeWithWeakrefObject, weakreflist), READONLY},
6916 {NULL} /* Sentinel */
6917};
6918
6919static void
6920heapctypewithweakref_dealloc(HeapCTypeWithWeakrefObject* self)
6921{
6922
6923 PyTypeObject *tp = Py_TYPE(self);
6924 if (self->weakreflist != NULL)
6925 PyObject_ClearWeakRefs((PyObject *) self);
6926 Py_XDECREF(self->weakreflist);
6927 PyObject_Free(self);
6928 Py_DECREF(tp);
6929}
6930
6931static PyType_Slot HeapCTypeWithWeakref_slots[] = {
6932 {Py_tp_members, heapctypewithweakref_members},
6933 {Py_tp_dealloc, heapctypewithweakref_dealloc},
6934 {0, 0},
6935};
6936
6937static PyType_Spec HeapCTypeWithWeakref_spec = {
6938 "_testcapi.HeapCTypeWithWeakref",
6939 sizeof(HeapCTypeWithWeakrefObject),
6940 0,
6941 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
6942 HeapCTypeWithWeakref_slots
6943};
6944
6945PyDoc_STRVAR(heapctypesetattr__doc__,
6946"A heap type without GC, but with overridden __setattr__.\n\n"
6947"The 'value' attribute is set to 10 in __init__ and updated via attribute setting.");
6948
6949typedef struct {
6950 PyObject_HEAD
6951 long value;
6952} HeapCTypeSetattrObject;
6953
6954static struct PyMemberDef heapctypesetattr_members[] = {
6955 {"pvalue", T_LONG, offsetof(HeapCTypeSetattrObject, value)},
6956 {NULL} /* Sentinel */
6957};
6958
6959static int
6960heapctypesetattr_init(PyObject *self, PyObject *args, PyObject *kwargs)
6961{
6962 ((HeapCTypeSetattrObject *)self)->value = 10;
6963 return 0;
6964}
6965
6966static void
6967heapctypesetattr_dealloc(HeapCTypeSetattrObject *self)
6968{
6969 PyTypeObject *tp = Py_TYPE(self);
6970 PyObject_Free(self);
6971 Py_DECREF(tp);
6972}
6973
6974static int
6975heapctypesetattr_setattro(HeapCTypeSetattrObject *self, PyObject *attr, PyObject *value)
6976{
6977 PyObject *svalue = PyUnicode_FromString("value");
6978 if (svalue == NULL)
6979 return -1;
6980 int eq = PyObject_RichCompareBool(svalue, attr, Py_EQ);
6981 Py_DECREF(svalue);
6982 if (eq < 0)
6983 return -1;
6984 if (!eq) {
6985 return PyObject_GenericSetAttr((PyObject*) self, attr, value);
6986 }
6987 if (value == NULL) {
6988 self->value = 0;
6989 return 0;
6990 }
6991 PyObject *ivalue = PyNumber_Long(value);
6992 if (ivalue == NULL)
6993 return -1;
6994 long v = PyLong_AsLong(ivalue);
6995 Py_DECREF(ivalue);
6996 if (v == -1 && PyErr_Occurred())
6997 return -1;
6998 self->value = v;
6999 return 0;
7000}
7001
7002static PyType_Slot HeapCTypeSetattr_slots[] = {
7003 {Py_tp_init, heapctypesetattr_init},
7004 {Py_tp_members, heapctypesetattr_members},
7005 {Py_tp_setattro, heapctypesetattr_setattro},
7006 {Py_tp_dealloc, heapctypesetattr_dealloc},
7007 {Py_tp_doc, (char*)heapctypesetattr__doc__},
7008 {0, 0},
7009};
7010
7011static PyType_Spec HeapCTypeSetattr_spec = {
7012 "_testcapi.HeapCTypeSetattr",
7013 sizeof(HeapCTypeSetattrObject),
7014 0,
7015 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
7016 HeapCTypeSetattr_slots
7017};
7018
7019static PyMethodDef meth_instance_methods[] = {
7020 {"meth_varargs", meth_varargs, METH_VARARGS},
7021 {"meth_varargs_keywords", (PyCFunction)(void(*)(void))meth_varargs_keywords, METH_VARARGS|METH_KEYWORDS},
7022 {"meth_o", meth_o, METH_O},
7023 {"meth_noargs", meth_noargs, METH_NOARGS},
7024 {"meth_fastcall", (PyCFunction)(void(*)(void))meth_fastcall, METH_FASTCALL},
7025 {"meth_fastcall_keywords", (PyCFunction)(void(*)(void))meth_fastcall_keywords, METH_FASTCALL|METH_KEYWORDS},
7026 {NULL, NULL} /* sentinel */
7027};
7028
7029
7030static PyTypeObject MethInstance_Type = {
7031 PyVarObject_HEAD_INIT(NULL, 0)
7032 "MethInstance",
7033 sizeof(PyObject),
7034 .tp_new = PyType_GenericNew,
7035 .tp_flags = Py_TPFLAGS_DEFAULT,
7036 .tp_methods = meth_instance_methods,
7037 .tp_doc = (char*)PyDoc_STR(
7038 "Class with normal (instance) methods to test calling conventions"),
7039};
7040
7041static PyMethodDef meth_class_methods[] = {
7042 {"meth_varargs", meth_varargs, METH_VARARGS|METH_CLASS},
7043 {"meth_varargs_keywords", (PyCFunction)(void(*)(void))meth_varargs_keywords, METH_VARARGS|METH_KEYWORDS|METH_CLASS},
7044 {"meth_o", meth_o, METH_O|METH_CLASS},
7045 {"meth_noargs", meth_noargs, METH_NOARGS|METH_CLASS},
7046 {"meth_fastcall", (PyCFunction)(void(*)(void))meth_fastcall, METH_FASTCALL|METH_CLASS},
7047 {"meth_fastcall_keywords", (PyCFunction)(void(*)(void))meth_fastcall_keywords, METH_FASTCALL|METH_KEYWORDS|METH_CLASS},
7048 {NULL, NULL} /* sentinel */
7049};
7050
7051
7052static PyTypeObject MethClass_Type = {
7053 PyVarObject_HEAD_INIT(NULL, 0)
7054 "MethClass",
7055 sizeof(PyObject),
7056 .tp_new = PyType_GenericNew,
7057 .tp_flags = Py_TPFLAGS_DEFAULT,
7058 .tp_methods = meth_class_methods,
7059 .tp_doc = PyDoc_STR(
7060 "Class with class methods to test calling conventions"),
7061};
7062
7063static PyMethodDef meth_static_methods[] = {
7064 {"meth_varargs", meth_varargs, METH_VARARGS|METH_STATIC},
7065 {"meth_varargs_keywords", (PyCFunction)(void(*)(void))meth_varargs_keywords, METH_VARARGS|METH_KEYWORDS|METH_STATIC},
7066 {"meth_o", meth_o, METH_O|METH_STATIC},
7067 {"meth_noargs", meth_noargs, METH_NOARGS|METH_STATIC},
7068 {"meth_fastcall", (PyCFunction)(void(*)(void))meth_fastcall, METH_FASTCALL|METH_STATIC},
7069 {"meth_fastcall_keywords", (PyCFunction)(void(*)(void))meth_fastcall_keywords, METH_FASTCALL|METH_KEYWORDS|METH_STATIC},
7070 {NULL, NULL} /* sentinel */
7071};
7072
7073
7074static PyTypeObject MethStatic_Type = {
7075 PyVarObject_HEAD_INIT(NULL, 0)
7076 "MethStatic",
7077 sizeof(PyObject),
7078 .tp_new = PyType_GenericNew,
7079 .tp_flags = Py_TPFLAGS_DEFAULT,
7080 .tp_methods = meth_static_methods,
7081 .tp_doc = PyDoc_STR(
7082 "Class with static methods to test calling conventions"),
7083};
7084
7085/* ContainerNoGC -- a simple container without GC methods */
7086
7087typedef struct {
7088 PyObject_HEAD
7089 PyObject *value;
7090} ContainerNoGCobject;
7091
7092static PyObject *
7093ContainerNoGC_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
7094{
7095 PyObject *value;
7096 char *names[] = {"value", NULL};
7097 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O", names, &value)) {
7098 return NULL;
7099 }
7100 PyObject *self = type->tp_alloc(type, 0);
7101 if (self == NULL) {
7102 return NULL;
7103 }
7104 Py_INCREF(value);
7105 ((ContainerNoGCobject *)self)->value = value;
7106 return self;
7107}
7108
7109static void
7110ContainerNoGC_dealloc(ContainerNoGCobject *self)
7111{
7112 Py_DECREF(self->value);
7113 Py_TYPE(self)->tp_free((PyObject *)self);
7114}
7115
7116static PyMemberDef ContainerNoGC_members[] = {
7117 {"value", T_OBJECT, offsetof(ContainerNoGCobject, value), READONLY,
7118 PyDoc_STR("a container value for test purposes")},
7119 {0}
7120};
7121
7122static PyTypeObject ContainerNoGC_type = {
7123 PyVarObject_HEAD_INIT(NULL, 0)
7124 "_testcapi.ContainerNoGC",
7125 sizeof(ContainerNoGCobject),
7126 .tp_dealloc = (destructor)ContainerNoGC_dealloc,
7127 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
7128 .tp_members = ContainerNoGC_members,
7129 .tp_new = ContainerNoGC_new,
7130};
7131
7132
7133static struct PyModuleDef _testcapimodule = {
7134 PyModuleDef_HEAD_INIT,
7135 "_testcapi",
7136 NULL,
7137 -1,
7138 TestMethods,
7139 NULL,
7140 NULL,
7141 NULL,
7142 NULL
7143};
7144
7145/* Per PEP 489, this module will not be converted to multi-phase initialization
7146 */
7147
7148PyMODINIT_FUNC
7149PyInit__testcapi(void)
7150{
7151 PyObject *m;
7152
7153 m = PyModule_Create(&_testcapimodule);
7154 if (m == NULL)
7155 return NULL;
7156
7157 Py_SET_TYPE(&_HashInheritanceTester_Type, &PyType_Type);
7158
7159 Py_SET_TYPE(&test_structmembersType, &PyType_Type);
7160 Py_INCREF(&test_structmembersType);
7161 /* don't use a name starting with "test", since we don't want
7162 test_capi to automatically call this */
7163 PyModule_AddObject(m, "_test_structmembersType", (PyObject *)&test_structmembersType);
7164 if (PyType_Ready(&matmulType) < 0)
7165 return NULL;
7166 Py_INCREF(&matmulType);
7167 PyModule_AddObject(m, "matmulType", (PyObject *)&matmulType);
7168 if (PyType_Ready(&ipowType) < 0) {
7169 return NULL;
7170 }
7171 Py_INCREF(&ipowType);
7172 PyModule_AddObject(m, "ipowType", (PyObject *)&ipowType);
7173
7174 if (PyType_Ready(&awaitType) < 0)
7175 return NULL;
7176 Py_INCREF(&awaitType);
7177 PyModule_AddObject(m, "awaitType", (PyObject *)&awaitType);
7178
7179 MyList_Type.tp_base = &PyList_Type;
7180 if (PyType_Ready(&MyList_Type) < 0)
7181 return NULL;
7182 Py_INCREF(&MyList_Type);
7183 PyModule_AddObject(m, "MyList", (PyObject *)&MyList_Type);
7184
7185 if (PyType_Ready(&MethodDescriptorBase_Type) < 0)
7186 return NULL;
7187 Py_INCREF(&MethodDescriptorBase_Type);
7188 PyModule_AddObject(m, "MethodDescriptorBase", (PyObject *)&MethodDescriptorBase_Type);
7189
7190 MethodDescriptorDerived_Type.tp_base = &MethodDescriptorBase_Type;
7191 if (PyType_Ready(&MethodDescriptorDerived_Type) < 0)
7192 return NULL;
7193 Py_INCREF(&MethodDescriptorDerived_Type);
7194 PyModule_AddObject(m, "MethodDescriptorDerived", (PyObject *)&MethodDescriptorDerived_Type);
7195
7196 MethodDescriptorNopGet_Type.tp_base = &MethodDescriptorBase_Type;
7197 if (PyType_Ready(&MethodDescriptorNopGet_Type) < 0)
7198 return NULL;
7199 Py_INCREF(&MethodDescriptorNopGet_Type);
7200 PyModule_AddObject(m, "MethodDescriptorNopGet", (PyObject *)&MethodDescriptorNopGet_Type);
7201
7202 MethodDescriptor2_Type.tp_base = &MethodDescriptorBase_Type;
7203 if (PyType_Ready(&MethodDescriptor2_Type) < 0)
7204 return NULL;
7205 Py_INCREF(&MethodDescriptor2_Type);
7206 PyModule_AddObject(m, "MethodDescriptor2", (PyObject *)&MethodDescriptor2_Type);
7207
7208 if (PyType_Ready(&GenericAlias_Type) < 0)
7209 return NULL;
7210 Py_INCREF(&GenericAlias_Type);
7211 PyModule_AddObject(m, "GenericAlias", (PyObject *)&GenericAlias_Type);
7212
7213 if (PyType_Ready(&Generic_Type) < 0)
7214 return NULL;
7215 Py_INCREF(&Generic_Type);
7216 PyModule_AddObject(m, "Generic", (PyObject *)&Generic_Type);
7217
7218 if (PyType_Ready(&MethInstance_Type) < 0)
7219 return NULL;
7220 Py_INCREF(&MethInstance_Type);
7221 PyModule_AddObject(m, "MethInstance", (PyObject *)&MethInstance_Type);
7222
7223 if (PyType_Ready(&MethClass_Type) < 0)
7224 return NULL;
7225 Py_INCREF(&MethClass_Type);
7226 PyModule_AddObject(m, "MethClass", (PyObject *)&MethClass_Type);
7227
7228 if (PyType_Ready(&MethStatic_Type) < 0)
7229 return NULL;
7230 Py_INCREF(&MethStatic_Type);
7231 PyModule_AddObject(m, "MethStatic", (PyObject *)&MethStatic_Type);
7232
7233 PyRecursingInfinitelyError_Type.tp_base = (PyTypeObject *)PyExc_Exception;
7234 if (PyType_Ready(&PyRecursingInfinitelyError_Type) < 0) {
7235 return NULL;
7236 }
7237 Py_INCREF(&PyRecursingInfinitelyError_Type);
7238 PyModule_AddObject(m, "RecursingInfinitelyError",
7239 (PyObject *)&PyRecursingInfinitelyError_Type);
7240
7241 PyModule_AddObject(m, "CHAR_MAX", PyLong_FromLong(CHAR_MAX));
7242 PyModule_AddObject(m, "CHAR_MIN", PyLong_FromLong(CHAR_MIN));
7243 PyModule_AddObject(m, "UCHAR_MAX", PyLong_FromLong(UCHAR_MAX));
7244 PyModule_AddObject(m, "SHRT_MAX", PyLong_FromLong(SHRT_MAX));
7245 PyModule_AddObject(m, "SHRT_MIN", PyLong_FromLong(SHRT_MIN));
7246 PyModule_AddObject(m, "USHRT_MAX", PyLong_FromLong(USHRT_MAX));
7247 PyModule_AddObject(m, "INT_MAX", PyLong_FromLong(INT_MAX));
7248 PyModule_AddObject(m, "INT_MIN", PyLong_FromLong(INT_MIN));
7249 PyModule_AddObject(m, "UINT_MAX", PyLong_FromUnsignedLong(UINT_MAX));
7250 PyModule_AddObject(m, "LONG_MAX", PyLong_FromLong(LONG_MAX));
7251 PyModule_AddObject(m, "LONG_MIN", PyLong_FromLong(LONG_MIN));
7252 PyModule_AddObject(m, "ULONG_MAX", PyLong_FromUnsignedLong(ULONG_MAX));
7253 PyModule_AddObject(m, "FLT_MAX", PyFloat_FromDouble(FLT_MAX));
7254 PyModule_AddObject(m, "FLT_MIN", PyFloat_FromDouble(FLT_MIN));
7255 PyModule_AddObject(m, "DBL_MAX", PyFloat_FromDouble(DBL_MAX));
7256 PyModule_AddObject(m, "DBL_MIN", PyFloat_FromDouble(DBL_MIN));
7257 PyModule_AddObject(m, "LLONG_MAX", PyLong_FromLongLong(LLONG_MAX));
7258 PyModule_AddObject(m, "LLONG_MIN", PyLong_FromLongLong(LLONG_MIN));
7259 PyModule_AddObject(m, "ULLONG_MAX", PyLong_FromUnsignedLongLong(ULLONG_MAX));
7260 PyModule_AddObject(m, "PY_SSIZE_T_MAX", PyLong_FromSsize_t(PY_SSIZE_T_MAX));
7261 PyModule_AddObject(m, "PY_SSIZE_T_MIN", PyLong_FromSsize_t(PY_SSIZE_T_MIN));
7262 PyModule_AddObject(m, "SIZEOF_TIME_T", PyLong_FromSsize_t(sizeof(time_t)));
7263 Py_INCREF(&PyInstanceMethod_Type);
7264 PyModule_AddObject(m, "instancemethod", (PyObject *)&PyInstanceMethod_Type);
7265
7266 PyModule_AddIntConstant(m, "the_number_three", 3);
7267 PyObject *v;
7268#ifdef WITH_PYMALLOC
7269 v = Py_True;
7270#else
7271 v = Py_False;
7272#endif
7273 Py_INCREF(v);
7274 PyModule_AddObject(m, "WITH_PYMALLOC", v);
7275
7276 TestError = PyErr_NewException("_testcapi.error", NULL, NULL);
7277 Py_INCREF(TestError);
7278 PyModule_AddObject(m, "error", TestError);
7279
7280 PyObject *HeapDocCType = PyType_FromSpec(&HeapDocCType_spec);
7281 if (HeapDocCType == NULL) {
7282 return NULL;
7283 }
7284 PyModule_AddObject(m, "HeapDocCType", HeapDocCType);
7285
7286 /* bpo-41832: Add a new type to test PyType_FromSpec()
7287 now can accept a NULL tp_doc slot. */
7288 PyObject *NullTpDocType = PyType_FromSpec(&NullTpDocType_spec);
7289 if (NullTpDocType == NULL) {
7290 return NULL;
7291 }
7292 PyModule_AddObject(m, "NullTpDocType", NullTpDocType);
7293
7294 PyObject *HeapGcCType = PyType_FromSpec(&HeapGcCType_spec);
7295 if (HeapGcCType == NULL) {
7296 return NULL;
7297 }
7298 PyModule_AddObject(m, "HeapGcCType", HeapGcCType);
7299
7300 PyObject *HeapCType = PyType_FromSpec(&HeapCType_spec);
7301 if (HeapCType == NULL) {
7302 return NULL;
7303 }
7304 PyObject *subclass_bases = PyTuple_Pack(1, HeapCType);
7305 if (subclass_bases == NULL) {
7306 return NULL;
7307 }
7308 PyObject *HeapCTypeSubclass = PyType_FromSpecWithBases(&HeapCTypeSubclass_spec, subclass_bases);
7309 if (HeapCTypeSubclass == NULL) {
7310 return NULL;
7311 }
7312 Py_DECREF(subclass_bases);
7313 PyModule_AddObject(m, "HeapCTypeSubclass", HeapCTypeSubclass);
7314
7315 PyObject *HeapCTypeWithDict = PyType_FromSpec(&HeapCTypeWithDict_spec);
7316 if (HeapCTypeWithDict == NULL) {
7317 return NULL;
7318 }
7319 PyModule_AddObject(m, "HeapCTypeWithDict", HeapCTypeWithDict);
7320
7321 PyObject *HeapCTypeWithNegativeDict = PyType_FromSpec(&HeapCTypeWithNegativeDict_spec);
7322 if (HeapCTypeWithNegativeDict == NULL) {
7323 return NULL;
7324 }
7325 PyModule_AddObject(m, "HeapCTypeWithNegativeDict", HeapCTypeWithNegativeDict);
7326
7327 PyObject *HeapCTypeWithWeakref = PyType_FromSpec(&HeapCTypeWithWeakref_spec);
7328 if (HeapCTypeWithWeakref == NULL) {
7329 return NULL;
7330 }
7331 PyModule_AddObject(m, "HeapCTypeWithWeakref", HeapCTypeWithWeakref);
7332
7333 PyObject *HeapCTypeWithBuffer = PyType_FromSpec(&HeapCTypeWithBuffer_spec);
7334 if (HeapCTypeWithBuffer == NULL) {
7335 return NULL;
7336 }
7337 PyModule_AddObject(m, "HeapCTypeWithBuffer", HeapCTypeWithBuffer);
7338
7339 PyObject *HeapCTypeSetattr = PyType_FromSpec(&HeapCTypeSetattr_spec);
7340 if (HeapCTypeSetattr == NULL) {
7341 return NULL;
7342 }
7343 PyModule_AddObject(m, "HeapCTypeSetattr", HeapCTypeSetattr);
7344
7345 PyObject *subclass_with_finalizer_bases = PyTuple_Pack(1, HeapCTypeSubclass);
7346 if (subclass_with_finalizer_bases == NULL) {
7347 return NULL;
7348 }
7349 PyObject *HeapCTypeSubclassWithFinalizer = PyType_FromSpecWithBases(
7350 &HeapCTypeSubclassWithFinalizer_spec, subclass_with_finalizer_bases);
7351 if (HeapCTypeSubclassWithFinalizer == NULL) {
7352 return NULL;
7353 }
7354 Py_DECREF(subclass_with_finalizer_bases);
7355 PyModule_AddObject(m, "HeapCTypeSubclassWithFinalizer", HeapCTypeSubclassWithFinalizer);
7356
7357 if (PyType_Ready(&ContainerNoGC_type) < 0) {
7358 return NULL;
7359 }
7360 Py_INCREF(&ContainerNoGC_type);
7361 if (PyModule_AddObject(m, "ContainerNoGC",
7362 (PyObject *) &ContainerNoGC_type) < 0)
7363 return NULL;
7364
7365 PyState_AddModule(m, &_testcapimodule);
7366 return m;
7367}
7368
7369
7370/* Test the C API exposed when PY_SSIZE_T_CLEAN is not defined */
7371
7372#undef Py_BuildValue
7373PyAPI_FUNC(PyObject *) Py_BuildValue(const char *, ...);
7374
7375static PyObject *
7376test_buildvalue_issue38913(PyObject *self, PyObject *Py_UNUSED(ignored))
7377{
7378 PyObject *res;
7379 const char str[] = "string";
7380 const Py_UNICODE unicode[] = L"unicode";
7381 assert(!PyErr_Occurred());
7382
7383 res = Py_BuildValue("(s#O)", str, 1, Py_None);
7384 assert(res == NULL);
7385 if (!PyErr_ExceptionMatches(PyExc_SystemError)) {
7386 return NULL;
7387 }
7388 PyErr_Clear();
7389
7390 res = Py_BuildValue("(z#O)", str, 1, Py_None);
7391 assert(res == NULL);
7392 if (!PyErr_ExceptionMatches(PyExc_SystemError)) {
7393 return NULL;
7394 }
7395 PyErr_Clear();
7396
7397 res = Py_BuildValue("(y#O)", str, 1, Py_None);
7398 assert(res == NULL);
7399 if (!PyErr_ExceptionMatches(PyExc_SystemError)) {
7400 return NULL;
7401 }
7402 PyErr_Clear();
7403
7404 res = Py_BuildValue("(u#O)", unicode, 1, Py_None);
7405 assert(res == NULL);
7406 if (!PyErr_ExceptionMatches(PyExc_SystemError)) {
7407 return NULL;
7408 }
7409 PyErr_Clear();
7410
7411
7412 Py_RETURN_NONE;
7413}
7414
7415#undef PyArg_ParseTupleAndKeywords
7416PyAPI_FUNC(int) PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,
7417 const char *, char **, ...);
7418
7419static PyObject *
7420getargs_s_hash_int(PyObject *self, PyObject *args, PyObject *kwargs)
7421{
7422 static char *keywords[] = {"", "x", NULL};
7423 const char *s;
7424 int len;
7425 int i = 0;
7426 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s#i", keywords, &s, &len, &i))
7427 return NULL;
7428 Py_RETURN_NONE;
7429}
7430