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