LCOV - code coverage report
Current view: top level - Modules - _testcapimodule.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit acb105a7c1f] Lines: 2364 3069 77.0 %
Date: 2022-07-20 13:12:14 Functions: 271 294 92.2 %
Branches: 902 1635 55.2 %

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

Generated by: LCOV version 1.14