LCOV - code coverage report
Current view: top level - Modules/_testcapi - unicode.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 4 597 0.7 %
Date: 2023-03-20 08:15:36 Functions: 1 35 2.9 %
Branches: 1 1380 0.1 %

           Branch data     Line data    Source code
       1                 :            : #define PY_SSIZE_T_CLEAN
       2                 :            : #include "parts.h"
       3                 :            : 
       4                 :            : static struct PyModuleDef *_testcapimodule = NULL;  // set at initialization
       5                 :            : 
       6                 :            : static PyObject *
       7                 :          0 : codec_incrementalencoder(PyObject *self, PyObject *args)
       8                 :            : {
       9                 :          0 :     const char *encoding, *errors = NULL;
      10         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "s|s:test_incrementalencoder",
      11                 :            :                           &encoding, &errors))
      12                 :          0 :         return NULL;
      13                 :          0 :     return PyCodec_IncrementalEncoder(encoding, errors);
      14                 :            : }
      15                 :            : 
      16                 :            : static PyObject *
      17                 :          0 : codec_incrementaldecoder(PyObject *self, PyObject *args)
      18                 :            : {
      19                 :          0 :     const char *encoding, *errors = NULL;
      20         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "s|s:test_incrementaldecoder",
      21                 :            :                           &encoding, &errors))
      22                 :          0 :         return NULL;
      23                 :          0 :     return PyCodec_IncrementalDecoder(encoding, errors);
      24                 :            : }
      25                 :            : 
      26                 :            : static PyObject *
      27                 :          0 : test_unicode_compare_with_ascii(PyObject *self, PyObject *Py_UNUSED(ignored)) {
      28                 :          0 :     PyObject *py_s = PyUnicode_FromStringAndSize("str\0", 4);
      29                 :            :     int result;
      30         [ #  # ]:          0 :     if (py_s == NULL)
      31                 :          0 :         return NULL;
      32                 :          0 :     result = PyUnicode_CompareWithASCIIString(py_s, "str");
      33                 :          0 :     Py_DECREF(py_s);
      34         [ #  # ]:          0 :     if (!result) {
      35                 :          0 :         PyErr_SetString(PyExc_AssertionError, "Python string ending in NULL "
      36                 :            :                         "should not compare equal to c string.");
      37                 :          0 :         return NULL;
      38                 :            :     }
      39                 :          0 :     Py_RETURN_NONE;
      40                 :            : }
      41                 :            : 
      42                 :            : static PyObject *
      43                 :          0 : test_widechar(PyObject *self, PyObject *Py_UNUSED(ignored))
      44                 :            : {
      45                 :            : #if defined(SIZEOF_WCHAR_T) && (SIZEOF_WCHAR_T == 4)
      46                 :          0 :     const wchar_t wtext[2] = {(wchar_t)0x10ABCDu};
      47                 :          0 :     size_t wtextlen = 1;
      48                 :          0 :     const wchar_t invalid[1] = {(wchar_t)0x110000u};
      49                 :            : #else
      50                 :            :     const wchar_t wtext[3] = {(wchar_t)0xDBEAu, (wchar_t)0xDFCDu};
      51                 :            :     size_t wtextlen = 2;
      52                 :            : #endif
      53                 :            :     PyObject *wide, *utf8;
      54                 :            : 
      55                 :          0 :     wide = PyUnicode_FromWideChar(wtext, wtextlen);
      56         [ #  # ]:          0 :     if (wide == NULL)
      57                 :          0 :         return NULL;
      58                 :            : 
      59                 :          0 :     utf8 = PyUnicode_FromString("\xf4\x8a\xaf\x8d");
      60         [ #  # ]:          0 :     if (utf8 == NULL) {
      61                 :          0 :         Py_DECREF(wide);
      62                 :          0 :         return NULL;
      63                 :            :     }
      64                 :            : 
      65         [ #  # ]:          0 :     if (PyUnicode_GET_LENGTH(wide) != PyUnicode_GET_LENGTH(utf8)) {
      66                 :          0 :         Py_DECREF(wide);
      67                 :          0 :         Py_DECREF(utf8);
      68                 :          0 :         PyErr_SetString(PyExc_AssertionError,
      69                 :            :                         "test_widechar: "
      70                 :            :                         "wide string and utf8 string "
      71                 :            :                         "have different length");
      72                 :          0 :         return NULL;
      73                 :            :     }
      74         [ #  # ]:          0 :     if (PyUnicode_Compare(wide, utf8)) {
      75                 :          0 :         Py_DECREF(wide);
      76                 :          0 :         Py_DECREF(utf8);
      77         [ #  # ]:          0 :         if (PyErr_Occurred())
      78                 :          0 :             return NULL;
      79                 :          0 :         PyErr_SetString(PyExc_AssertionError,
      80                 :            :                         "test_widechar: "
      81                 :            :                         "wide string and utf8 string "
      82                 :            :                         "are different");
      83                 :          0 :         return NULL;
      84                 :            :     }
      85                 :            : 
      86                 :          0 :     Py_DECREF(wide);
      87                 :          0 :     Py_DECREF(utf8);
      88                 :            : 
      89                 :            : #if defined(SIZEOF_WCHAR_T) && (SIZEOF_WCHAR_T == 4)
      90                 :          0 :     wide = PyUnicode_FromWideChar(invalid, 1);
      91         [ #  # ]:          0 :     if (wide == NULL)
      92                 :          0 :         PyErr_Clear();
      93                 :            :     else {
      94                 :          0 :         PyErr_SetString(PyExc_AssertionError,
      95                 :            :                         "test_widechar: "
      96                 :            :                         "PyUnicode_FromWideChar(L\"\\U00110000\", 1) didn't fail");
      97                 :          0 :         return NULL;
      98                 :            :     }
      99                 :            : #endif
     100                 :          0 :     Py_RETURN_NONE;
     101                 :            : }
     102                 :            : 
     103                 :            : #define NULLABLE(x) do { if (x == Py_None) x = NULL; } while (0);
     104                 :            : 
     105                 :            : /* Test PyUnicode_FromObject() */
     106                 :            : static PyObject *
     107                 :          0 : unicode_fromobject(PyObject *self, PyObject *arg)
     108                 :            : {
     109         [ #  # ]:          0 :     NULLABLE(arg);
     110                 :          0 :     return PyUnicode_FromObject(arg);
     111                 :            : }
     112                 :            : 
     113                 :            : /* Test PyUnicode_AsWideChar() */
     114                 :            : static PyObject *
     115                 :          0 : unicode_aswidechar(PyObject *self, PyObject *args)
     116                 :            : {
     117                 :            :     PyObject *unicode, *result;
     118                 :            :     Py_ssize_t buflen, size;
     119                 :            :     wchar_t *buffer;
     120                 :            : 
     121         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "Un", &unicode, &buflen))
     122                 :          0 :         return NULL;
     123         [ #  # ]:          0 :     buffer = PyMem_New(wchar_t, buflen);
     124         [ #  # ]:          0 :     if (buffer == NULL)
     125                 :          0 :         return PyErr_NoMemory();
     126                 :            : 
     127                 :          0 :     size = PyUnicode_AsWideChar(unicode, buffer, buflen);
     128         [ #  # ]:          0 :     if (size == -1) {
     129                 :          0 :         PyMem_Free(buffer);
     130                 :          0 :         return NULL;
     131                 :            :     }
     132                 :            : 
     133         [ #  # ]:          0 :     if (size < buflen)
     134                 :          0 :         buflen = size + 1;
     135                 :            :     else
     136                 :          0 :         buflen = size;
     137                 :          0 :     result = PyUnicode_FromWideChar(buffer, buflen);
     138                 :          0 :     PyMem_Free(buffer);
     139         [ #  # ]:          0 :     if (result == NULL)
     140                 :          0 :         return NULL;
     141                 :            : 
     142                 :          0 :     return Py_BuildValue("(Nn)", result, size);
     143                 :            : }
     144                 :            : 
     145                 :            : /* Test PyUnicode_AsWideCharString() */
     146                 :            : static PyObject *
     147                 :          0 : unicode_aswidecharstring(PyObject *self, PyObject *args)
     148                 :            : {
     149                 :            :     PyObject *unicode, *result;
     150                 :            :     Py_ssize_t size;
     151                 :            :     wchar_t *buffer;
     152                 :            : 
     153         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "U", &unicode))
     154                 :          0 :         return NULL;
     155                 :            : 
     156                 :          0 :     buffer = PyUnicode_AsWideCharString(unicode, &size);
     157         [ #  # ]:          0 :     if (buffer == NULL)
     158                 :          0 :         return NULL;
     159                 :            : 
     160                 :          0 :     result = PyUnicode_FromWideChar(buffer, size + 1);
     161                 :          0 :     PyMem_Free(buffer);
     162         [ #  # ]:          0 :     if (result == NULL)
     163                 :          0 :         return NULL;
     164                 :          0 :     return Py_BuildValue("(Nn)", result, size);
     165                 :            : }
     166                 :            : 
     167                 :            : /* Test PyUnicode_AsUCS4() */
     168                 :            : static PyObject *
     169                 :          0 : unicode_asucs4(PyObject *self, PyObject *args)
     170                 :            : {
     171                 :            :     PyObject *unicode, *result;
     172                 :            :     Py_UCS4 *buffer;
     173                 :            :     int copy_null;
     174                 :            :     Py_ssize_t str_len, buf_len;
     175                 :            : 
     176         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "Unp:unicode_asucs4", &unicode, &str_len, &copy_null)) {
     177                 :          0 :         return NULL;
     178                 :            :     }
     179                 :            : 
     180                 :          0 :     buf_len = str_len + 1;
     181         [ #  # ]:          0 :     buffer = PyMem_NEW(Py_UCS4, buf_len);
     182         [ #  # ]:          0 :     if (buffer == NULL) {
     183                 :          0 :         return PyErr_NoMemory();
     184                 :            :     }
     185                 :          0 :     memset(buffer, 0, sizeof(Py_UCS4)*buf_len);
     186                 :          0 :     buffer[str_len] = 0xffffU;
     187                 :            : 
     188         [ #  # ]:          0 :     if (!PyUnicode_AsUCS4(unicode, buffer, buf_len, copy_null)) {
     189                 :          0 :         PyMem_Free(buffer);
     190                 :          0 :         return NULL;
     191                 :            :     }
     192                 :            : 
     193                 :          0 :     result = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, buffer, buf_len);
     194                 :          0 :     PyMem_Free(buffer);
     195                 :          0 :     return result;
     196                 :            : }
     197                 :            : 
     198                 :            : /* Test PyUnicode_AsUTF8() */
     199                 :            : static PyObject *
     200                 :          0 : unicode_asutf8(PyObject *self, PyObject *args)
     201                 :            : {
     202                 :            :     PyObject *unicode;
     203                 :            :     const char *buffer;
     204                 :            : 
     205         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "U", &unicode)) {
     206                 :          0 :         return NULL;
     207                 :            :     }
     208                 :            : 
     209                 :          0 :     buffer = PyUnicode_AsUTF8(unicode);
     210         [ #  # ]:          0 :     if (buffer == NULL) {
     211                 :          0 :         return NULL;
     212                 :            :     }
     213                 :            : 
     214                 :          0 :     return PyBytes_FromString(buffer);
     215                 :            : }
     216                 :            : 
     217                 :            : /* Test PyUnicode_AsUTF8AndSize() */
     218                 :            : static PyObject *
     219                 :          0 : unicode_asutf8andsize(PyObject *self, PyObject *args)
     220                 :            : {
     221                 :            :     PyObject *unicode, *result;
     222                 :            :     const char *buffer;
     223                 :            :     Py_ssize_t utf8_len;
     224                 :            : 
     225         [ #  # ]:          0 :     if(!PyArg_ParseTuple(args, "U", &unicode)) {
     226                 :          0 :         return NULL;
     227                 :            :     }
     228                 :            : 
     229                 :          0 :     buffer = PyUnicode_AsUTF8AndSize(unicode, &utf8_len);
     230         [ #  # ]:          0 :     if (buffer == NULL) {
     231                 :          0 :         return NULL;
     232                 :            :     }
     233                 :            : 
     234                 :          0 :     result = PyBytes_FromString(buffer);
     235         [ #  # ]:          0 :     if (result == NULL) {
     236                 :          0 :         return NULL;
     237                 :            :     }
     238                 :            : 
     239                 :          0 :     return Py_BuildValue("(Nn)", result, utf8_len);
     240                 :            : }
     241                 :            : 
     242                 :            : /* Test PyUnicode_DecodeUTF8() */
     243                 :            : static PyObject *
     244                 :          0 : unicode_decodeutf8(PyObject *self, PyObject *args)
     245                 :            : {
     246                 :            :     const char *data;
     247                 :            :     Py_ssize_t size;
     248                 :          0 :     const char *errors = NULL;
     249                 :            : 
     250         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))
     251                 :          0 :         return NULL;
     252                 :            : 
     253                 :          0 :     return PyUnicode_DecodeUTF8(data, size, errors);
     254                 :            : }
     255                 :            : 
     256                 :            : /* Test PyUnicode_DecodeUTF8Stateful() */
     257                 :            : static PyObject *
     258                 :          0 : unicode_decodeutf8stateful(PyObject *self, PyObject *args)
     259                 :            : {
     260                 :            :     const char *data;
     261                 :            :     Py_ssize_t size;
     262                 :          0 :     const char *errors = NULL;
     263                 :          0 :     Py_ssize_t consumed = 123456789;
     264                 :            :     PyObject *result;
     265                 :            : 
     266         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "y#|z", &data, &size, &errors))
     267                 :          0 :         return NULL;
     268                 :            : 
     269                 :          0 :     result = PyUnicode_DecodeUTF8Stateful(data, size, errors, &consumed);
     270         [ #  # ]:          0 :     if (!result) {
     271                 :          0 :         return NULL;
     272                 :            :     }
     273                 :          0 :     return Py_BuildValue("(Nn)", result, consumed);
     274                 :            : }
     275                 :            : 
     276                 :            : /* Test PyUnicode_Concat() */
     277                 :            : static PyObject *
     278                 :          0 : unicode_concat(PyObject *self, PyObject *args)
     279                 :            : {
     280                 :            :     PyObject *left;
     281                 :            :     PyObject *right;
     282                 :            : 
     283         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OO", &left, &right))
     284                 :          0 :         return NULL;
     285                 :            : 
     286         [ #  # ]:          0 :     NULLABLE(left);
     287         [ #  # ]:          0 :     NULLABLE(right);
     288                 :          0 :     return PyUnicode_Concat(left, right);
     289                 :            : }
     290                 :            : 
     291                 :            : /* Test PyUnicode_Split() */
     292                 :            : static PyObject *
     293                 :          0 : unicode_split(PyObject *self, PyObject *args)
     294                 :            : {
     295                 :            :     PyObject *s;
     296                 :            :     PyObject *sep;
     297                 :          0 :     Py_ssize_t maxsplit = -1;
     298                 :            : 
     299         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OO|n", &s, &sep, &maxsplit))
     300                 :          0 :         return NULL;
     301                 :            : 
     302         [ #  # ]:          0 :     NULLABLE(s);
     303         [ #  # ]:          0 :     NULLABLE(sep);
     304                 :          0 :     return PyUnicode_Split(s, sep, maxsplit);
     305                 :            : }
     306                 :            : 
     307                 :            : /* Test PyUnicode_RSplit() */
     308                 :            : static PyObject *
     309                 :          0 : unicode_rsplit(PyObject *self, PyObject *args)
     310                 :            : {
     311                 :            :     PyObject *s;
     312                 :            :     PyObject *sep;
     313                 :          0 :     Py_ssize_t maxsplit = -1;
     314                 :            : 
     315         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OO|n", &s, &sep, &maxsplit))
     316                 :          0 :         return NULL;
     317                 :            : 
     318         [ #  # ]:          0 :     NULLABLE(s);
     319         [ #  # ]:          0 :     NULLABLE(sep);
     320                 :          0 :     return PyUnicode_RSplit(s, sep, maxsplit);
     321                 :            : }
     322                 :            : 
     323                 :            : /* Test PyUnicode_Splitlines() */
     324                 :            : static PyObject *
     325                 :          0 : unicode_splitlines(PyObject *self, PyObject *args)
     326                 :            : {
     327                 :            :     PyObject *s;
     328                 :          0 :     int keepends = 0;
     329                 :            : 
     330         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "O|i", &s, &keepends))
     331                 :          0 :         return NULL;
     332                 :            : 
     333         [ #  # ]:          0 :     NULLABLE(s);
     334                 :          0 :     return PyUnicode_Splitlines(s, keepends);
     335                 :            : }
     336                 :            : 
     337                 :            : /* Test PyUnicode_Partition() */
     338                 :            : static PyObject *
     339                 :          0 : unicode_partition(PyObject *self, PyObject *args)
     340                 :            : {
     341                 :            :     PyObject *s;
     342                 :            :     PyObject *sep;
     343                 :            : 
     344         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OO", &s, &sep))
     345                 :          0 :         return NULL;
     346                 :            : 
     347         [ #  # ]:          0 :     NULLABLE(s);
     348         [ #  # ]:          0 :     NULLABLE(sep);
     349                 :          0 :     return PyUnicode_Partition(s, sep);
     350                 :            : }
     351                 :            : 
     352                 :            : /* Test PyUnicode_RPartition() */
     353                 :            : static PyObject *
     354                 :          0 : unicode_rpartition(PyObject *self, PyObject *args)
     355                 :            : {
     356                 :            :     PyObject *s;
     357                 :            :     PyObject *sep;
     358                 :            : 
     359         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OO", &s, &sep))
     360                 :          0 :         return NULL;
     361                 :            : 
     362         [ #  # ]:          0 :     NULLABLE(s);
     363         [ #  # ]:          0 :     NULLABLE(sep);
     364                 :          0 :     return PyUnicode_RPartition(s, sep);
     365                 :            : }
     366                 :            : 
     367                 :            : /* Test PyUnicode_Translate() */
     368                 :            : static PyObject *
     369                 :          0 : unicode_translate(PyObject *self, PyObject *args)
     370                 :            : {
     371                 :            :     PyObject *obj;
     372                 :            :     PyObject *table;
     373                 :          0 :     const char *errors = NULL;
     374                 :            : 
     375         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OO|z", &obj, &table, &errors))
     376                 :          0 :         return NULL;
     377                 :            : 
     378         [ #  # ]:          0 :     NULLABLE(obj);
     379         [ #  # ]:          0 :     NULLABLE(table);
     380                 :          0 :     return PyUnicode_Translate(obj, table, errors);
     381                 :            : }
     382                 :            : 
     383                 :            : /* Test PyUnicode_Join() */
     384                 :            : static PyObject *
     385                 :          0 : unicode_join(PyObject *self, PyObject *args)
     386                 :            : {
     387                 :            :     PyObject *sep;
     388                 :            :     PyObject *seq;
     389                 :            : 
     390         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OO", &sep, &seq))
     391                 :          0 :         return NULL;
     392                 :            : 
     393         [ #  # ]:          0 :     NULLABLE(sep);
     394         [ #  # ]:          0 :     NULLABLE(seq);
     395                 :          0 :     return PyUnicode_Join(sep, seq);
     396                 :            : }
     397                 :            : 
     398                 :            : /* Test PyUnicode_Count() */
     399                 :            : static PyObject *
     400                 :          0 : unicode_count(PyObject *self, PyObject *args)
     401                 :            : {
     402                 :            :     PyObject *str;
     403                 :            :     PyObject *substr;
     404                 :            :     Py_ssize_t start;
     405                 :            :     Py_ssize_t end;
     406                 :            :     Py_ssize_t result;
     407                 :            : 
     408         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OOnn", &str, &substr, &start, &end))
     409                 :          0 :         return NULL;
     410                 :            : 
     411         [ #  # ]:          0 :     NULLABLE(str);
     412         [ #  # ]:          0 :     NULLABLE(substr);
     413                 :          0 :     result = PyUnicode_Count(str, substr, start, end);
     414         [ #  # ]:          0 :     if (result == -1)
     415                 :          0 :         return NULL;
     416                 :          0 :     return PyLong_FromSsize_t(result);
     417                 :            : }
     418                 :            : 
     419                 :            : /* Test PyUnicode_Find() */
     420                 :            : static PyObject *
     421                 :          0 : unicode_find(PyObject *self, PyObject *args)
     422                 :            : {
     423                 :            :     PyObject *str;
     424                 :            :     PyObject *substr;
     425                 :            :     Py_ssize_t start;
     426                 :            :     Py_ssize_t end;
     427                 :            :     int direction;
     428                 :            :     Py_ssize_t result;
     429                 :            : 
     430         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OOnni", &str, &substr, &start, &end, &direction))
     431                 :          0 :         return NULL;
     432                 :            : 
     433         [ #  # ]:          0 :     NULLABLE(str);
     434         [ #  # ]:          0 :     NULLABLE(substr);
     435                 :          0 :     result = PyUnicode_Find(str, substr, start, end, direction);
     436         [ #  # ]:          0 :     if (result == -2)
     437                 :          0 :         return NULL;
     438                 :          0 :     return PyLong_FromSsize_t(result);
     439                 :            : }
     440                 :            : 
     441                 :            : /* Test PyUnicode_Tailmatch() */
     442                 :            : static PyObject *
     443                 :          0 : unicode_tailmatch(PyObject *self, PyObject *args)
     444                 :            : {
     445                 :            :     PyObject *str;
     446                 :            :     PyObject *substr;
     447                 :            :     Py_ssize_t start;
     448                 :            :     Py_ssize_t end;
     449                 :            :     int direction;
     450                 :            :     Py_ssize_t result;
     451                 :            : 
     452         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OOnni", &str, &substr, &start, &end, &direction))
     453                 :          0 :         return NULL;
     454                 :            : 
     455         [ #  # ]:          0 :     NULLABLE(str);
     456         [ #  # ]:          0 :     NULLABLE(substr);
     457                 :          0 :     result = PyUnicode_Tailmatch(str, substr, start, end, direction);
     458         [ #  # ]:          0 :     if (result == -1)
     459                 :          0 :         return NULL;
     460                 :          0 :     return PyLong_FromSsize_t(result);
     461                 :            : }
     462                 :            : 
     463                 :            : /* Test PyUnicode_FindChar() */
     464                 :            : static PyObject *
     465                 :          0 : unicode_findchar(PyObject *self, PyObject *args)
     466                 :            : {
     467                 :            :     PyObject *str;
     468                 :            :     int direction;
     469                 :            :     unsigned int ch;
     470                 :            :     Py_ssize_t result;
     471                 :            :     Py_ssize_t start, end;
     472                 :            : 
     473         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "UInni:unicode_findchar", &str, &ch,
     474                 :            :                           &start, &end, &direction)) {
     475                 :          0 :         return NULL;
     476                 :            :     }
     477                 :            : 
     478                 :          0 :     result = PyUnicode_FindChar(str, (Py_UCS4)ch, start, end, direction);
     479         [ #  # ]:          0 :     if (result == -2)
     480                 :          0 :         return NULL;
     481                 :            :     else
     482                 :          0 :         return PyLong_FromSsize_t(result);
     483                 :            : }
     484                 :            : 
     485                 :            : /* Test PyUnicode_Replace() */
     486                 :            : static PyObject *
     487                 :          0 : unicode_replace(PyObject *self, PyObject *args)
     488                 :            : {
     489                 :            :     PyObject *str;
     490                 :            :     PyObject *substr;
     491                 :            :     PyObject *replstr;
     492                 :          0 :     Py_ssize_t maxcount = -1;
     493                 :            : 
     494         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OOO|n", &str, &substr, &replstr, &maxcount))
     495                 :          0 :         return NULL;
     496                 :            : 
     497         [ #  # ]:          0 :     NULLABLE(str);
     498         [ #  # ]:          0 :     NULLABLE(substr);
     499         [ #  # ]:          0 :     NULLABLE(replstr);
     500                 :          0 :     return PyUnicode_Replace(str, substr, replstr, maxcount);
     501                 :            : }
     502                 :            : 
     503                 :            : /* Test PyUnicode_Compare() */
     504                 :            : static PyObject *
     505                 :          0 : unicode_compare(PyObject *self, PyObject *args)
     506                 :            : {
     507                 :            :     PyObject *left;
     508                 :            :     PyObject *right;
     509                 :            :     int result;
     510                 :            : 
     511         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OO", &left, &right))
     512                 :          0 :         return NULL;
     513                 :            : 
     514         [ #  # ]:          0 :     NULLABLE(left);
     515         [ #  # ]:          0 :     NULLABLE(right);
     516                 :          0 :     result = PyUnicode_Compare(left, right);
     517   [ #  #  #  # ]:          0 :     if (result == -1 && PyErr_Occurred()) {
     518                 :          0 :         return NULL;
     519                 :            :     }
     520                 :          0 :     return PyLong_FromLong(result);
     521                 :            : }
     522                 :            : 
     523                 :            : /* Test PyUnicode_CompareWithASCIIString() */
     524                 :            : static PyObject *
     525                 :          0 : unicode_comparewithasciistring(PyObject *self, PyObject *args)
     526                 :            : {
     527                 :            :     PyObject *left;
     528                 :          0 :     const char *right = NULL;
     529                 :            :     Py_ssize_t right_len;
     530                 :            :     int result;
     531                 :            : 
     532         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "O|y#", &left, &right, &right_len))
     533                 :          0 :         return NULL;
     534                 :            : 
     535         [ #  # ]:          0 :     NULLABLE(left);
     536                 :          0 :     result = PyUnicode_CompareWithASCIIString(left, right);
     537   [ #  #  #  # ]:          0 :     if (result == -1 && PyErr_Occurred()) {
     538                 :          0 :         return NULL;
     539                 :            :     }
     540                 :          0 :     return PyLong_FromLong(result);
     541                 :            : }
     542                 :            : 
     543                 :            : /* Test PyUnicode_RichCompare() */
     544                 :            : static PyObject *
     545                 :          0 : unicode_richcompare(PyObject *self, PyObject *args)
     546                 :            : {
     547                 :            :     PyObject *left;
     548                 :            :     PyObject *right;
     549                 :            :     int op;
     550                 :            : 
     551         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OOi", &left, &right, &op))
     552                 :          0 :         return NULL;
     553                 :            : 
     554         [ #  # ]:          0 :     NULLABLE(left);
     555         [ #  # ]:          0 :     NULLABLE(right);
     556                 :          0 :     return PyUnicode_RichCompare(left, right, op);
     557                 :            : }
     558                 :            : 
     559                 :            : /* Test PyUnicode_Format() */
     560                 :            : static PyObject *
     561                 :          0 : unicode_format(PyObject *self, PyObject *args)
     562                 :            : {
     563                 :            :     PyObject *format;
     564                 :            :     PyObject *fargs;
     565                 :            : 
     566         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OO", &format, &fargs))
     567                 :          0 :         return NULL;
     568                 :            : 
     569         [ #  # ]:          0 :     NULLABLE(format);
     570         [ #  # ]:          0 :     NULLABLE(fargs);
     571                 :          0 :     return PyUnicode_Format(format, fargs);
     572                 :            : }
     573                 :            : 
     574                 :            : /* Test PyUnicode_Contains() */
     575                 :            : static PyObject *
     576                 :          0 : unicode_contains(PyObject *self, PyObject *args)
     577                 :            : {
     578                 :            :     PyObject *container;
     579                 :            :     PyObject *element;
     580                 :            :     int result;
     581                 :            : 
     582         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "OO", &container, &element))
     583                 :          0 :         return NULL;
     584                 :            : 
     585         [ #  # ]:          0 :     NULLABLE(container);
     586         [ #  # ]:          0 :     NULLABLE(element);
     587                 :          0 :     result = PyUnicode_Contains(container, element);
     588   [ #  #  #  # ]:          0 :     if (result == -1 && PyErr_Occurred()) {
     589                 :          0 :         return NULL;
     590                 :            :     }
     591                 :          0 :     return PyLong_FromLong(result);
     592                 :            : }
     593                 :            : 
     594                 :            : /* Test PyUnicode_IsIdentifier() */
     595                 :            : static PyObject *
     596                 :          0 : unicode_isidentifier(PyObject *self, PyObject *arg)
     597                 :            : {
     598                 :            :     int result;
     599                 :            : 
     600         [ #  # ]:          0 :     NULLABLE(arg);
     601                 :          0 :     result = PyUnicode_IsIdentifier(arg);
     602   [ #  #  #  # ]:          0 :     if (result == -1 && PyErr_Occurred()) {
     603                 :          0 :         return NULL;
     604                 :            :     }
     605                 :          0 :     return PyLong_FromLong(result);
     606                 :            : }
     607                 :            : 
     608                 :            : /* Test PyUnicode_CopyCharacters() */
     609                 :            : static PyObject *
     610                 :          0 : unicode_copycharacters(PyObject *self, PyObject *args)
     611                 :            : {
     612                 :            :     PyObject *from, *to, *to_copy;
     613                 :            :     Py_ssize_t from_start, to_start, how_many, copied;
     614                 :            : 
     615         [ #  # ]:          0 :     if (!PyArg_ParseTuple(args, "UnOnn:unicode_copycharacters", &to, &to_start,
     616                 :            :                           &from, &from_start, &how_many)) {
     617                 :          0 :         return NULL;
     618                 :            :     }
     619                 :            : 
     620         [ #  # ]:          0 :     if (!(to_copy = PyUnicode_New(PyUnicode_GET_LENGTH(to),
     621                 :            :                                   PyUnicode_MAX_CHAR_VALUE(to)))) {
     622                 :          0 :         return NULL;
     623                 :            :     }
     624         [ #  # ]:          0 :     if (PyUnicode_Fill(to_copy, 0, PyUnicode_GET_LENGTH(to_copy), 0U) < 0) {
     625                 :          0 :         Py_DECREF(to_copy);
     626                 :          0 :         return NULL;
     627                 :            :     }
     628                 :            : 
     629         [ #  # ]:          0 :     if ((copied = PyUnicode_CopyCharacters(to_copy, to_start, from,
     630                 :            :                                            from_start, how_many)) < 0) {
     631                 :          0 :         Py_DECREF(to_copy);
     632                 :          0 :         return NULL;
     633                 :            :     }
     634                 :            : 
     635                 :          0 :     return Py_BuildValue("(Nn)", to_copy, copied);
     636                 :            : }
     637                 :            : 
     638                 :            : static int
     639                 :          0 : check_raised_systemerror(PyObject *result, char* msg)
     640                 :            : {
     641         [ #  # ]:          0 :     if (result) {
     642                 :            :         // no exception
     643                 :          0 :         PyErr_Format(PyExc_AssertionError,
     644                 :            :                      "SystemError not raised: %s",
     645                 :            :                      msg);
     646                 :          0 :         return 0;
     647                 :            :     }
     648         [ #  # ]:          0 :     if (PyErr_ExceptionMatches(PyExc_SystemError)) {
     649                 :            :         // expected exception
     650                 :          0 :         PyErr_Clear();
     651                 :          0 :         return 1;
     652                 :            :     }
     653                 :            :     // unexpected exception
     654                 :          0 :     return 0;
     655                 :            : }
     656                 :            : 
     657                 :            : static PyObject *
     658                 :          0 : test_string_from_format(PyObject *self, PyObject *Py_UNUSED(ignored))
     659                 :            : {
     660                 :            :     PyObject *result;
     661                 :          0 :     PyObject *unicode = PyUnicode_FromString("None");
     662                 :            : 
     663                 :            : #define CHECK_FORMAT_2(FORMAT, EXPECTED, ARG1, ARG2)                \
     664                 :            :     result = PyUnicode_FromFormat(FORMAT, ARG1, ARG2);              \
     665                 :            :     if (EXPECTED == NULL) {                                         \
     666                 :            :         if (!check_raised_systemerror(result, FORMAT)) {            \
     667                 :            :             goto Fail;                                              \
     668                 :            :         }                                                           \
     669                 :            :     }                                                               \
     670                 :            :     else if (result == NULL)                                        \
     671                 :            :         return NULL;                                                \
     672                 :            :     else if (!_PyUnicode_EqualToASCIIString(result, EXPECTED)) {    \
     673                 :            :         PyErr_Format(PyExc_AssertionError,                          \
     674                 :            :                      "test_string_from_format: failed at \"%s\" "   \
     675                 :            :                      "expected \"%s\" got \"%s\"",                  \
     676                 :            :                      FORMAT, EXPECTED, PyUnicode_AsUTF8(result));   \
     677                 :            :         goto Fail;                                                  \
     678                 :            :     }                                                               \
     679                 :            :     Py_XDECREF(result)
     680                 :            : 
     681                 :            : #define CHECK_FORMAT_1(FORMAT, EXPECTED, ARG)                       \
     682                 :            :     CHECK_FORMAT_2(FORMAT, EXPECTED, ARG, 0)
     683                 :            : 
     684                 :            : #define CHECK_FORMAT_0(FORMAT, EXPECTED)                            \
     685                 :            :     CHECK_FORMAT_2(FORMAT, EXPECTED, 0, 0)
     686                 :            : 
     687                 :            :     // Unrecognized
     688         [ #  # ]:          0 :     CHECK_FORMAT_2("%u %? %u", NULL, 1, 2);
     689                 :            : 
     690                 :            :     // "%%" (options are rejected)
     691   [ #  #  #  # ]:          0 :     CHECK_FORMAT_0(  "%%", "%");
     692         [ #  # ]:          0 :     CHECK_FORMAT_0( "%0%", NULL);
     693         [ #  # ]:          0 :     CHECK_FORMAT_0("%00%", NULL);
     694         [ #  # ]:          0 :     CHECK_FORMAT_0( "%2%", NULL);
     695         [ #  # ]:          0 :     CHECK_FORMAT_0("%02%", NULL);
     696         [ #  # ]:          0 :     CHECK_FORMAT_0("%.0%", NULL);
     697         [ #  # ]:          0 :     CHECK_FORMAT_0("%.2%", NULL);
     698                 :            : 
     699                 :            :     // "%c"
     700   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1(  "%c", "c", 'c');
     701   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1( "%0c", "c", 'c');
     702   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%00c", "c", 'c');
     703   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1( "%2c", "c", 'c');
     704   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%02c", "c", 'c');
     705   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.0c", "c", 'c');
     706   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.2c", "c", 'c');
     707                 :            : 
     708                 :            :     // Integers
     709   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%d",             "123",                (int)123);
     710   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%i",             "123",                (int)123);
     711   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%u",             "123",       (unsigned int)123);
     712   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%ld",            "123",               (long)123);
     713   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%li",            "123",               (long)123);
     714   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%lu",            "123",      (unsigned long)123);
     715   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%lld",           "123",          (long long)123);
     716   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%lli",           "123",          (long long)123);
     717   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%llu",           "123", (unsigned long long)123);
     718   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%zd",            "123",         (Py_ssize_t)123);
     719   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%zi",            "123",         (Py_ssize_t)123);
     720   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%zu",            "123",             (size_t)123);
     721   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%x",              "7b",                (int)123);
     722                 :            : 
     723   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%d",            "-123",               (int)-123);
     724   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%i",            "-123",               (int)-123);
     725   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%ld",           "-123",              (long)-123);
     726   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%li",           "-123",              (long)-123);
     727   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%lld",          "-123",         (long long)-123);
     728   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%lli",          "-123",         (long long)-123);
     729   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%zd",           "-123",        (Py_ssize_t)-123);
     730   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%zi",           "-123",        (Py_ssize_t)-123);
     731   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%x",        "ffffff85",               (int)-123);
     732                 :            : 
     733                 :            :     // Integers: width < length
     734   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1d",            "123",                (int)123);
     735   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1i",            "123",                (int)123);
     736   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1u",            "123",       (unsigned int)123);
     737   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1ld",           "123",               (long)123);
     738   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1li",           "123",               (long)123);
     739   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1lu",           "123",      (unsigned long)123);
     740   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1lld",          "123",          (long long)123);
     741   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1lli",          "123",          (long long)123);
     742   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1llu",          "123", (unsigned long long)123);
     743   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1zd",           "123",         (Py_ssize_t)123);
     744   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1zi",           "123",         (Py_ssize_t)123);
     745   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1zu",           "123",             (size_t)123);
     746   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1x",             "7b",                (int)123);
     747                 :            : 
     748   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1d",           "-123",               (int)-123);
     749   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1i",           "-123",               (int)-123);
     750   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1ld",          "-123",              (long)-123);
     751   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1li",          "-123",              (long)-123);
     752   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1lld",         "-123",         (long long)-123);
     753   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1lli",         "-123",         (long long)-123);
     754   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1zd",          "-123",        (Py_ssize_t)-123);
     755   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1zi",          "-123",        (Py_ssize_t)-123);
     756   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1x",       "ffffff85",               (int)-123);
     757                 :            : 
     758                 :            :     // Integers: width > length
     759   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5d",          "  123",                (int)123);
     760   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5i",          "  123",                (int)123);
     761   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5u",          "  123",       (unsigned int)123);
     762   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5ld",         "  123",               (long)123);
     763   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5li",         "  123",               (long)123);
     764   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5lu",         "  123",      (unsigned long)123);
     765   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5lld",        "  123",          (long long)123);
     766   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5lli",        "  123",          (long long)123);
     767   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5llu",        "  123", (unsigned long long)123);
     768   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5zd",         "  123",         (Py_ssize_t)123);
     769   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5zi",         "  123",         (Py_ssize_t)123);
     770   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5zu",         "  123",             (size_t)123);
     771   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5x",          "   7b",                (int)123);
     772                 :            : 
     773   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5d",          " -123",               (int)-123);
     774   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5i",          " -123",               (int)-123);
     775   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5ld",         " -123",              (long)-123);
     776   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5li",         " -123",              (long)-123);
     777   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5lld",        " -123",         (long long)-123);
     778   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5lli",        " -123",         (long long)-123);
     779   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5zd",         " -123",        (Py_ssize_t)-123);
     780   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5zi",         " -123",        (Py_ssize_t)-123);
     781   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%9x",      " ffffff85",               (int)-123);
     782                 :            : 
     783                 :            :     // Integers: width > length, 0-flag
     784   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05d",         "00123",                (int)123);
     785   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05i",         "00123",                (int)123);
     786   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05u",         "00123",       (unsigned int)123);
     787   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05ld",        "00123",               (long)123);
     788   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05li",        "00123",               (long)123);
     789   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05lu",        "00123",      (unsigned long)123);
     790   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05lld",       "00123",          (long long)123);
     791   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05lli",       "00123",          (long long)123);
     792   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05llu",       "00123", (unsigned long long)123);
     793   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05zd",        "00123",         (Py_ssize_t)123);
     794   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05zi",        "00123",         (Py_ssize_t)123);
     795   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05zu",        "00123",             (size_t)123);
     796   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05x",         "0007b",                (int)123);
     797                 :            : 
     798   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05d",         "-0123",               (int)-123);
     799   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05i",         "-0123",               (int)-123);
     800   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05ld",        "-0123",              (long)-123);
     801   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05li",        "-0123",              (long)-123);
     802   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05lld",       "-0123",         (long long)-123);
     803   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05lli",       "-0123",         (long long)-123);
     804   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05zd",        "-0123",        (Py_ssize_t)-123);
     805   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05zi",        "-0123",        (Py_ssize_t)-123);
     806   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%09x",     "0ffffff85",               (int)-123);
     807                 :            : 
     808                 :            :     // Integers: precision < length
     809   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1d",           "123",                (int)123);
     810   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1i",           "123",                (int)123);
     811   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1u",           "123",       (unsigned int)123);
     812   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1ld",          "123",               (long)123);
     813   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1li",          "123",               (long)123);
     814   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1lu",          "123",      (unsigned long)123);
     815   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1lld",         "123",          (long long)123);
     816   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1lli",         "123",          (long long)123);
     817   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1llu",         "123", (unsigned long long)123);
     818   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1zd",          "123",         (Py_ssize_t)123);
     819   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1zi",          "123",         (Py_ssize_t)123);
     820   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1zu",          "123",             (size_t)123);
     821   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1x",            "7b",                (int)123);
     822                 :            : 
     823   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1d",          "-123",               (int)-123);
     824   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1i",          "-123",               (int)-123);
     825   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1ld",         "-123",              (long)-123);
     826   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1li",         "-123",              (long)-123);
     827   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1lld",        "-123",         (long long)-123);
     828   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1lli",        "-123",         (long long)-123);
     829   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1zd",         "-123",        (Py_ssize_t)-123);
     830   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1zi",         "-123",        (Py_ssize_t)-123);
     831   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1x",      "ffffff85",               (int)-123);
     832                 :            : 
     833                 :            :     // Integers: precision > length
     834   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5d",         "00123",                (int)123);
     835   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5i",         "00123",                (int)123);
     836   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5u",         "00123",       (unsigned int)123);
     837   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5ld",        "00123",               (long)123);
     838   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5li",        "00123",               (long)123);
     839   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5lu",        "00123",      (unsigned long)123);
     840   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5lld",       "00123",          (long long)123);
     841   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5lli",       "00123",          (long long)123);
     842   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5llu",       "00123", (unsigned long long)123);
     843   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5zd",        "00123",         (Py_ssize_t)123);
     844   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5zi",        "00123",         (Py_ssize_t)123);
     845   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5zu",        "00123",             (size_t)123);
     846   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5x",         "0007b",                (int)123);
     847                 :            : 
     848   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5d",        "-00123",               (int)-123);
     849   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5i",        "-00123",               (int)-123);
     850   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5ld",       "-00123",              (long)-123);
     851   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5li",       "-00123",              (long)-123);
     852   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5lld",      "-00123",         (long long)-123);
     853   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5lli",      "-00123",         (long long)-123);
     854   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5zd",       "-00123",        (Py_ssize_t)-123);
     855   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5zi",       "-00123",        (Py_ssize_t)-123);
     856   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.9x",     "0ffffff85",               (int)-123);
     857                 :            : 
     858                 :            :     // Integers: width > precision > length
     859   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5d",      "  00123",                (int)123);
     860   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5i",      "  00123",                (int)123);
     861   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5u",      "  00123",       (unsigned int)123);
     862   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5ld",     "  00123",               (long)123);
     863   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5li",     "  00123",               (long)123);
     864   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5lu",     "  00123",      (unsigned long)123);
     865   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5lld",    "  00123",          (long long)123);
     866   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5lli",    "  00123",          (long long)123);
     867   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5llu",    "  00123", (unsigned long long)123);
     868   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5zd",     "  00123",         (Py_ssize_t)123);
     869   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5zi",     "  00123",         (Py_ssize_t)123);
     870   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5zu",     "  00123",             (size_t)123);
     871   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5x",      "  0007b",                (int)123);
     872                 :            : 
     873   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5d",      " -00123",               (int)-123);
     874   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5i",      " -00123",               (int)-123);
     875   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5ld",     " -00123",              (long)-123);
     876   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5li",     " -00123",              (long)-123);
     877   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5lld",    " -00123",         (long long)-123);
     878   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5lli",    " -00123",         (long long)-123);
     879   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5zd",     " -00123",        (Py_ssize_t)-123);
     880   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%7.5zi",     " -00123",        (Py_ssize_t)-123);
     881   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%10.9x",  " 0ffffff85",               (int)-123);
     882                 :            : 
     883                 :            :     // Integers: width > precision > length, 0-flag
     884   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5d",     "0000123",                (int)123);
     885   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5i",     "0000123",                (int)123);
     886   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5u",     "0000123",       (unsigned int)123);
     887   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5ld",    "0000123",               (long)123);
     888   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5li",    "0000123",               (long)123);
     889   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5lu",    "0000123",      (unsigned long)123);
     890   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5lld",   "0000123",          (long long)123);
     891   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5lli",   "0000123",          (long long)123);
     892   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5llu",   "0000123", (unsigned long long)123);
     893   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5zd",    "0000123",         (Py_ssize_t)123);
     894   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5zi",    "0000123",         (Py_ssize_t)123);
     895   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5zu",    "0000123",             (size_t)123);
     896   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5x",     "000007b",                (int)123);
     897                 :            : 
     898   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5d",     "-000123",               (int)-123);
     899   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5i",     "-000123",               (int)-123);
     900   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5ld",    "-000123",              (long)-123);
     901   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5li",    "-000123",              (long)-123);
     902   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5lld",   "-000123",         (long long)-123);
     903   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5lli",   "-000123",         (long long)-123);
     904   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5zd",    "-000123",        (Py_ssize_t)-123);
     905   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%07.5zi",    "-000123",        (Py_ssize_t)-123);
     906   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%010.9x", "00ffffff85",               (int)-123);
     907                 :            : 
     908                 :            :     // Integers: precision > width > length
     909   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7d",      "0000123",                (int)123);
     910   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7i",      "0000123",                (int)123);
     911   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7u",      "0000123",       (unsigned int)123);
     912   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7ld",     "0000123",               (long)123);
     913   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7li",     "0000123",               (long)123);
     914   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7lu",     "0000123",      (unsigned long)123);
     915   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7lld",    "0000123",          (long long)123);
     916   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7lli",    "0000123",          (long long)123);
     917   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7llu",    "0000123", (unsigned long long)123);
     918   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7zd",     "0000123",         (Py_ssize_t)123);
     919   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7zi",     "0000123",         (Py_ssize_t)123);
     920   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7zu",     "0000123",             (size_t)123);
     921   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7x",      "000007b",                (int)123);
     922                 :            : 
     923   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7d",     "-0000123",               (int)-123);
     924   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7i",     "-0000123",               (int)-123);
     925   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7ld",    "-0000123",              (long)-123);
     926   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7li",    "-0000123",              (long)-123);
     927   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7lld",   "-0000123",         (long long)-123);
     928   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7lli",   "-0000123",         (long long)-123);
     929   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7zd",    "-0000123",        (Py_ssize_t)-123);
     930   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.7zi",    "-0000123",        (Py_ssize_t)-123);
     931   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%9.10x",  "00ffffff85",               (int)-123);
     932                 :            : 
     933                 :            :     // Integers: precision > width > length, 0-flag
     934   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7d",     "0000123",                (int)123);
     935   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7i",     "0000123",                (int)123);
     936   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7u",     "0000123",       (unsigned int)123);
     937   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7ld",    "0000123",               (long)123);
     938   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7li",    "0000123",               (long)123);
     939   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7lu",    "0000123",      (unsigned long)123);
     940   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7lld",   "0000123",          (long long)123);
     941   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7lli",   "0000123",          (long long)123);
     942   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7llu",   "0000123", (unsigned long long)123);
     943   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7zd",    "0000123",         (Py_ssize_t)123);
     944   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7zi",    "0000123",         (Py_ssize_t)123);
     945   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7zu",    "0000123",             (size_t)123);
     946   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7x",     "000007b",                (int)123);
     947                 :            : 
     948   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7d",    "-0000123",               (int)-123);
     949   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7i",    "-0000123",               (int)-123);
     950   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7ld",   "-0000123",              (long)-123);
     951   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7li",   "-0000123",              (long)-123);
     952   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7lld",  "-0000123",         (long long)-123);
     953   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7lli",  "-0000123",         (long long)-123);
     954   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7zd",   "-0000123",        (Py_ssize_t)-123);
     955   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%05.7zi",   "-0000123",        (Py_ssize_t)-123);
     956   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%09.10x", "00ffffff85",               (int)-123);
     957                 :            : 
     958                 :            :     // Integers: precision = 0, arg = 0 (empty string in C)
     959   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.0d",             "0",                  (int)0);
     960   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.0i",             "0",                  (int)0);
     961   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.0u",             "0",         (unsigned int)0);
     962   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.0ld",            "0",                 (long)0);
     963   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.0li",            "0",                 (long)0);
     964   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.0lu",            "0",        (unsigned long)0);
     965   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.0lld",           "0",            (long long)0);
     966   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.0lli",           "0",            (long long)0);
     967   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.0llu",           "0",   (unsigned long long)0);
     968   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.0zd",            "0",           (Py_ssize_t)0);
     969   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.0zi",            "0",           (Py_ssize_t)0);
     970   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.0zu",            "0",               (size_t)0);
     971   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.0x",             "0",                  (int)0);
     972                 :            : 
     973                 :            :     // Strings
     974   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%s",     "None",  "None");
     975   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%U",     "None", unicode);
     976   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%A",     "None", Py_None);
     977   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%S",     "None", Py_None);
     978   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%R",     "None", Py_None);
     979   [ #  #  #  # ]:          0 :     CHECK_FORMAT_2("%V",     "None", unicode, "ignored");
     980   [ #  #  #  # ]:          0 :     CHECK_FORMAT_2("%V",     "None",    NULL,    "None");
     981                 :            : 
     982                 :            :     // Strings: width < length
     983   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1s",    "None",  "None");
     984   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1U",    "None", unicode);
     985   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1A",    "None", Py_None);
     986   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1S",    "None", Py_None);
     987   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1R",    "None", Py_None);
     988   [ #  #  #  # ]:          0 :     CHECK_FORMAT_2("%1V",    "None", unicode, "ignored");
     989   [ #  #  #  # ]:          0 :     CHECK_FORMAT_2("%1V",    "None",    NULL,    "None");
     990                 :            : 
     991                 :            :     // Strings: width > length
     992   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5s",   " None",  "None");
     993   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5U",   " None", unicode);
     994   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5A",   " None", Py_None);
     995   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5S",   " None", Py_None);
     996   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5R",   " None", Py_None);
     997   [ #  #  #  # ]:          0 :     CHECK_FORMAT_2("%5V",   " None", unicode, "ignored");
     998   [ #  #  #  # ]:          0 :     CHECK_FORMAT_2("%5V",   " None",    NULL,    "None");
     999                 :            : 
    1000                 :            :     // Strings: precision < length
    1001   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1s",      "N",  "None");
    1002   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1U",      "N", unicode);
    1003   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1A",      "N", Py_None);
    1004   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1S",      "N", Py_None);
    1005   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.1R",      "N", Py_None);
    1006   [ #  #  #  # ]:          0 :     CHECK_FORMAT_2("%.1V",      "N", unicode, "ignored");
    1007   [ #  #  #  # ]:          0 :     CHECK_FORMAT_2("%.1V",      "N",    NULL,    "None");
    1008                 :            : 
    1009                 :            :     // Strings: precision > length
    1010   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5s",   "None",  "None");
    1011   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5U",   "None", unicode);
    1012   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5A",   "None", Py_None);
    1013   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5S",   "None", Py_None);
    1014   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%.5R",   "None", Py_None);
    1015   [ #  #  #  # ]:          0 :     CHECK_FORMAT_2("%.5V",   "None", unicode, "ignored");
    1016   [ #  #  #  # ]:          0 :     CHECK_FORMAT_2("%.5V",   "None",    NULL,    "None");
    1017                 :            : 
    1018                 :            :     // Strings: precision < length, width > length
    1019   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.1s", "    N",  "None");
    1020   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.1U", "    N", unicode);
    1021   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.1A", "    N", Py_None);
    1022   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.1S", "    N", Py_None);
    1023   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%5.1R", "    N", Py_None);
    1024   [ #  #  #  # ]:          0 :     CHECK_FORMAT_2("%5.1V", "    N", unicode, "ignored");
    1025   [ #  #  #  # ]:          0 :     CHECK_FORMAT_2("%5.1V", "    N",    NULL,    "None");
    1026                 :            : 
    1027                 :            :     // Strings: width < length, precision > length
    1028   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1.5s",  "None",  "None");
    1029   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1.5U",  "None", unicode);
    1030   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1.5A",  "None", Py_None);
    1031   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1.5S",  "None", Py_None);
    1032   [ #  #  #  # ]:          0 :     CHECK_FORMAT_1("%1.5R",  "None", Py_None);
    1033   [ #  #  #  # ]:          0 :     CHECK_FORMAT_2("%1.5V",  "None", unicode, "ignored");
    1034   [ #  #  #  # ]:          0 :     CHECK_FORMAT_2("%1.5V",  "None",    NULL,    "None");
    1035                 :            : 
    1036                 :          0 :     Py_XDECREF(unicode);
    1037                 :          0 :     Py_RETURN_NONE;
    1038                 :            : 
    1039                 :          0 :  Fail:
    1040                 :          0 :     Py_XDECREF(result);
    1041                 :          0 :     Py_XDECREF(unicode);
    1042                 :          0 :     return NULL;
    1043                 :            : 
    1044                 :            : #undef CHECK_FORMAT_2
    1045                 :            : #undef CHECK_FORMAT_1
    1046                 :            : #undef CHECK_FORMAT_0
    1047                 :            : }
    1048                 :            : 
    1049                 :            : static PyMethodDef TestMethods[] = {
    1050                 :            :     {"codec_incrementalencoder", codec_incrementalencoder,       METH_VARARGS},
    1051                 :            :     {"codec_incrementaldecoder", codec_incrementaldecoder,       METH_VARARGS},
    1052                 :            :     {"test_unicode_compare_with_ascii",
    1053                 :            :      test_unicode_compare_with_ascii,                            METH_NOARGS},
    1054                 :            :     {"test_string_from_format",  test_string_from_format,        METH_NOARGS},
    1055                 :            :     {"test_widechar",            test_widechar,                  METH_NOARGS},
    1056                 :            :     {"unicode_fromobject",       unicode_fromobject,             METH_O},
    1057                 :            :     {"unicode_aswidechar",       unicode_aswidechar,             METH_VARARGS},
    1058                 :            :     {"unicode_aswidecharstring", unicode_aswidecharstring,       METH_VARARGS},
    1059                 :            :     {"unicode_asucs4",           unicode_asucs4,                 METH_VARARGS},
    1060                 :            :     {"unicode_asutf8",           unicode_asutf8,                 METH_VARARGS},
    1061                 :            :     {"unicode_asutf8andsize",    unicode_asutf8andsize,          METH_VARARGS},
    1062                 :            :     {"unicode_decodeutf8",       unicode_decodeutf8,             METH_VARARGS},
    1063                 :            :     {"unicode_decodeutf8stateful",unicode_decodeutf8stateful,    METH_VARARGS},
    1064                 :            :     {"unicode_concat",           unicode_concat,                 METH_VARARGS},
    1065                 :            :     {"unicode_splitlines",       unicode_splitlines,             METH_VARARGS},
    1066                 :            :     {"unicode_split",            unicode_split,                  METH_VARARGS},
    1067                 :            :     {"unicode_rsplit",           unicode_rsplit,                 METH_VARARGS},
    1068                 :            :     {"unicode_partition",        unicode_partition,              METH_VARARGS},
    1069                 :            :     {"unicode_rpartition",       unicode_rpartition,             METH_VARARGS},
    1070                 :            :     {"unicode_translate",        unicode_translate,              METH_VARARGS},
    1071                 :            :     {"unicode_join",             unicode_join,                   METH_VARARGS},
    1072                 :            :     {"unicode_count",            unicode_count,                  METH_VARARGS},
    1073                 :            :     {"unicode_tailmatch",        unicode_tailmatch,              METH_VARARGS},
    1074                 :            :     {"unicode_find",             unicode_find,                   METH_VARARGS},
    1075                 :            :     {"unicode_findchar",         unicode_findchar,               METH_VARARGS},
    1076                 :            :     {"unicode_replace",          unicode_replace,                METH_VARARGS},
    1077                 :            :     {"unicode_compare",          unicode_compare,                METH_VARARGS},
    1078                 :            :     {"unicode_comparewithasciistring",unicode_comparewithasciistring,METH_VARARGS},
    1079                 :            :     {"unicode_richcompare",      unicode_richcompare,            METH_VARARGS},
    1080                 :            :     {"unicode_format",           unicode_format,                 METH_VARARGS},
    1081                 :            :     {"unicode_contains",         unicode_contains,               METH_VARARGS},
    1082                 :            :     {"unicode_isidentifier",     unicode_isidentifier,           METH_O},
    1083                 :            :     {"unicode_copycharacters",   unicode_copycharacters,         METH_VARARGS},
    1084                 :            :     {NULL},
    1085                 :            : };
    1086                 :            : 
    1087                 :            : int
    1088                 :          2 : _PyTestCapi_Init_Unicode(PyObject *m) {
    1089                 :          2 :     _testcapimodule = PyModule_GetDef(m);
    1090                 :            : 
    1091         [ -  + ]:          2 :     if (PyModule_AddFunctions(m, TestMethods) < 0) {
    1092                 :          0 :         return -1;
    1093                 :            :     }
    1094                 :            : 
    1095                 :          2 :     return 0;
    1096                 :            : }

Generated by: LCOV version 1.14