cpython/Lib/test/clinic.test

/*[clinic input]
output preset block
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=3c81ac2402d06a8b]*/

/*[clinic input]
test_object_converter

    a: object
    b: object(converter="PyUnicode_FSConverter")
    c: object(subclass_of="&PyUnicode_Type")
    d: object(type="PyUnicode_Object *")
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_object_converter__doc__,
"test_object_converter($module, a, b, c, d, /)\n"
"--\n"
"\n");

#define TEST_OBJECT_CONVERTER_METHODDEF    \
    {"test_object_converter", (PyCFunction)(void(*)(void))test_object_converter, METH_FASTCALL, test_object_converter__doc__},

static PyObject *
test_object_converter_impl(PyObject *module, PyObject *a, PyObject *b,
                           PyObject *c, PyUnicode_Object *d);

static PyObject *
test_object_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    PyObject *a;
    PyObject *b;
    PyObject *c;
    PyUnicode_Object *d;

    if (!_PyArg_ParseStack(args, nargs, "OO&O!O:test_object_converter",
        &a, PyUnicode_FSConverter, &b, &PyUnicode_Type, &c, &d)) {
        goto exit;
    }
    return_value = test_object_converter_impl(module, a, b, c, d);

exit:
    return return_value;
}

static PyObject *
test_object_converter_impl(PyObject *module, PyObject *a, PyObject *b,
                           PyObject *c, PyUnicode_Object *d)
/*[clinic end generated code: output=ac25517226de46c8 input=005e6a8a711a869b]*/

/*[clinic input]
test_object_converter_one_arg

    a: object
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_object_converter_one_arg__doc__,
"test_object_converter_one_arg($module, a, /)\n"
"--\n"
"\n");

#define TEST_OBJECT_CONVERTER_ONE_ARG_METHODDEF    \
    {"test_object_converter_one_arg", (PyCFunction)test_object_converter_one_arg, METH_O, test_object_converter_one_arg__doc__},

static PyObject *
test_object_converter_one_arg(PyObject *module, PyObject *a)
/*[clinic end generated code: output=6da755f8502139df input=d635d92a421f1ca3]*/

/*[clinic input]
test_objects_converter

    a: object
    b: object = NULL
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_objects_converter__doc__,
"test_objects_converter($module, a, b=None, /)\n"
"--\n"
"\n");

#define TEST_OBJECTS_CONVERTER_METHODDEF    \
    {"test_objects_converter", (PyCFunction)(void(*)(void))test_objects_converter, METH_FASTCALL, test_objects_converter__doc__},

static PyObject *
test_objects_converter_impl(PyObject *module, PyObject *a, PyObject *b);

static PyObject *
test_objects_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    PyObject *a;
    PyObject *b = NULL;

    if (!_PyArg_UnpackStack(args, nargs, "test_objects_converter",
        1, 2,
        &a, &b)) {
        goto exit;
    }
    return_value = test_objects_converter_impl(module, a, b);

exit:
    return return_value;
}

static PyObject *
test_objects_converter_impl(PyObject *module, PyObject *a, PyObject *b)
/*[clinic end generated code: output=068c25d6ae8cd1ef input=4cbb3d9edd2a36f3]*/

/*[clinic input]
test_object_converter_subclass_of

    a: object(subclass_of="&PyLong_Type")
    b: object(subclass_of="&PyTuple_Type")
    c: object(subclass_of="&PyList_Type")
    d: object(subclass_of="&PySet_Type")
    e: object(subclass_of="&PyFrozenSet_Type")
    f: object(subclass_of="&PyDict_Type")
    g: object(subclass_of="&PyUnicode_Type")
    h: object(subclass_of="&PyBytes_Type")
    i: object(subclass_of="&PyByteArray_Type")
    j: object(subclass_of="&MyType")
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_object_converter_subclass_of__doc__,
"test_object_converter_subclass_of($module, a, b, c, d, e, f, g, h, i,\n"
"                                  j, /)\n"
"--\n"
"\n");

#define TEST_OBJECT_CONVERTER_SUBCLASS_OF_METHODDEF    \
    {"test_object_converter_subclass_of", (PyCFunction)(void(*)(void))test_object_converter_subclass_of, METH_FASTCALL, test_object_converter_subclass_of__doc__},

static PyObject *
test_object_converter_subclass_of_impl(PyObject *module, PyObject *a,
                                       PyObject *b, PyObject *c, PyObject *d,
                                       PyObject *e, PyObject *f, PyObject *g,
                                       PyObject *h, PyObject *i, PyObject *j);

static PyObject *
test_object_converter_subclass_of(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    PyObject *a;
    PyObject *b;
    PyObject *c;
    PyObject *d;
    PyObject *e;
    PyObject *f;
    PyObject *g;
    PyObject *h;
    PyObject *i;
    PyObject *j;

    if (!_PyArg_ParseStack(args, nargs, "O!O!O!O!O!O!O!O!O!O!:test_object_converter_subclass_of",
        &PyLong_Type, &a, &PyTuple_Type, &b, &PyList_Type, &c, &PySet_Type, &d, &PyFrozenSet_Type, &e, &PyDict_Type, &f, &PyUnicode_Type, &g, &PyBytes_Type, &h, &PyByteArray_Type, &i, &MyType, &j)) {
        goto exit;
    }
    return_value = test_object_converter_subclass_of_impl(module, a, b, c, d, e, f, g, h, i, j);

exit:
    return return_value;
}

static PyObject *
test_object_converter_subclass_of_impl(PyObject *module, PyObject *a,
                                       PyObject *b, PyObject *c, PyObject *d,
                                       PyObject *e, PyObject *f, PyObject *g,
                                       PyObject *h, PyObject *i, PyObject *j)
/*[clinic end generated code: output=b26bcdc31dfc7872 input=31b06b772d5f983e]*/

/*[clinic input]
test_PyBytesObject_converter

    a: PyBytesObject
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_PyBytesObject_converter__doc__,
"test_PyBytesObject_converter($module, a, /)\n"
"--\n"
"\n");

#define TEST_PYBYTESOBJECT_CONVERTER_METHODDEF    \
    {"test_PyBytesObject_converter", (PyCFunction)test_PyBytesObject_converter, METH_O, test_PyBytesObject_converter__doc__},

static PyObject *
test_PyBytesObject_converter_impl(PyObject *module, PyBytesObject *a);

static PyObject *
test_PyBytesObject_converter(PyObject *module, PyObject *arg)
{
    PyObject *return_value = NULL;
    PyBytesObject *a;

    if (!PyBytes_Check(arg)) {
        _PyArg_BadArgument("test_PyBytesObject_converter", "bytes", arg);
        goto exit;
    }
    a = (PyBytesObject *)arg;
    return_value = test_PyBytesObject_converter_impl(module, a);

exit:
    return return_value;
}

static PyObject *
test_PyBytesObject_converter_impl(PyObject *module, PyBytesObject *a)
/*[clinic end generated code: output=fd69d6df4d26c853 input=12b10c7cb5750400]*/

/*[clinic input]
test_PyByteArrayObject_converter

    a: PyByteArrayObject
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_PyByteArrayObject_converter__doc__,
"test_PyByteArrayObject_converter($module, a, /)\n"
"--\n"
"\n");

#define TEST_PYBYTEARRAYOBJECT_CONVERTER_METHODDEF    \
    {"test_PyByteArrayObject_converter", (PyCFunction)test_PyByteArrayObject_converter, METH_O, test_PyByteArrayObject_converter__doc__},

static PyObject *
test_PyByteArrayObject_converter_impl(PyObject *module, PyByteArrayObject *a);

static PyObject *
test_PyByteArrayObject_converter(PyObject *module, PyObject *arg)
{
    PyObject *return_value = NULL;
    PyByteArrayObject *a;

    if (!PyByteArray_Check(arg)) {
        _PyArg_BadArgument("test_PyByteArrayObject_converter", "bytearray", arg);
        goto exit;
    }
    a = (PyByteArrayObject *)arg;
    return_value = test_PyByteArrayObject_converter_impl(module, a);

exit:
    return return_value;
}

static PyObject *
test_PyByteArrayObject_converter_impl(PyObject *module, PyByteArrayObject *a)
/*[clinic end generated code: output=d309c909182c4183 input=5a657da535d194ae]*/

/*[clinic input]
test_unicode_converter

    a: unicode
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_unicode_converter__doc__,
"test_unicode_converter($module, a, /)\n"
"--\n"
"\n");

#define TEST_UNICODE_CONVERTER_METHODDEF    \
    {"test_unicode_converter", (PyCFunction)test_unicode_converter, METH_O, test_unicode_converter__doc__},

static PyObject *
test_unicode_converter_impl(PyObject *module, PyObject *a);

static PyObject *
test_unicode_converter(PyObject *module, PyObject *arg)
{
    PyObject *return_value = NULL;
    PyObject *a;

    if (!PyUnicode_Check(arg)) {
        _PyArg_BadArgument("test_unicode_converter", "str", arg);
        goto exit;
    }
    if (PyUnicode_READY(arg) == -1) {
        goto exit;
    }
    a = arg;
    return_value = test_unicode_converter_impl(module, a);

exit:
    return return_value;
}

static PyObject *
test_unicode_converter_impl(PyObject *module, PyObject *a)
/*[clinic end generated code: output=ca603454e1f8f764 input=aa33612df92aa9c5]*/

/*[clinic input]
test_bool_converter

    a: bool = True
    b: bool(accept={object}) = True
    c: bool(accept={int}) = True
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_bool_converter__doc__,
"test_bool_converter($module, a=True, b=True, c=True, /)\n"
"--\n"
"\n");

#define TEST_BOOL_CONVERTER_METHODDEF    \
    {"test_bool_converter", (PyCFunction)(void(*)(void))test_bool_converter, METH_FASTCALL, test_bool_converter__doc__},

static PyObject *
test_bool_converter_impl(PyObject *module, int a, int b, int c);

static PyObject *
test_bool_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    int a = 1;
    int b = 1;
    int c = 1;

    if (!_PyArg_ParseStack(args, nargs, "|ppi:test_bool_converter",
        &a, &b, &c)) {
        goto exit;
    }
    return_value = test_bool_converter_impl(module, a, b, c);

exit:
    return return_value;
}

static PyObject *
test_bool_converter_impl(PyObject *module, int a, int b, int c)
/*[clinic end generated code: output=f08a22d3390ab6f7 input=939854fa9f248c60]*/

/*[clinic input]
test_char_converter

    a: char = b'A'
    b: char = b'\a'
    c: char = b'\b'
    d: char = b'\t'
    e: char = b'\n'
    f: char = b'\v'
    g: char = b'\f'
    h: char = b'\r'
    i: char = b'"'
    j: char = b"'"
    k: char = b'?'
    l: char = b'\\'
    m: char = b'\000'
    n: char = b'\377'
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_char_converter__doc__,
"test_char_converter($module, a=b\'A\', b=b\'\\x07\', c=b\'\\x08\', d=b\'\\t\',\n"
"                    e=b\'\\n\', f=b\'\\x0b\', g=b\'\\x0c\', h=b\'\\r\', i=b\'\"\',\n"
"                    j=b\"\'\", k=b\'?\', l=b\'\\\\\', m=b\'\\x00\', n=b\'\\xff\', /)\n"
"--\n"
"\n");

#define TEST_CHAR_CONVERTER_METHODDEF    \
    {"test_char_converter", (PyCFunction)(void(*)(void))test_char_converter, METH_FASTCALL, test_char_converter__doc__},

static PyObject *
test_char_converter_impl(PyObject *module, char a, char b, char c, char d,
                         char e, char f, char g, char h, char i, char j,
                         char k, char l, char m, char n);

static PyObject *
test_char_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    char a = 'A';
    char b = '\x07';
    char c = '\x08';
    char d = '\t';
    char e = '\n';
    char f = '\x0b';
    char g = '\x0c';
    char h = '\r';
    char i = '"';
    char j = '\'';
    char k = '?';
    char l = '\\';
    char m = '\x00';
    char n = '\xff';

    if (!_PyArg_ParseStack(args, nargs, "|cccccccccccccc:test_char_converter",
        &a, &b, &c, &d, &e, &f, &g, &h, &i, &j, &k, &l, &m, &n)) {
        goto exit;
    }
    return_value = test_char_converter_impl(module, a, b, c, d, e, f, g, h, i, j, k, l, m, n);

exit:
    return return_value;
}

static PyObject *
test_char_converter_impl(PyObject *module, char a, char b, char c, char d,
                         char e, char f, char g, char h, char i, char j,
                         char k, char l, char m, char n)
/*[clinic end generated code: output=14c61e8ee78f3d47 input=e42330417a44feac]*/

/*[clinic input]
test_unsigned_char_converter

    a: unsigned_char = 12
    b: unsigned_char(bitwise=False) = 34
    c: unsigned_char(bitwise=True) = 56
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_unsigned_char_converter__doc__,
"test_unsigned_char_converter($module, a=12, b=34, c=56, /)\n"
"--\n"
"\n");

#define TEST_UNSIGNED_CHAR_CONVERTER_METHODDEF    \
    {"test_unsigned_char_converter", (PyCFunction)(void(*)(void))test_unsigned_char_converter, METH_FASTCALL, test_unsigned_char_converter__doc__},

static PyObject *
test_unsigned_char_converter_impl(PyObject *module, unsigned char a,
                                  unsigned char b, unsigned char c);

static PyObject *
test_unsigned_char_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    unsigned char a = 12;
    unsigned char b = 34;
    unsigned char c = 56;

    if (!_PyArg_ParseStack(args, nargs, "|bbB:test_unsigned_char_converter",
        &a, &b, &c)) {
        goto exit;
    }
    return_value = test_unsigned_char_converter_impl(module, a, b, c);

exit:
    return return_value;
}

static PyObject *
test_unsigned_char_converter_impl(PyObject *module, unsigned char a,
                                  unsigned char b, unsigned char c)
/*[clinic end generated code: output=a4fd7ad26077dcfc input=021414060993e289]*/

/*[clinic input]
test_short_converter

    a: short = 12
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_short_converter__doc__,
"test_short_converter($module, a=12, /)\n"
"--\n"
"\n");

#define TEST_SHORT_CONVERTER_METHODDEF    \
    {"test_short_converter", (PyCFunction)(void(*)(void))test_short_converter, METH_FASTCALL, test_short_converter__doc__},

static PyObject *
test_short_converter_impl(PyObject *module, short a);

static PyObject *
test_short_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    short a = 12;

    if (!_PyArg_ParseStack(args, nargs, "|h:test_short_converter",
        &a)) {
        goto exit;
    }
    return_value = test_short_converter_impl(module, a);

exit:
    return return_value;
}

static PyObject *
test_short_converter_impl(PyObject *module, short a)
/*[clinic end generated code: output=08259a92c12890b1 input=6a8a7a509a498ff4]*/

/*[clinic input]
test_unsigned_short_converter

    a: unsigned_short = 12
    b: unsigned_short(bitwise=False) = 34
    c: unsigned_short(bitwise=True) = 56
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_unsigned_short_converter__doc__,
"test_unsigned_short_converter($module, a=12, b=34, c=56, /)\n"
"--\n"
"\n");

#define TEST_UNSIGNED_SHORT_CONVERTER_METHODDEF    \
    {"test_unsigned_short_converter", (PyCFunction)(void(*)(void))test_unsigned_short_converter, METH_FASTCALL, test_unsigned_short_converter__doc__},

static PyObject *
test_unsigned_short_converter_impl(PyObject *module, unsigned short a,
                                   unsigned short b, unsigned short c);

static PyObject *
test_unsigned_short_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    unsigned short a = 12;
    unsigned short b = 34;
    unsigned short c = 56;

    if (!_PyArg_ParseStack(args, nargs, "|O&O&H:test_unsigned_short_converter",
        _PyLong_UnsignedShort_Converter, &a, _PyLong_UnsignedShort_Converter, &b, &c)) {
        goto exit;
    }
    return_value = test_unsigned_short_converter_impl(module, a, b, c);

exit:
    return return_value;
}

static PyObject *
test_unsigned_short_converter_impl(PyObject *module, unsigned short a,
                                   unsigned short b, unsigned short c)
/*[clinic end generated code: output=d714bceb98c1fe84 input=cdfd8eff3d9176b4]*/

/*[clinic input]
test_int_converter

    a: int = 12
    b: int(accept={int}) = 34
    c: int(accept={str}) = 45
    d: int(type='myenum') = 67
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_int_converter__doc__,
"test_int_converter($module, a=12, b=34, c=45, d=67, /)\n"
"--\n"
"\n");

#define TEST_INT_CONVERTER_METHODDEF    \
    {"test_int_converter", (PyCFunction)(void(*)(void))test_int_converter, METH_FASTCALL, test_int_converter__doc__},

static PyObject *
test_int_converter_impl(PyObject *module, int a, int b, int c, myenum d);

static PyObject *
test_int_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    int a = 12;
    int b = 34;
    int c = 45;
    myenum d = 67;

    if (!_PyArg_ParseStack(args, nargs, "|iiCi:test_int_converter",
        &a, &b, &c, &d)) {
        goto exit;
    }
    return_value = test_int_converter_impl(module, a, b, c, d);

exit:
    return return_value;
}

static PyObject *
test_int_converter_impl(PyObject *module, int a, int b, int c, myenum d)
/*[clinic end generated code: output=1995799d5264e4a5 input=d20541fc1ca0553e]*/

/*[clinic input]
test_unsigned_int_converter

    a: unsigned_int = 12
    b: unsigned_int(bitwise=False) = 34
    c: unsigned_int(bitwise=True) = 56
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_unsigned_int_converter__doc__,
"test_unsigned_int_converter($module, a=12, b=34, c=56, /)\n"
"--\n"
"\n");

#define TEST_UNSIGNED_INT_CONVERTER_METHODDEF    \
    {"test_unsigned_int_converter", (PyCFunction)(void(*)(void))test_unsigned_int_converter, METH_FASTCALL, test_unsigned_int_converter__doc__},

static PyObject *
test_unsigned_int_converter_impl(PyObject *module, unsigned int a,
                                 unsigned int b, unsigned int c);

static PyObject *
test_unsigned_int_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    unsigned int a = 12;
    unsigned int b = 34;
    unsigned int c = 56;

    if (!_PyArg_ParseStack(args, nargs, "|O&O&I:test_unsigned_int_converter",
        _PyLong_UnsignedInt_Converter, &a, _PyLong_UnsignedInt_Converter, &b, &c)) {
        goto exit;
    }
    return_value = test_unsigned_int_converter_impl(module, a, b, c);

exit:
    return return_value;
}

static PyObject *
test_unsigned_int_converter_impl(PyObject *module, unsigned int a,
                                 unsigned int b, unsigned int c)
/*[clinic end generated code: output=3cdb7a3ef2b369a3 input=5533534828b62fc0]*/

/*[clinic input]
test_long_converter

    a: long = 12
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_long_converter__doc__,
"test_long_converter($module, a=12, /)\n"
"--\n"
"\n");

#define TEST_LONG_CONVERTER_METHODDEF    \
    {"test_long_converter", (PyCFunction)(void(*)(void))test_long_converter, METH_FASTCALL, test_long_converter__doc__},

static PyObject *
test_long_converter_impl(PyObject *module, long a);

static PyObject *
test_long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    long a = 12;

    if (!_PyArg_ParseStack(args, nargs, "|l:test_long_converter",
        &a)) {
        goto exit;
    }
    return_value = test_long_converter_impl(module, a);

exit:
    return return_value;
}

static PyObject *
test_long_converter_impl(PyObject *module, long a)
/*[clinic end generated code: output=65a8092a1dc10de6 input=d2179e3c9cdcde89]*/

/*[clinic input]
test_unsigned_long_converter

    a: unsigned_long = 12
    b: unsigned_long(bitwise=False) = 34
    c: unsigned_long(bitwise=True) = 56
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_unsigned_long_converter__doc__,
"test_unsigned_long_converter($module, a=12, b=34, c=56, /)\n"
"--\n"
"\n");

#define TEST_UNSIGNED_LONG_CONVERTER_METHODDEF    \
    {"test_unsigned_long_converter", (PyCFunction)(void(*)(void))test_unsigned_long_converter, METH_FASTCALL, test_unsigned_long_converter__doc__},

static PyObject *
test_unsigned_long_converter_impl(PyObject *module, unsigned long a,
                                  unsigned long b, unsigned long c);

static PyObject *
test_unsigned_long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    unsigned long a = 12;
    unsigned long b = 34;
    unsigned long c = 56;

    if (!_PyArg_ParseStack(args, nargs, "|O&O&k:test_unsigned_long_converter",
        _PyLong_UnsignedLong_Converter, &a, _PyLong_UnsignedLong_Converter, &b, &c)) {
        goto exit;
    }
    return_value = test_unsigned_long_converter_impl(module, a, b, c);

exit:
    return return_value;
}

static PyObject *
test_unsigned_long_converter_impl(PyObject *module, unsigned long a,
                                  unsigned long b, unsigned long c)
/*[clinic end generated code: output=81fd66d8981abeb2 input=f450d94cae1ef73b]*/

/*[clinic input]
test_long_long_converter

    a: long_long = 12
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_long_long_converter__doc__,
"test_long_long_converter($module, a=12, /)\n"
"--\n"
"\n");

#define TEST_LONG_LONG_CONVERTER_METHODDEF    \
    {"test_long_long_converter", (PyCFunction)(void(*)(void))test_long_long_converter, METH_FASTCALL, test_long_long_converter__doc__},

static PyObject *
test_long_long_converter_impl(PyObject *module, long long a);

static PyObject *
test_long_long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    long long a = 12;

    if (!_PyArg_ParseStack(args, nargs, "|L:test_long_long_converter",
        &a)) {
        goto exit;
    }
    return_value = test_long_long_converter_impl(module, a);

exit:
    return return_value;
}

static PyObject *
test_long_long_converter_impl(PyObject *module, long long a)
/*[clinic end generated code: output=9412f5800661b0c0 input=d5fc81577ff4dd02]*/

/*[clinic input]
test_unsigned_long_long_converter

    a: unsigned_long_long = 12
    b: unsigned_long_long(bitwise=False) = 34
    c: unsigned_long_long(bitwise=True) = 56
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_unsigned_long_long_converter__doc__,
"test_unsigned_long_long_converter($module, a=12, b=34, c=56, /)\n"
"--\n"
"\n");

#define TEST_UNSIGNED_LONG_LONG_CONVERTER_METHODDEF    \
    {"test_unsigned_long_long_converter", (PyCFunction)(void(*)(void))test_unsigned_long_long_converter, METH_FASTCALL, test_unsigned_long_long_converter__doc__},

static PyObject *
test_unsigned_long_long_converter_impl(PyObject *module,
                                       unsigned long long a,
                                       unsigned long long b,
                                       unsigned long long c);

static PyObject *
test_unsigned_long_long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    unsigned long long a = 12;
    unsigned long long b = 34;
    unsigned long long c = 56;

    if (!_PyArg_ParseStack(args, nargs, "|O&O&K:test_unsigned_long_long_converter",
        _PyLong_UnsignedLongLong_Converter, &a, _PyLong_UnsignedLongLong_Converter, &b, &c)) {
        goto exit;
    }
    return_value = test_unsigned_long_long_converter_impl(module, a, b, c);

exit:
    return return_value;
}

static PyObject *
test_unsigned_long_long_converter_impl(PyObject *module,
                                       unsigned long long a,
                                       unsigned long long b,
                                       unsigned long long c)
/*[clinic end generated code: output=f5a57e0ccc048a32 input=a15115dc41866ff4]*/

/*[clinic input]
test_Py_ssize_t_converter

    a: Py_ssize_t = 12
    b: Py_ssize_t(accept={int}) = 34
    c: Py_ssize_t(accept={int, NoneType}) = 56
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_Py_ssize_t_converter__doc__,
"test_Py_ssize_t_converter($module, a=12, b=34, c=56, /)\n"
"--\n"
"\n");

#define TEST_PY_SSIZE_T_CONVERTER_METHODDEF    \
    {"test_Py_ssize_t_converter", (PyCFunction)(void(*)(void))test_Py_ssize_t_converter, METH_FASTCALL, test_Py_ssize_t_converter__doc__},

static PyObject *
test_Py_ssize_t_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b,
                               Py_ssize_t c);

static PyObject *
test_Py_ssize_t_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    Py_ssize_t a = 12;
    Py_ssize_t b = 34;
    Py_ssize_t c = 56;

    if (!_PyArg_ParseStack(args, nargs, "|nnO&:test_Py_ssize_t_converter",
        &a, &b, _Py_convert_optional_to_ssize_t, &c)) {
        goto exit;
    }
    return_value = test_Py_ssize_t_converter_impl(module, a, b, c);

exit:
    return return_value;
}

static PyObject *
test_Py_ssize_t_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b,
                               Py_ssize_t c)
/*[clinic end generated code: output=50bc360c57b40e3f input=3855f184bb3f299d]*/

/*[clinic input]
test_slice_index_converter

    a: slice_index = 12
    b: slice_index(accept={int}) = 34
    c: slice_index(accept={int, NoneType}) = 56
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_slice_index_converter__doc__,
"test_slice_index_converter($module, a=12, b=34, c=56, /)\n"
"--\n"
"\n");

#define TEST_SLICE_INDEX_CONVERTER_METHODDEF    \
    {"test_slice_index_converter", (PyCFunction)(void(*)(void))test_slice_index_converter, METH_FASTCALL, test_slice_index_converter__doc__},

static PyObject *
test_slice_index_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b,
                                Py_ssize_t c);

static PyObject *
test_slice_index_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    Py_ssize_t a = 12;
    Py_ssize_t b = 34;
    Py_ssize_t c = 56;

    if (!_PyArg_ParseStack(args, nargs, "|O&O&O&:test_slice_index_converter",
        _PyEval_SliceIndex, &a, _PyEval_SliceIndexNotNone, &b, _PyEval_SliceIndex, &c)) {
        goto exit;
    }
    return_value = test_slice_index_converter_impl(module, a, b, c);

exit:
    return return_value;
}

static PyObject *
test_slice_index_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b,
                                Py_ssize_t c)
/*[clinic end generated code: output=33b9152bf3c5963a input=edeadb0ee126f531]*/

/*[clinic input]
test_size_t_converter

    a: size_t = 12
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_size_t_converter__doc__,
"test_size_t_converter($module, a=12, /)\n"
"--\n"
"\n");

#define TEST_SIZE_T_CONVERTER_METHODDEF    \
    {"test_size_t_converter", (PyCFunction)(void(*)(void))test_size_t_converter, METH_FASTCALL, test_size_t_converter__doc__},

static PyObject *
test_size_t_converter_impl(PyObject *module, size_t a);

static PyObject *
test_size_t_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    size_t a = 12;

    if (!_PyArg_ParseStack(args, nargs, "|O&:test_size_t_converter",
        _PyLong_Size_t_Converter, &a)) {
        goto exit;
    }
    return_value = test_size_t_converter_impl(module, a);

exit:
    return return_value;
}

static PyObject *
test_size_t_converter_impl(PyObject *module, size_t a)
/*[clinic end generated code: output=02fe6bf4c5a139d5 input=52e93a0fed0f1fb3]*/

/*[clinic input]
test_float_converter

    a: float = 12.5
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_float_converter__doc__,
"test_float_converter($module, a=12.5, /)\n"
"--\n"
"\n");

#define TEST_FLOAT_CONVERTER_METHODDEF    \
    {"test_float_converter", (PyCFunction)(void(*)(void))test_float_converter, METH_FASTCALL, test_float_converter__doc__},

static PyObject *
test_float_converter_impl(PyObject *module, float a);

static PyObject *
test_float_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    float a = 12.5;

    if (!_PyArg_ParseStack(args, nargs, "|f:test_float_converter",
        &a)) {
        goto exit;
    }
    return_value = test_float_converter_impl(module, a);

exit:
    return return_value;
}

static PyObject *
test_float_converter_impl(PyObject *module, float a)
/*[clinic end generated code: output=a0689b5ee76673ad input=259c0d98eca35034]*/

/*[clinic input]
test_double_converter

    a: double = 12.5
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_double_converter__doc__,
"test_double_converter($module, a=12.5, /)\n"
"--\n"
"\n");

#define TEST_DOUBLE_CONVERTER_METHODDEF    \
    {"test_double_converter", (PyCFunction)(void(*)(void))test_double_converter, METH_FASTCALL, test_double_converter__doc__},

static PyObject *
test_double_converter_impl(PyObject *module, double a);

static PyObject *
test_double_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    double a = 12.5;

    if (!_PyArg_ParseStack(args, nargs, "|d:test_double_converter",
        &a)) {
        goto exit;
    }
    return_value = test_double_converter_impl(module, a);

exit:
    return return_value;
}

static PyObject *
test_double_converter_impl(PyObject *module, double a)
/*[clinic end generated code: output=b78d23bd37b40681 input=c6a9945706a41c27]*/

/*[clinic input]
test_Py_complex_converter

    a: Py_complex
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_Py_complex_converter__doc__,
"test_Py_complex_converter($module, a, /)\n"
"--\n"
"\n");

#define TEST_PY_COMPLEX_CONVERTER_METHODDEF    \
    {"test_Py_complex_converter", (PyCFunction)test_Py_complex_converter, METH_O, test_Py_complex_converter__doc__},

static PyObject *
test_Py_complex_converter_impl(PyObject *module, Py_complex a);

static PyObject *
test_Py_complex_converter(PyObject *module, PyObject *arg)
{
    PyObject *return_value = NULL;
    Py_complex a;

    a = PyComplex_AsCComplex(arg);
    if (PyErr_Occurred()) {
        goto exit;
    }
    return_value = test_Py_complex_converter_impl(module, a);

exit:
    return return_value;
}

static PyObject *
test_Py_complex_converter_impl(PyObject *module, Py_complex a)
/*[clinic end generated code: output=c2ecbec2144ca540 input=070f216a515beb79]*/

/*[clinic input]
test_str_converter

    a: str = NULL
    b: str = "ab"
    c: str(accept={str}) = "cd"
    d: str(accept={robuffer}) = "cef"
    e: str(accept={str, NoneType}) = "gh"
    f: str(accept={robuffer}, zeroes=True) = "ij"
    g: str(accept={robuffer, str}, zeroes=True) = "kl"
    h: str(accept={robuffer, str, NoneType}, zeroes=True) = "mn"
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_str_converter__doc__,
"test_str_converter($module, a=None, b=\'ab\', c=\'cd\', d=\'cef\', e=\'gh\',\n"
"                   f=\'ij\', g=\'kl\', h=\'mn\', /)\n"
"--\n"
"\n");

#define TEST_STR_CONVERTER_METHODDEF    \
    {"test_str_converter", (PyCFunction)(void(*)(void))test_str_converter, METH_FASTCALL, test_str_converter__doc__},

static PyObject *
test_str_converter_impl(PyObject *module, const char *a, const char *b,
                        const char *c, const char *d, const char *e,
                        const char *f, Py_ssize_clean_t f_length,
                        const char *g, Py_ssize_clean_t g_length,
                        const char *h, Py_ssize_clean_t h_length);

static PyObject *
test_str_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    const char *a = NULL;
    const char *b = "ab";
    const char *c = "cd";
    const char *d = "cef";
    const char *e = "gh";
    const char *f = "ij";
    Py_ssize_clean_t f_length;
    const char *g = "kl";
    Py_ssize_clean_t g_length;
    const char *h = "mn";
    Py_ssize_clean_t h_length;

    if (!_PyArg_ParseStack(args, nargs, "|sssyzy#s#z#:test_str_converter",
        &a, &b, &c, &d, &e, &f, &f_length, &g, &g_length, &h, &h_length)) {
        goto exit;
    }
    return_value = test_str_converter_impl(module, a, b, c, d, e, f, f_length, g, g_length, h, h_length);

exit:
    return return_value;
}

static PyObject *
test_str_converter_impl(PyObject *module, const char *a, const char *b,
                        const char *c, const char *d, const char *e,
                        const char *f, Py_ssize_clean_t f_length,
                        const char *g, Py_ssize_clean_t g_length,
                        const char *h, Py_ssize_clean_t h_length)
/*[clinic end generated code: output=8415d82c56154307 input=8afe9da8185cd38c]*/

/*[clinic input]
test_str_converter_encoding

    a: str(encoding="idna")
    b: str(encoding="idna", accept={str})
    c: str(encoding="idna", accept={bytes, bytearray, str})
    d: str(encoding="idna", zeroes=True)
    e: str(encoding="idna", accept={bytes, bytearray, str}, zeroes=True)
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_str_converter_encoding__doc__,
"test_str_converter_encoding($module, a, b, c, d, e, /)\n"
"--\n"
"\n");

#define TEST_STR_CONVERTER_ENCODING_METHODDEF    \
    {"test_str_converter_encoding", (PyCFunction)(void(*)(void))test_str_converter_encoding, METH_FASTCALL, test_str_converter_encoding__doc__},

static PyObject *
test_str_converter_encoding_impl(PyObject *module, char *a, char *b, char *c,
                                 char *d, Py_ssize_clean_t d_length, char *e,
                                 Py_ssize_clean_t e_length);

static PyObject *
test_str_converter_encoding(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    char *a = NULL;
    char *b = NULL;
    char *c = NULL;
    char *d = NULL;
    Py_ssize_clean_t d_length;
    char *e = NULL;
    Py_ssize_clean_t e_length;

    if (!_PyArg_ParseStack(args, nargs, "esesetes#et#:test_str_converter_encoding",
        "idna", &a, "idna", &b, "idna", &c, "idna", &d, &d_length, "idna", &e, &e_length)) {
        goto exit;
    }
    return_value = test_str_converter_encoding_impl(module, a, b, c, d, d_length, e, e_length);

exit:
    /* Cleanup for a */
    if (a) {
       PyMem_FREE(a);
    }
    /* Cleanup for b */
    if (b) {
       PyMem_FREE(b);
    }
    /* Cleanup for c */
    if (c) {
       PyMem_FREE(c);
    }
    /* Cleanup for d */
    if (d) {
       PyMem_FREE(d);
    }
    /* Cleanup for e */
    if (e) {
       PyMem_FREE(e);
    }

    return return_value;
}

static PyObject *
test_str_converter_encoding_impl(PyObject *module, char *a, char *b, char *c,
                                 char *d, Py_ssize_clean_t d_length, char *e,
                                 Py_ssize_clean_t e_length)
/*[clinic end generated code: output=f579dd9e795a364e input=eb4c38e1f898f402]*/

/*[clinic input]
test_Py_UNICODE_converter

    a: Py_UNICODE
    b: Py_UNICODE(accept={str})
    c: Py_UNICODE(accept={str, NoneType})
    d: Py_UNICODE(zeroes=True)
    e: Py_UNICODE(accept={str, NoneType}, zeroes=True)
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_Py_UNICODE_converter__doc__,
"test_Py_UNICODE_converter($module, a, b, c, d, e, /)\n"
"--\n"
"\n");

#define TEST_PY_UNICODE_CONVERTER_METHODDEF    \
    {"test_Py_UNICODE_converter", (PyCFunction)(void(*)(void))test_Py_UNICODE_converter, METH_FASTCALL, test_Py_UNICODE_converter__doc__},

static PyObject *
test_Py_UNICODE_converter_impl(PyObject *module, const Py_UNICODE *a,
                               const Py_UNICODE *b, const Py_UNICODE *c,
                               const Py_UNICODE *d,
                               Py_ssize_clean_t d_length,
                               const Py_UNICODE *e,
                               Py_ssize_clean_t e_length);

static PyObject *
test_Py_UNICODE_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    const Py_UNICODE *a;
    const Py_UNICODE *b;
    const Py_UNICODE *c;
    const Py_UNICODE *d;
    Py_ssize_clean_t d_length;
    const Py_UNICODE *e;
    Py_ssize_clean_t e_length;

    if (!_PyArg_ParseStack(args, nargs, "uuZu#Z#:test_Py_UNICODE_converter",
        &a, &b, &c, &d, &d_length, &e, &e_length)) {
        goto exit;
    }
    return_value = test_Py_UNICODE_converter_impl(module, a, b, c, d, d_length, e, e_length);

exit:
    return return_value;
}

static PyObject *
test_Py_UNICODE_converter_impl(PyObject *module, const Py_UNICODE *a,
                               const Py_UNICODE *b, const Py_UNICODE *c,
                               const Py_UNICODE *d,
                               Py_ssize_clean_t d_length,
                               const Py_UNICODE *e,
                               Py_ssize_clean_t e_length)
/*[clinic end generated code: output=dd0a09a1b772e57b input=064a3b68ad7f04b0]*/

/*[clinic input]
test_Py_buffer_converter

    a: Py_buffer
    b: Py_buffer(accept={buffer})
    c: Py_buffer(accept={str, buffer})
    d: Py_buffer(accept={str, buffer, NoneType})
    e: Py_buffer(accept={rwbuffer})
    /

[clinic start generated code]*/

PyDoc_STRVAR(test_Py_buffer_converter__doc__,
"test_Py_buffer_converter($module, a, b, c, d, e, /)\n"
"--\n"
"\n");

#define TEST_PY_BUFFER_CONVERTER_METHODDEF    \
    {"test_Py_buffer_converter", (PyCFunction)(void(*)(void))test_Py_buffer_converter, METH_FASTCALL, test_Py_buffer_converter__doc__},

static PyObject *
test_Py_buffer_converter_impl(PyObject *module, Py_buffer *a, Py_buffer *b,
                              Py_buffer *c, Py_buffer *d, Py_buffer *e);

static PyObject *
test_Py_buffer_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    Py_buffer a = {NULL, NULL};
    Py_buffer b = {NULL, NULL};
    Py_buffer c = {NULL, NULL};
    Py_buffer d = {NULL, NULL};
    Py_buffer e = {NULL, NULL};

    if (!_PyArg_ParseStack(args, nargs, "y*y*s*z*w*:test_Py_buffer_converter",
        &a, &b, &c, &d, &e)) {
        goto exit;
    }
    return_value = test_Py_buffer_converter_impl(module, &a, &b, &c, &d, &e);

exit:
    /* Cleanup for a */
    if (a.obj) {
       PyBuffer_Release(&a);
    }
    /* Cleanup for b */
    if (b.obj) {
       PyBuffer_Release(&b);
    }
    /* Cleanup for c */
    if (c.obj) {
       PyBuffer_Release(&c);
    }
    /* Cleanup for d */
    if (d.obj) {
       PyBuffer_Release(&d);
    }
    /* Cleanup for e */
    if (e.obj) {
       PyBuffer_Release(&e);
    }

    return return_value;
}

static PyObject *
test_Py_buffer_converter_impl(PyObject *module, Py_buffer *a, Py_buffer *b,
                              Py_buffer *c, Py_buffer *d, Py_buffer *e)
/*[clinic end generated code: output=5760c82faa2ed61f input=6a9da0f56f9525fd]*/