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