/*[clinic input]

output preset block

[clinic start generated code]*/

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

/*[clinic input]

class Test "TestObj *" "TestType"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=fc7e50384d12b83f]*/

/*[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_CAST(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_CheckPositional("test_object_converter", nargs, 4, 4)) {

goto exit;

}

a = args[0];

if (!PyUnicode_FSConverter(args[1], &b)) {

goto exit;

}

if (!PyUnicode_Check(args[2])) {

_PyArg_BadArgument("test_object_converter", "argument 3", "str", args[2]);

goto exit;

}

c = args[2];

d = (PyUnicode_Object *)args[3];

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=886f4f9b598726b6 input=005e6a8a711a869b]*/

/*[clinic input]

cloned = test_object_converter

Check the clone feature.

[clinic start generated code]*/

PyDoc_STRVAR(cloned__doc__,

"cloned($module, a, b, c, d, /)\n"

"--\n"

"\n"

"Check the clone feature.");

#define CLONED_METHODDEF \

{"cloned", _PyCFunction_CAST(cloned), METH_FASTCALL, cloned__doc__},

static PyObject *

cloned_impl(PyObject *module, PyObject *a, PyObject *b, PyObject *c,

PyUnicode_Object *d);

static PyObject *

cloned(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

PyObject *a;

PyObject *b;

PyObject *c;

PyUnicode_Object *d;

if (!_PyArg_CheckPositional("cloned", nargs, 4, 4)) {

goto exit;

}

a = args[0];

if (!PyUnicode_FSConverter(args[1], &b)) {

goto exit;

}

if (!PyUnicode_Check(args[2])) {

_PyArg_BadArgument("cloned", "argument 3", "str", args[2]);

goto exit;

}

c = args[2];

d = (PyUnicode_Object *)args[3];

return_value = cloned_impl(module, a, b, c, d);

exit:

return return_value;

}

static PyObject *

cloned_impl(PyObject *module, PyObject *a, PyObject *b, PyObject *c,

PyUnicode_Object *d)

/*[clinic end generated code: output=026b483e27c38065 input=0543614019d6fcc7]*/

/*[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=<unrepresentable>, /)\n"

"--\n"

"\n");

#define TEST_OBJECTS_CONVERTER_METHODDEF \

{"test_objects_converter", _PyCFunction_CAST(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_CheckPositional("test_objects_converter", nargs, 1, 2)) {

goto exit;

}

a = args[0];

if (nargs < 2) {

goto skip_optional;

}

b = args[1];

skip_optional:

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=fc26328b79d46bb7 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_CAST(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_CheckPositional("test_object_converter_subclass_of", nargs, 10, 10)) {

goto exit;

}

if (!PyLong_Check(args[0])) {

_PyArg_BadArgument("test_object_converter_subclass_of", "argument 1", "int", args[0]);

goto exit;

}

a = args[0];

if (!PyTuple_Check(args[1])) {

_PyArg_BadArgument("test_object_converter_subclass_of", "argument 2", "tuple", args[1]);

goto exit;

}

b = args[1];

if (!PyList_Check(args[2])) {

_PyArg_BadArgument("test_object_converter_subclass_of", "argument 3", "list", args[2]);

goto exit;

}

c = args[2];

if (!PySet_Check(args[3])) {

_PyArg_BadArgument("test_object_converter_subclass_of", "argument 4", "set", args[3]);

goto exit;

}

d = args[3];

if (!PyFrozenSet_Check(args[4])) {

_PyArg_BadArgument("test_object_converter_subclass_of", "argument 5", "frozenset", args[4]);

goto exit;

}

e = args[4];

if (!PyDict_Check(args[5])) {

_PyArg_BadArgument("test_object_converter_subclass_of", "argument 6", "dict", args[5]);

goto exit;

}

f = args[5];

if (!PyUnicode_Check(args[6])) {

_PyArg_BadArgument("test_object_converter_subclass_of", "argument 7", "str", args[6]);

goto exit;

}

g = args[6];

if (!PyBytes_Check(args[7])) {

_PyArg_BadArgument("test_object_converter_subclass_of", "argument 8", "bytes", args[7]);

goto exit;

}

h = args[7];

if (!PyByteArray_Check(args[8])) {

_PyArg_BadArgument("test_object_converter_subclass_of", "argument 9", "bytearray", args[8]);

goto exit;

}

i = args[8];

if (!PyObject_TypeCheck(args[9], &MyType)) {

_PyArg_BadArgument("test_object_converter_subclass_of", "argument 10", (&MyType)->tp_name, args[9]);

goto exit;

}

j = args[9];

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=e4b07c9a54479a40 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", "argument", "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=7539d628e6fceace 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", "argument", "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=1245af9f5b3e355e 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", "argument", "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=18f1e3880c862611 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_CAST(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_CheckPositional("test_bool_converter", nargs, 0, 3)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

a = PyObject_IsTrue(args[0]);

if (a < 0) {

goto exit;

}

if (nargs < 2) {

goto skip_optional;

}

b = PyObject_IsTrue(args[1]);

if (b < 0) {

goto exit;

}

if (nargs < 3) {

goto skip_optional;

}

c = _PyLong_AsInt(args[2]);

if (c == -1 && PyErr_Occurred()) {

goto exit;

}

skip_optional:

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=27f0e653a70b9be3 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_CAST(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_CheckPositional("test_char_converter", nargs, 0, 14)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

if (PyBytes_Check(args[0]) && PyBytes_GET_SIZE(args[0]) == 1) {

a = PyBytes_AS_STRING(args[0])[0];

}

else if (PyByteArray_Check(args[0]) && PyByteArray_GET_SIZE(args[0]) == 1) {

a = PyByteArray_AS_STRING(args[0])[0];

}

else {

_PyArg_BadArgument("test_char_converter", "argument 1", "a byte string of length 1", args[0]);

goto exit;

}

if (nargs < 2) {

goto skip_optional;

}

if (PyBytes_Check(args[1]) && PyBytes_GET_SIZE(args[1]) == 1) {

b = PyBytes_AS_STRING(args[1])[0];

}

else if (PyByteArray_Check(args[1]) && PyByteArray_GET_SIZE(args[1]) == 1) {

b = PyByteArray_AS_STRING(args[1])[0];

}

else {

_PyArg_BadArgument("test_char_converter", "argument 2", "a byte string of length 1", args[1]);

goto exit;

}

if (nargs < 3) {

goto skip_optional;

}

if (PyBytes_Check(args[2]) && PyBytes_GET_SIZE(args[2]) == 1) {

c = PyBytes_AS_STRING(args[2])[0];

}

else if (PyByteArray_Check(args[2]) && PyByteArray_GET_SIZE(args[2]) == 1) {

c = PyByteArray_AS_STRING(args[2])[0];

}

else {

_PyArg_BadArgument("test_char_converter", "argument 3", "a byte string of length 1", args[2]);

goto exit;

}

if (nargs < 4) {

goto skip_optional;

}

if (PyBytes_Check(args[3]) && PyBytes_GET_SIZE(args[3]) == 1) {

d = PyBytes_AS_STRING(args[3])[0];

}

else if (PyByteArray_Check(args[3]) && PyByteArray_GET_SIZE(args[3]) == 1) {

d = PyByteArray_AS_STRING(args[3])[0];

}

else {

_PyArg_BadArgument("test_char_converter", "argument 4", "a byte string of length 1", args[3]);

goto exit;

}

if (nargs < 5) {

goto skip_optional;

}

if (PyBytes_Check(args[4]) && PyBytes_GET_SIZE(args[4]) == 1) {

e = PyBytes_AS_STRING(args[4])[0];

}

else if (PyByteArray_Check(args[4]) && PyByteArray_GET_SIZE(args[4]) == 1) {

e = PyByteArray_AS_STRING(args[4])[0];

}

else {

_PyArg_BadArgument("test_char_converter", "argument 5", "a byte string of length 1", args[4]);

goto exit;

}

if (nargs < 6) {

goto skip_optional;

}

if (PyBytes_Check(args[5]) && PyBytes_GET_SIZE(args[5]) == 1) {

f = PyBytes_AS_STRING(args[5])[0];

}

else if (PyByteArray_Check(args[5]) && PyByteArray_GET_SIZE(args[5]) == 1) {

f = PyByteArray_AS_STRING(args[5])[0];

}

else {

_PyArg_BadArgument("test_char_converter", "argument 6", "a byte string of length 1", args[5]);

goto exit;

}

if (nargs < 7) {

goto skip_optional;

}

if (PyBytes_Check(args[6]) && PyBytes_GET_SIZE(args[6]) == 1) {

g = PyBytes_AS_STRING(args[6])[0];

}

else if (PyByteArray_Check(args[6]) && PyByteArray_GET_SIZE(args[6]) == 1) {

g = PyByteArray_AS_STRING(args[6])[0];

}

else {

_PyArg_BadArgument("test_char_converter", "argument 7", "a byte string of length 1", args[6]);

goto exit;

}

if (nargs < 8) {

goto skip_optional;

}

if (PyBytes_Check(args[7]) && PyBytes_GET_SIZE(args[7]) == 1) {

h = PyBytes_AS_STRING(args[7])[0];

}

else if (PyByteArray_Check(args[7]) && PyByteArray_GET_SIZE(args[7]) == 1) {

h = PyByteArray_AS_STRING(args[7])[0];

}

else {

_PyArg_BadArgument("test_char_converter", "argument 8", "a byte string of length 1", args[7]);

goto exit;

}

if (nargs < 9) {

goto skip_optional;

}

if (PyBytes_Check(args[8]) && PyBytes_GET_SIZE(args[8]) == 1) {

i = PyBytes_AS_STRING(args[8])[0];

}

else if (PyByteArray_Check(args[8]) && PyByteArray_GET_SIZE(args[8]) == 1) {

i = PyByteArray_AS_STRING(args[8])[0];

}

else {

_PyArg_BadArgument("test_char_converter", "argument 9", "a byte string of length 1", args[8]);

goto exit;

}

if (nargs < 10) {

goto skip_optional;

}

if (PyBytes_Check(args[9]) && PyBytes_GET_SIZE(args[9]) == 1) {

j = PyBytes_AS_STRING(args[9])[0];

}

else if (PyByteArray_Check(args[9]) && PyByteArray_GET_SIZE(args[9]) == 1) {

j = PyByteArray_AS_STRING(args[9])[0];

}

else {

_PyArg_BadArgument("test_char_converter", "argument 10", "a byte string of length 1", args[9]);

goto exit;

}

if (nargs < 11) {

goto skip_optional;

}

if (PyBytes_Check(args[10]) && PyBytes_GET_SIZE(args[10]) == 1) {

k = PyBytes_AS_STRING(args[10])[0];

}

else if (PyByteArray_Check(args[10]) && PyByteArray_GET_SIZE(args[10]) == 1) {

k = PyByteArray_AS_STRING(args[10])[0];

}

else {

_PyArg_BadArgument("test_char_converter", "argument 11", "a byte string of length 1", args[10]);

goto exit;

}

if (nargs < 12) {

goto skip_optional;

}

if (PyBytes_Check(args[11]) && PyBytes_GET_SIZE(args[11]) == 1) {

l = PyBytes_AS_STRING(args[11])[0];

}

else if (PyByteArray_Check(args[11]) && PyByteArray_GET_SIZE(args[11]) == 1) {

l = PyByteArray_AS_STRING(args[11])[0];

}

else {

_PyArg_BadArgument("test_char_converter", "argument 12", "a byte string of length 1", args[11]);

goto exit;

}

if (nargs < 13) {

goto skip_optional;

}

if (PyBytes_Check(args[12]) && PyBytes_GET_SIZE(args[12]) == 1) {

m = PyBytes_AS_STRING(args[12])[0];

}

else if (PyByteArray_Check(args[12]) && PyByteArray_GET_SIZE(args[12]) == 1) {

m = PyByteArray_AS_STRING(args[12])[0];

}

else {

_PyArg_BadArgument("test_char_converter", "argument 13", "a byte string of length 1", args[12]);

goto exit;

}

if (nargs < 14) {

goto skip_optional;

}

if (PyBytes_Check(args[13]) && PyBytes_GET_SIZE(args[13]) == 1) {

n = PyBytes_AS_STRING(args[13])[0];

}

else if (PyByteArray_Check(args[13]) && PyByteArray_GET_SIZE(args[13]) == 1) {

n = PyByteArray_AS_STRING(args[13])[0];

}

else {

_PyArg_BadArgument("test_char_converter", "argument 14", "a byte string of length 1", args[13]);

goto exit;

}

skip_optional:

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=98589f02422fe6b1 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_CAST(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_CheckPositional("test_unsigned_char_converter", nargs, 0, 3)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

{

long ival = PyLong_AsLong(args[0]);

if (ival == -1 && PyErr_Occurred()) {

goto exit;

}

else if (ival < 0) {

PyErr_SetString(PyExc_OverflowError,

"unsigned byte integer is less than minimum");

goto exit;

}

else if (ival > UCHAR_MAX) {

PyErr_SetString(PyExc_OverflowError,

"unsigned byte integer is greater than maximum");

goto exit;

}

else {

a = (unsigned char) ival;

}

}

if (nargs < 2) {

goto skip_optional;

}

{

long ival = PyLong_AsLong(args[1]);

if (ival == -1 && PyErr_Occurred()) {

goto exit;

}

else if (ival < 0) {

PyErr_SetString(PyExc_OverflowError,

"unsigned byte integer is less than minimum");

goto exit;

}

else if (ival > UCHAR_MAX) {

PyErr_SetString(PyExc_OverflowError,

"unsigned byte integer is greater than maximum");

goto exit;

}

else {

b = (unsigned char) ival;

}

}

if (nargs < 3) {

goto skip_optional;

}

{

unsigned long ival = PyLong_AsUnsignedLongMask(args[2]);

if (ival == (unsigned long)-1 && PyErr_Occurred()) {

goto exit;

}

else {

c = (unsigned char) ival;

}

}

skip_optional:

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=45920dbedc22eb55 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_CAST(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_CheckPositional("test_short_converter", nargs, 0, 1)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

{

long ival = PyLong_AsLong(args[0]);

if (ival == -1 && PyErr_Occurred()) {

goto exit;

}

else if (ival < SHRT_MIN) {

PyErr_SetString(PyExc_OverflowError,

"signed short integer is less than minimum");

goto exit;

}

else if (ival > SHRT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"signed short integer is greater than maximum");

goto exit;

}

else {

a = (short) ival;

}

}

skip_optional:

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=a580945bd6963d45 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_CAST(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_CheckPositional("test_unsigned_short_converter", nargs, 0, 3)) {

goto exit;

}

if (nargs < 1) {

goto skip_optional;

}

if (!_PyLong_UnsignedShort_Converter(args[0], &a)) {

goto exit;

}

if (nargs < 2) {

goto skip_optional;

}

if (!_PyLong_UnsignedShort_Converter(args[1], &b)) {

goto exit;

}

if (nargs < 3) {

goto skip_optional;

}

c = (unsigned short)PyLong_AsUnsignedLongMask(args[2]);

if (c == (unsigned short)-1 && PyErr_Occurred()) {

goto exit;

}

skip_optional:

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=e6e990df729114fc 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_CAST(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)

{