[Python-checkins] gh-96002: Add functional test for Argument Clinic (#96178)
erlend-aasland
webhook-mailer at python.org
Mon Nov 21 09:09:16 EST 2022
https://github.com/python/cpython/commit/c450c8c9ed6e420025f39d0e4850a79f8160cdcd
commit: c450c8c9ed6e420025f39d0e4850a79f8160cdcd
branch: main
author: colorfulappl <colorfulappl at qq.com>
committer: erlend-aasland <erlend.aasland at protonmail.com>
date: 2022-11-21T15:08:45+01:00
summary:
gh-96002: Add functional test for Argument Clinic (#96178)
Co-authored-by: Kumar Aditya <59607654+kumaraditya303 at users.noreply.github.com>
Co-authored-by: Erlend E. Aasland <erlend.aasland at protonmail.com>
files:
A Misc/NEWS.d/next/Tests/2022-08-22-15-49-14.gh-issue-96002.4UE9UE.rst
A Modules/_testclinic.c
A Modules/clinic/_testclinic.c.h
M Include/internal/pycore_global_objects_fini_generated.h
M Include/internal/pycore_global_strings.h
M Include/internal/pycore_runtime_init_generated.h
M Include/internal/pycore_unicodeobject_generated.h
M Lib/test/test_clinic.py
M Modules/Setup.stdlib.in
M Tools/build/generate_stdlib_module_names.py
M configure
M configure.ac
diff --git a/Include/internal/pycore_global_objects_fini_generated.h b/Include/internal/pycore_global_objects_fini_generated.h
index 381f166ca582..494bcf293cdb 100644
--- a/Include/internal/pycore_global_objects_fini_generated.h
+++ b/Include/internal/pycore_global_objects_fini_generated.h
@@ -801,6 +801,7 @@ _PyStaticObjects_CheckRefcnt(PyInterpreterState *interp) {
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(byteorder));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(bytes));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(bytes_per_sep));
+ _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(c));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(c_call));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(c_exception));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(c_return));
@@ -850,6 +851,7 @@ _PyStaticObjects_CheckRefcnt(PyInterpreterState *interp) {
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(coro));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(count));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(cwd));
+ _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(d));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(data));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(database));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(decode));
@@ -877,6 +879,7 @@ _PyStaticObjects_CheckRefcnt(PyInterpreterState *interp) {
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(dst));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(dst_dir_fd));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(duration));
+ _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(e));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(effective_ids));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(element_factory));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(encode));
diff --git a/Include/internal/pycore_global_strings.h b/Include/internal/pycore_global_strings.h
index b2b0dc6c51e9..b0cb8365933e 100644
--- a/Include/internal/pycore_global_strings.h
+++ b/Include/internal/pycore_global_strings.h
@@ -287,6 +287,7 @@ struct _Py_global_strings {
STRUCT_FOR_ID(byteorder)
STRUCT_FOR_ID(bytes)
STRUCT_FOR_ID(bytes_per_sep)
+ STRUCT_FOR_ID(c)
STRUCT_FOR_ID(c_call)
STRUCT_FOR_ID(c_exception)
STRUCT_FOR_ID(c_return)
@@ -336,6 +337,7 @@ struct _Py_global_strings {
STRUCT_FOR_ID(coro)
STRUCT_FOR_ID(count)
STRUCT_FOR_ID(cwd)
+ STRUCT_FOR_ID(d)
STRUCT_FOR_ID(data)
STRUCT_FOR_ID(database)
STRUCT_FOR_ID(decode)
@@ -363,6 +365,7 @@ struct _Py_global_strings {
STRUCT_FOR_ID(dst)
STRUCT_FOR_ID(dst_dir_fd)
STRUCT_FOR_ID(duration)
+ STRUCT_FOR_ID(e)
STRUCT_FOR_ID(effective_ids)
STRUCT_FOR_ID(element_factory)
STRUCT_FOR_ID(encode)
diff --git a/Include/internal/pycore_runtime_init_generated.h b/Include/internal/pycore_runtime_init_generated.h
index 859e67624908..4b128da54555 100644
--- a/Include/internal/pycore_runtime_init_generated.h
+++ b/Include/internal/pycore_runtime_init_generated.h
@@ -793,6 +793,7 @@ extern "C" {
INIT_ID(byteorder), \
INIT_ID(bytes), \
INIT_ID(bytes_per_sep), \
+ INIT_ID(c), \
INIT_ID(c_call), \
INIT_ID(c_exception), \
INIT_ID(c_return), \
@@ -842,6 +843,7 @@ extern "C" {
INIT_ID(coro), \
INIT_ID(count), \
INIT_ID(cwd), \
+ INIT_ID(d), \
INIT_ID(data), \
INIT_ID(database), \
INIT_ID(decode), \
@@ -869,6 +871,7 @@ extern "C" {
INIT_ID(dst), \
INIT_ID(dst_dir_fd), \
INIT_ID(duration), \
+ INIT_ID(e), \
INIT_ID(effective_ids), \
INIT_ID(element_factory), \
INIT_ID(encode), \
diff --git a/Include/internal/pycore_unicodeobject_generated.h b/Include/internal/pycore_unicodeobject_generated.h
index abff03ffe27b..7ef1f7e94dde 100644
--- a/Include/internal/pycore_unicodeobject_generated.h
+++ b/Include/internal/pycore_unicodeobject_generated.h
@@ -480,6 +480,8 @@ _PyUnicode_InitStaticStrings(void) {
PyUnicode_InternInPlace(&string);
string = &_Py_ID(bytes_per_sep);
PyUnicode_InternInPlace(&string);
+ string = &_Py_ID(c);
+ PyUnicode_InternInPlace(&string);
string = &_Py_ID(c_call);
PyUnicode_InternInPlace(&string);
string = &_Py_ID(c_exception);
@@ -578,6 +580,8 @@ _PyUnicode_InitStaticStrings(void) {
PyUnicode_InternInPlace(&string);
string = &_Py_ID(cwd);
PyUnicode_InternInPlace(&string);
+ string = &_Py_ID(d);
+ PyUnicode_InternInPlace(&string);
string = &_Py_ID(data);
PyUnicode_InternInPlace(&string);
string = &_Py_ID(database);
@@ -632,6 +636,8 @@ _PyUnicode_InitStaticStrings(void) {
PyUnicode_InternInPlace(&string);
string = &_Py_ID(duration);
PyUnicode_InternInPlace(&string);
+ string = &_Py_ID(e);
+ PyUnicode_InternInPlace(&string);
string = &_Py_ID(effective_ids);
PyUnicode_InternInPlace(&string);
string = &_Py_ID(element_factory);
diff --git a/Lib/test/test_clinic.py b/Lib/test/test_clinic.py
index 8ab40c694f71..7c1bd1c10d2a 100644
--- a/Lib/test/test_clinic.py
+++ b/Lib/test/test_clinic.py
@@ -3,7 +3,7 @@
# Licensed to the PSF under a contributor agreement.
from test import support, test_tools
-from test.support import os_helper
+from test.support import import_helper, os_helper
from unittest import TestCase
import collections
import inspect
@@ -820,5 +820,397 @@ def test_external(self):
self.assertEqual(new_mtime_ns, old_mtime_ns)
+ac_tester = import_helper.import_module('_testclinic')
+
+
+class ClinicFunctionalTest(unittest.TestCase):
+ locals().update((name, getattr(ac_tester, name))
+ for name in dir(ac_tester) if name.startswith('test_'))
+
+ def test_objects_converter(self):
+ with self.assertRaises(TypeError):
+ ac_tester.objects_converter()
+ self.assertEqual(ac_tester.objects_converter(1, 2), (1, 2))
+ self.assertEqual(ac_tester.objects_converter([], 'whatever class'), ([], 'whatever class'))
+ self.assertEqual(ac_tester.objects_converter(1), (1, None))
+
+ def test_bytes_object_converter(self):
+ with self.assertRaises(TypeError):
+ ac_tester.bytes_object_converter(1)
+ self.assertEqual(ac_tester.bytes_object_converter(b'BytesObject'), (b'BytesObject',))
+
+ def test_byte_array_object_converter(self):
+ with self.assertRaises(TypeError):
+ ac_tester.byte_array_object_converter(1)
+ byte_arr = bytearray(b'ByteArrayObject')
+ self.assertEqual(ac_tester.byte_array_object_converter(byte_arr), (byte_arr,))
+
+ def test_unicode_converter(self):
+ with self.assertRaises(TypeError):
+ ac_tester.unicode_converter(1)
+ self.assertEqual(ac_tester.unicode_converter('unicode'), ('unicode',))
+
+ def test_bool_converter(self):
+ with self.assertRaises(TypeError):
+ ac_tester.bool_converter(False, False, 'not a int')
+ self.assertEqual(ac_tester.bool_converter(), (True, True, True))
+ self.assertEqual(ac_tester.bool_converter('', [], 5), (False, False, True))
+ self.assertEqual(ac_tester.bool_converter(('not empty',), {1: 2}, 0), (True, True, False))
+
+ def test_char_converter(self):
+ with self.assertRaises(TypeError):
+ ac_tester.char_converter(1)
+ with self.assertRaises(TypeError):
+ ac_tester.char_converter(b'ab')
+ chars = [b'A', b'\a', b'\b', b'\t', b'\n', b'\v', b'\f', b'\r', b'"', b"'", b'?', b'\\', b'\000', b'\377']
+ expected = tuple(ord(c) for c in chars)
+ self.assertEqual(ac_tester.char_converter(), expected)
+ chars = [b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'0', b'a', b'b', b'c', b'd']
+ expected = tuple(ord(c) for c in chars)
+ self.assertEqual(ac_tester.char_converter(*chars), expected)
+
+ def test_unsigned_char_converter(self):
+ from _testcapi import UCHAR_MAX
+ with self.assertRaises(OverflowError):
+ ac_tester.unsigned_char_converter(-1)
+ with self.assertRaises(OverflowError):
+ ac_tester.unsigned_char_converter(UCHAR_MAX + 1)
+ with self.assertRaises(OverflowError):
+ ac_tester.unsigned_char_converter(0, UCHAR_MAX + 1)
+ with self.assertRaises(TypeError):
+ ac_tester.unsigned_char_converter([])
+ self.assertEqual(ac_tester.unsigned_char_converter(), (12, 34, 56))
+ self.assertEqual(ac_tester.unsigned_char_converter(0, 0, UCHAR_MAX + 1), (0, 0, 0))
+ self.assertEqual(ac_tester.unsigned_char_converter(0, 0, (UCHAR_MAX + 1) * 3 + 123), (0, 0, 123))
+
+ def test_short_converter(self):
+ from _testcapi import SHRT_MIN, SHRT_MAX
+ with self.assertRaises(OverflowError):
+ ac_tester.short_converter(SHRT_MIN - 1)
+ with self.assertRaises(OverflowError):
+ ac_tester.short_converter(SHRT_MAX + 1)
+ with self.assertRaises(TypeError):
+ ac_tester.short_converter([])
+ self.assertEqual(ac_tester.short_converter(-1234), (-1234,))
+ self.assertEqual(ac_tester.short_converter(4321), (4321,))
+
+ def test_unsigned_short_converter(self):
+ from _testcapi import USHRT_MAX
+ with self.assertRaises(ValueError):
+ ac_tester.unsigned_short_converter(-1)
+ with self.assertRaises(OverflowError):
+ ac_tester.unsigned_short_converter(USHRT_MAX + 1)
+ with self.assertRaises(OverflowError):
+ ac_tester.unsigned_short_converter(0, USHRT_MAX + 1)
+ with self.assertRaises(TypeError):
+ ac_tester.unsigned_short_converter([])
+ self.assertEqual(ac_tester.unsigned_short_converter(), (12, 34, 56))
+ self.assertEqual(ac_tester.unsigned_short_converter(0, 0, USHRT_MAX + 1), (0, 0, 0))
+ self.assertEqual(ac_tester.unsigned_short_converter(0, 0, (USHRT_MAX + 1) * 3 + 123), (0, 0, 123))
+
+ def test_int_converter(self):
+ from _testcapi import INT_MIN, INT_MAX
+ with self.assertRaises(OverflowError):
+ ac_tester.int_converter(INT_MIN - 1)
+ with self.assertRaises(OverflowError):
+ ac_tester.int_converter(INT_MAX + 1)
+ with self.assertRaises(TypeError):
+ ac_tester.int_converter(1, 2, 3)
+ with self.assertRaises(TypeError):
+ ac_tester.int_converter([])
+ self.assertEqual(ac_tester.int_converter(), (12, 34, 45))
+ self.assertEqual(ac_tester.int_converter(1, 2, '3'), (1, 2, ord('3')))
+
+ def test_unsigned_int_converter(self):
+ from _testcapi import UINT_MAX
+ with self.assertRaises(ValueError):
+ ac_tester.unsigned_int_converter(-1)
+ with self.assertRaises(OverflowError):
+ ac_tester.unsigned_int_converter(UINT_MAX + 1)
+ with self.assertRaises(OverflowError):
+ ac_tester.unsigned_int_converter(0, UINT_MAX + 1)
+ with self.assertRaises(TypeError):
+ ac_tester.unsigned_int_converter([])
+ self.assertEqual(ac_tester.unsigned_int_converter(), (12, 34, 56))
+ self.assertEqual(ac_tester.unsigned_int_converter(0, 0, UINT_MAX + 1), (0, 0, 0))
+ self.assertEqual(ac_tester.unsigned_int_converter(0, 0, (UINT_MAX + 1) * 3 + 123), (0, 0, 123))
+
+ def test_long_converter(self):
+ from _testcapi import LONG_MIN, LONG_MAX
+ with self.assertRaises(OverflowError):
+ ac_tester.long_converter(LONG_MIN - 1)
+ with self.assertRaises(OverflowError):
+ ac_tester.long_converter(LONG_MAX + 1)
+ with self.assertRaises(TypeError):
+ ac_tester.long_converter([])
+ self.assertEqual(ac_tester.long_converter(), (12,))
+ self.assertEqual(ac_tester.long_converter(-1234), (-1234,))
+
+ def test_unsigned_long_converter(self):
+ from _testcapi import ULONG_MAX
+ with self.assertRaises(ValueError):
+ ac_tester.unsigned_long_converter(-1)
+ with self.assertRaises(OverflowError):
+ ac_tester.unsigned_long_converter(ULONG_MAX + 1)
+ with self.assertRaises(OverflowError):
+ ac_tester.unsigned_long_converter(0, ULONG_MAX + 1)
+ with self.assertRaises(TypeError):
+ ac_tester.unsigned_long_converter([])
+ self.assertEqual(ac_tester.unsigned_long_converter(), (12, 34, 56))
+ self.assertEqual(ac_tester.unsigned_long_converter(0, 0, ULONG_MAX + 1), (0, 0, 0))
+ self.assertEqual(ac_tester.unsigned_long_converter(0, 0, (ULONG_MAX + 1) * 3 + 123), (0, 0, 123))
+
+ def test_long_long_converter(self):
+ from _testcapi import LLONG_MIN, LLONG_MAX
+ with self.assertRaises(OverflowError):
+ ac_tester.long_long_converter(LLONG_MIN - 1)
+ with self.assertRaises(OverflowError):
+ ac_tester.long_long_converter(LLONG_MAX + 1)
+ with self.assertRaises(TypeError):
+ ac_tester.long_long_converter([])
+ self.assertEqual(ac_tester.long_long_converter(), (12,))
+ self.assertEqual(ac_tester.long_long_converter(-1234), (-1234,))
+
+ def test_unsigned_long_long_converter(self):
+ from _testcapi import ULLONG_MAX
+ with self.assertRaises(ValueError):
+ ac_tester.unsigned_long_long_converter(-1)
+ with self.assertRaises(OverflowError):
+ ac_tester.unsigned_long_long_converter(ULLONG_MAX + 1)
+ with self.assertRaises(OverflowError):
+ ac_tester.unsigned_long_long_converter(0, ULLONG_MAX + 1)
+ with self.assertRaises(TypeError):
+ ac_tester.unsigned_long_long_converter([])
+ self.assertEqual(ac_tester.unsigned_long_long_converter(), (12, 34, 56))
+ self.assertEqual(ac_tester.unsigned_long_long_converter(0, 0, ULLONG_MAX + 1), (0, 0, 0))
+ self.assertEqual(ac_tester.unsigned_long_long_converter(0, 0, (ULLONG_MAX + 1) * 3 + 123), (0, 0, 123))
+
+ def test_py_ssize_t_converter(self):
+ from _testcapi import PY_SSIZE_T_MIN, PY_SSIZE_T_MAX
+ with self.assertRaises(OverflowError):
+ ac_tester.py_ssize_t_converter(PY_SSIZE_T_MIN - 1)
+ with self.assertRaises(OverflowError):
+ ac_tester.py_ssize_t_converter(PY_SSIZE_T_MAX + 1)
+ with self.assertRaises(TypeError):
+ ac_tester.py_ssize_t_converter([])
+ self.assertEqual(ac_tester.py_ssize_t_converter(), (12, 34, 56))
+ self.assertEqual(ac_tester.py_ssize_t_converter(1, 2, None), (1, 2, 56))
+
+ def test_slice_index_converter(self):
+ from _testcapi import PY_SSIZE_T_MIN, PY_SSIZE_T_MAX
+ with self.assertRaises(TypeError):
+ ac_tester.slice_index_converter([])
+ self.assertEqual(ac_tester.slice_index_converter(), (12, 34, 56))
+ self.assertEqual(ac_tester.slice_index_converter(1, 2, None), (1, 2, 56))
+ self.assertEqual(ac_tester.slice_index_converter(PY_SSIZE_T_MAX, PY_SSIZE_T_MAX + 1, PY_SSIZE_T_MAX + 1234),
+ (PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX))
+ self.assertEqual(ac_tester.slice_index_converter(PY_SSIZE_T_MIN, PY_SSIZE_T_MIN - 1, PY_SSIZE_T_MIN - 1234),
+ (PY_SSIZE_T_MIN, PY_SSIZE_T_MIN, PY_SSIZE_T_MIN))
+
+ def test_size_t_converter(self):
+ with self.assertRaises(ValueError):
+ ac_tester.size_t_converter(-1)
+ with self.assertRaises(TypeError):
+ ac_tester.size_t_converter([])
+ self.assertEqual(ac_tester.size_t_converter(), (12,))
+
+ def test_float_converter(self):
+ with self.assertRaises(TypeError):
+ ac_tester.float_converter([])
+ self.assertEqual(ac_tester.float_converter(), (12.5,))
+ self.assertEqual(ac_tester.float_converter(-0.5), (-0.5,))
+
+ def test_double_converter(self):
+ with self.assertRaises(TypeError):
+ ac_tester.double_converter([])
+ self.assertEqual(ac_tester.double_converter(), (12.5,))
+ self.assertEqual(ac_tester.double_converter(-0.5), (-0.5,))
+
+ def test_py_complex_converter(self):
+ with self.assertRaises(TypeError):
+ ac_tester.py_complex_converter([])
+ self.assertEqual(ac_tester.py_complex_converter(complex(1, 2)), (complex(1, 2),))
+ self.assertEqual(ac_tester.py_complex_converter(complex('-1-2j')), (complex('-1-2j'),))
+ self.assertEqual(ac_tester.py_complex_converter(-0.5), (-0.5,))
+ self.assertEqual(ac_tester.py_complex_converter(10), (10,))
+
+ def test_str_converter(self):
+ with self.assertRaises(TypeError):
+ ac_tester.str_converter(1)
+ with self.assertRaises(TypeError):
+ ac_tester.str_converter('a', 'b', 'c')
+ with self.assertRaises(ValueError):
+ ac_tester.str_converter('a', b'b\0b', 'c')
+ self.assertEqual(ac_tester.str_converter('a', b'b', 'c'), ('a', 'b', 'c'))
+ self.assertEqual(ac_tester.str_converter('a', b'b', b'c'), ('a', 'b', 'c'))
+ self.assertEqual(ac_tester.str_converter('a', b'b', 'c\0c'), ('a', 'b', 'c\0c'))
+
+ def test_py_buffer_converter(self):
+ with self.assertRaises(TypeError):
+ ac_tester.py_buffer_converter('a', 'b')
+ self.assertEqual(ac_tester.py_buffer_converter('abc', bytearray([1, 2, 3])), (b'abc', b'\x01\x02\x03'))
+
+ def test_keywords(self):
+ self.assertEqual(ac_tester.keywords(1, 2), (1, 2))
+ self.assertEqual(ac_tester.keywords(1, b=2), (1, 2))
+ self.assertEqual(ac_tester.keywords(a=1, b=2), (1, 2))
+
+ def test_keywords_kwonly(self):
+ with self.assertRaises(TypeError):
+ ac_tester.keywords_kwonly(1, 2)
+ self.assertEqual(ac_tester.keywords_kwonly(1, b=2), (1, 2))
+ self.assertEqual(ac_tester.keywords_kwonly(a=1, b=2), (1, 2))
+
+ def test_keywords_opt(self):
+ self.assertEqual(ac_tester.keywords_opt(1), (1, None, None))
+ self.assertEqual(ac_tester.keywords_opt(1, 2), (1, 2, None))
+ self.assertEqual(ac_tester.keywords_opt(1, 2, 3), (1, 2, 3))
+ self.assertEqual(ac_tester.keywords_opt(1, b=2), (1, 2, None))
+ self.assertEqual(ac_tester.keywords_opt(1, 2, c=3), (1, 2, 3))
+ self.assertEqual(ac_tester.keywords_opt(a=1, c=3), (1, None, 3))
+ self.assertEqual(ac_tester.keywords_opt(a=1, b=2, c=3), (1, 2, 3))
+
+ def test_keywords_opt_kwonly(self):
+ self.assertEqual(ac_tester.keywords_opt_kwonly(1), (1, None, None, None))
+ self.assertEqual(ac_tester.keywords_opt_kwonly(1, 2), (1, 2, None, None))
+ with self.assertRaises(TypeError):
+ ac_tester.keywords_opt_kwonly(1, 2, 3)
+ self.assertEqual(ac_tester.keywords_opt_kwonly(1, b=2), (1, 2, None, None))
+ self.assertEqual(ac_tester.keywords_opt_kwonly(1, 2, c=3), (1, 2, 3, None))
+ self.assertEqual(ac_tester.keywords_opt_kwonly(a=1, c=3), (1, None, 3, None))
+ self.assertEqual(ac_tester.keywords_opt_kwonly(a=1, b=2, c=3, d=4), (1, 2, 3, 4))
+
+ def test_keywords_kwonly_opt(self):
+ self.assertEqual(ac_tester.keywords_kwonly_opt(1), (1, None, None))
+ with self.assertRaises(TypeError):
+ ac_tester.keywords_kwonly_opt(1, 2)
+ self.assertEqual(ac_tester.keywords_kwonly_opt(1, b=2), (1, 2, None))
+ self.assertEqual(ac_tester.keywords_kwonly_opt(a=1, c=3), (1, None, 3))
+ self.assertEqual(ac_tester.keywords_kwonly_opt(a=1, b=2, c=3), (1, 2, 3))
+
+ def test_posonly_keywords(self):
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_keywords(1)
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_keywords(a=1, b=2)
+ self.assertEqual(ac_tester.posonly_keywords(1, 2), (1, 2))
+ self.assertEqual(ac_tester.posonly_keywords(1, b=2), (1, 2))
+
+ def test_posonly_kwonly(self):
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_kwonly(1)
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_kwonly(1, 2)
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_kwonly(a=1, b=2)
+ self.assertEqual(ac_tester.posonly_kwonly(1, b=2), (1, 2))
+
+ def test_posonly_keywords_kwonly(self):
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_keywords_kwonly(1)
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_keywords_kwonly(1, 2, 3)
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_keywords_kwonly(a=1, b=2, c=3)
+ self.assertEqual(ac_tester.posonly_keywords_kwonly(1, 2, c=3), (1, 2, 3))
+ self.assertEqual(ac_tester.posonly_keywords_kwonly(1, b=2, c=3), (1, 2, 3))
+
+ def test_posonly_keywords_opt(self):
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_keywords_opt(1)
+ self.assertEqual(ac_tester.posonly_keywords_opt(1, 2), (1, 2, None, None))
+ self.assertEqual(ac_tester.posonly_keywords_opt(1, 2, 3), (1, 2, 3, None))
+ self.assertEqual(ac_tester.posonly_keywords_opt(1, 2, 3, 4), (1, 2, 3, 4))
+ self.assertEqual(ac_tester.posonly_keywords_opt(1, b=2), (1, 2, None, None))
+ self.assertEqual(ac_tester.posonly_keywords_opt(1, 2, c=3), (1, 2, 3, None))
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_keywords_opt(a=1, b=2, c=3, d=4)
+ self.assertEqual(ac_tester.posonly_keywords_opt(1, b=2, c=3, d=4), (1, 2, 3, 4))
+
+ def test_posonly_opt_keywords_opt(self):
+ self.assertEqual(ac_tester.posonly_opt_keywords_opt(1), (1, None, None, None))
+ self.assertEqual(ac_tester.posonly_opt_keywords_opt(1, 2), (1, 2, None, None))
+ self.assertEqual(ac_tester.posonly_opt_keywords_opt(1, 2, 3), (1, 2, 3, None))
+ self.assertEqual(ac_tester.posonly_opt_keywords_opt(1, 2, 3, 4), (1, 2, 3, 4))
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_opt_keywords_opt(1, b=2)
+ self.assertEqual(ac_tester.posonly_opt_keywords_opt(1, 2, c=3), (1, 2, 3, None))
+ self.assertEqual(ac_tester.posonly_opt_keywords_opt(1, 2, c=3, d=4), (1, 2, 3, 4))
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_opt_keywords_opt(a=1, b=2, c=3, d=4)
+
+ def test_posonly_kwonly_opt(self):
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_kwonly_opt(1)
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_kwonly_opt(1, 2)
+ self.assertEqual(ac_tester.posonly_kwonly_opt(1, b=2), (1, 2, None, None))
+ self.assertEqual(ac_tester.posonly_kwonly_opt(1, b=2, c=3), (1, 2, 3, None))
+ self.assertEqual(ac_tester.posonly_kwonly_opt(1, b=2, c=3, d=4), (1, 2, 3, 4))
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_kwonly_opt(a=1, b=2, c=3, d=4)
+
+ def test_posonly_opt_kwonly_opt(self):
+ self.assertEqual(ac_tester.posonly_opt_kwonly_opt(1), (1, None, None, None))
+ self.assertEqual(ac_tester.posonly_opt_kwonly_opt(1, 2), (1, 2, None, None))
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_opt_kwonly_opt(1, 2, 3)
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_opt_kwonly_opt(1, b=2)
+ self.assertEqual(ac_tester.posonly_opt_kwonly_opt(1, 2, c=3), (1, 2, 3, None))
+ self.assertEqual(ac_tester.posonly_opt_kwonly_opt(1, 2, c=3, d=4), (1, 2, 3, 4))
+
+ def test_posonly_keywords_kwonly_opt(self):
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_keywords_kwonly_opt(1)
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_keywords_kwonly_opt(1, 2)
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_keywords_kwonly_opt(1, b=2)
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_keywords_kwonly_opt(1, 2, 3)
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_keywords_kwonly_opt(a=1, b=2, c=3)
+ self.assertEqual(ac_tester.posonly_keywords_kwonly_opt(1, 2, c=3), (1, 2, 3, None, None))
+ self.assertEqual(ac_tester.posonly_keywords_kwonly_opt(1, b=2, c=3), (1, 2, 3, None, None))
+ self.assertEqual(ac_tester.posonly_keywords_kwonly_opt(1, 2, c=3, d=4), (1, 2, 3, 4, None))
+ self.assertEqual(ac_tester.posonly_keywords_kwonly_opt(1, 2, c=3, d=4, e=5), (1, 2, 3, 4, 5))
+
+ def test_posonly_keywords_opt_kwonly_opt(self):
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_keywords_opt_kwonly_opt(1)
+ self.assertEqual(ac_tester.posonly_keywords_opt_kwonly_opt(1, 2), (1, 2, None, None, None))
+ self.assertEqual(ac_tester.posonly_keywords_opt_kwonly_opt(1, b=2), (1, 2, None, None, None))
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_keywords_opt_kwonly_opt(1, 2, 3, 4)
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_keywords_opt_kwonly_opt(a=1, b=2)
+ self.assertEqual(ac_tester.posonly_keywords_opt_kwonly_opt(1, 2, c=3), (1, 2, 3, None, None))
+ self.assertEqual(ac_tester.posonly_keywords_opt_kwonly_opt(1, b=2, c=3), (1, 2, 3, None, None))
+ self.assertEqual(ac_tester.posonly_keywords_opt_kwonly_opt(1, 2, 3, d=4), (1, 2, 3, 4, None))
+ self.assertEqual(ac_tester.posonly_keywords_opt_kwonly_opt(1, 2, c=3, d=4), (1, 2, 3, 4, None))
+ self.assertEqual(ac_tester.posonly_keywords_opt_kwonly_opt(1, 2, 3, d=4, e=5), (1, 2, 3, 4, 5))
+ self.assertEqual(ac_tester.posonly_keywords_opt_kwonly_opt(1, 2, c=3, d=4, e=5), (1, 2, 3, 4, 5))
+
+ def test_posonly_opt_keywords_opt_kwonly_opt(self):
+ self.assertEqual(ac_tester.posonly_opt_keywords_opt_kwonly_opt(1), (1, None, None, None))
+ self.assertEqual(ac_tester.posonly_opt_keywords_opt_kwonly_opt(1, 2), (1, 2, None, None))
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_opt_keywords_opt_kwonly_opt(1, b=2)
+ self.assertEqual(ac_tester.posonly_opt_keywords_opt_kwonly_opt(1, 2, 3), (1, 2, 3, None))
+ self.assertEqual(ac_tester.posonly_opt_keywords_opt_kwonly_opt(1, 2, c=3), (1, 2, 3, None))
+ self.assertEqual(ac_tester.posonly_opt_keywords_opt_kwonly_opt(1, 2, 3, d=4), (1, 2, 3, 4))
+ self.assertEqual(ac_tester.posonly_opt_keywords_opt_kwonly_opt(1, 2, c=3, d=4), (1, 2, 3, 4))
+ with self.assertRaises(TypeError):
+ ac_tester.posonly_opt_keywords_opt_kwonly_opt(1, 2, 3, 4)
+
+ def test_keyword_only_parameter(self):
+ with self.assertRaises(TypeError):
+ ac_tester.keyword_only_parameter()
+ with self.assertRaises(TypeError):
+ ac_tester.keyword_only_parameter(1)
+ self.assertEqual(ac_tester.keyword_only_parameter(a=1), (1,))
+
+
if __name__ == "__main__":
unittest.main()
diff --git a/Misc/NEWS.d/next/Tests/2022-08-22-15-49-14.gh-issue-96002.4UE9UE.rst b/Misc/NEWS.d/next/Tests/2022-08-22-15-49-14.gh-issue-96002.4UE9UE.rst
new file mode 100644
index 000000000000..dc86e1d70f12
--- /dev/null
+++ b/Misc/NEWS.d/next/Tests/2022-08-22-15-49-14.gh-issue-96002.4UE9UE.rst
@@ -0,0 +1 @@
+Add functional test for Argument Clinic.
diff --git a/Modules/Setup.stdlib.in b/Modules/Setup.stdlib.in
index 6747d9730b25..7307d37bb492 100644
--- a/Modules/Setup.stdlib.in
+++ b/Modules/Setup.stdlib.in
@@ -170,6 +170,7 @@
@MODULE__TESTBUFFER_TRUE at _testbuffer _testbuffer.c
@MODULE__TESTINTERNALCAPI_TRUE at _testinternalcapi _testinternalcapi.c
@MODULE__TESTCAPI_TRUE at _testcapi _testcapimodule.c _testcapi/vectorcall.c _testcapi/vectorcall_limited.c _testcapi/heaptype.c _testcapi/unicode.c _testcapi/getargs.c _testcapi/pytime.c _testcapi/datetime.c _testcapi/docstring.c _testcapi/mem.c _testcapi/watchers.c _testcapi/long.c _testcapi/float.c
+ at MODULE__TESTCLINIC_TRUE@_testclinic _testclinic.c
# Some testing modules MUST be built as shared libraries.
*shared*
diff --git a/Modules/_testclinic.c b/Modules/_testclinic.c
new file mode 100644
index 000000000000..c9858e964457
--- /dev/null
+++ b/Modules/_testclinic.c
@@ -0,0 +1,952 @@
+#ifndef Py_BUILD_CORE_BUILTIN
+# define Py_BUILD_CORE_MODULE 1
+#endif
+
+/* Always enable assertions */
+#undef NDEBUG
+
+#define PY_SSIZE_T_CLEAN
+
+#include "Python.h"
+
+#include "clinic/_testclinic.c.h"
+
+
+/* Pack arguments to a tuple, implicitly increase all the arguments' refcount.
+ * NULL arguments will be replaced to Py_None. */
+static PyObject *
+pack_arguments_newref(int argc, ...)
+{
+ assert(!PyErr_Occurred());
+ PyObject *tuple = PyTuple_New(argc);
+ if (!tuple) {
+ return NULL;
+ }
+
+ va_list vargs;
+ va_start(vargs, argc);
+ for (int i = 0; i < argc; i++) {
+ PyObject *arg = va_arg(vargs, PyObject *);
+ if (arg) {
+ if (_PyObject_IsFreed(arg)) {
+ PyErr_Format(PyExc_AssertionError,
+ "argument %d at %p is freed or corrupted!",
+ i, arg);
+ va_end(vargs);
+ Py_DECREF(tuple);
+ return NULL;
+ }
+ }
+ else {
+ arg = Py_None;
+ }
+ PyTuple_SET_ITEM(tuple, i, Py_NewRef(arg));
+ }
+ va_end(vargs);
+ return tuple;
+}
+
+/* Pack arguments to a tuple.
+ * `wrapper` is function which converts primitive type to PyObject.
+ * `arg_type` is type that arguments should be converted to before wrapped. */
+#define RETURN_PACKED_ARGS(argc, wrapper, arg_type, ...) do { \
+ assert(!PyErr_Occurred()); \
+ arg_type in[argc] = {__VA_ARGS__}; \
+ PyObject *out[argc] = {NULL,}; \
+ for (int _i = 0; _i < argc; _i++) { \
+ out[_i] = wrapper(in[_i]); \
+ assert(out[_i] || PyErr_Occurred()); \
+ if (!out[_i]) { \
+ for (int _j = 0; _j < _i; _j++) { \
+ Py_DECREF(out[_j]); \
+ } \
+ return NULL; \
+ } \
+ } \
+ PyObject *tuple = PyTuple_New(argc); \
+ if (!tuple) { \
+ for (int _i = 0; _i < argc; _i++) { \
+ Py_DECREF(out[_i]); \
+ } \
+ return NULL; \
+ } \
+ for (int _i = 0; _i < argc; _i++) { \
+ PyTuple_SET_ITEM(tuple, _i, out[_i]); \
+ } \
+ return tuple; \
+ } while (0)
+
+
+/*[clinic input]
+module _testclinic
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=d4981b80d6efdb12]*/
+
+
+/*[clinic input]
+test_empty_function
+
+[clinic start generated code]*/
+
+static PyObject *
+test_empty_function_impl(PyObject *module)
+/*[clinic end generated code: output=0f8aeb3ddced55cb input=0dd7048651ad4ae4]*/
+{
+ Py_RETURN_NONE;
+}
+
+
+/*[clinic input]
+objects_converter
+
+ a: object
+ b: object = NULL
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+objects_converter_impl(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=3f9c9415ec86c695 input=1533b1bd94187de4]*/
+{
+ return pack_arguments_newref(2, a, b);
+}
+
+
+/*[clinic input]
+bytes_object_converter
+
+ a: PyBytesObject
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+bytes_object_converter_impl(PyObject *module, PyBytesObject *a)
+/*[clinic end generated code: output=7732da869d74b784 input=94211751e7996236]*/
+{
+ if (!PyBytes_Check(a)) {
+ PyErr_SetString(PyExc_AssertionError,
+ "argument a is not a PyBytesObject");
+ return NULL;
+ }
+ return pack_arguments_newref(1, a);
+}
+
+
+/*[clinic input]
+byte_array_object_converter
+
+ a: PyByteArrayObject
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+byte_array_object_converter_impl(PyObject *module, PyByteArrayObject *a)
+/*[clinic end generated code: output=51f15c76f302b1f7 input=b04d253db51c6f56]*/
+{
+ if (!PyByteArray_Check(a)) {
+ PyErr_SetString(PyExc_AssertionError,
+ "argument a is not a PyByteArrayObject");
+ return NULL;
+ }
+ return pack_arguments_newref(1, a);
+}
+
+
+/*[clinic input]
+unicode_converter
+
+ a: unicode
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+unicode_converter_impl(PyObject *module, PyObject *a)
+/*[clinic end generated code: output=1b4a4adbb6ac6e34 input=de7b5adbf07435ba]*/
+{
+ if (!PyUnicode_Check(a)) {
+ PyErr_SetString(PyExc_AssertionError,
+ "argument a is not a unicode object");
+ return NULL;
+ }
+ return pack_arguments_newref(1, a);
+}
+
+
+/*[clinic input]
+bool_converter
+
+ a: bool = True
+ b: bool(accept={object}) = True
+ c: bool(accept={int}) = True
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+bool_converter_impl(PyObject *module, int a, int b, int c)
+/*[clinic end generated code: output=17005b0c29afd590 input=7f6537705b2f32f4]*/
+{
+ PyObject *obj_a = a ? Py_True : Py_False;
+ PyObject *obj_b = b ? Py_True : Py_False;
+ PyObject *obj_c = c ? Py_True : Py_False;
+ return pack_arguments_newref(3, obj_a, obj_b, obj_c);
+}
+
+
+/*[clinic input]
+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]*/
+
+static PyObject *
+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=f929dbd2e55a9871 input=b601bc5bc7fe85e3]*/
+{
+ RETURN_PACKED_ARGS(14, PyLong_FromUnsignedLong, unsigned char,
+ a, b, c, d, e, f, g, h, i, j, k, l, m, n);
+}
+
+
+/*[clinic input]
+unsigned_char_converter
+
+ a: unsigned_char = 12
+ b: unsigned_char(bitwise=False) = 34
+ c: unsigned_char(bitwise=True) = 56
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+unsigned_char_converter_impl(PyObject *module, unsigned char a,
+ unsigned char b, unsigned char c)
+/*[clinic end generated code: output=490af3b39ce0b199 input=e859502fbe0b3185]*/
+{
+ RETURN_PACKED_ARGS(3, PyLong_FromUnsignedLong, unsigned char, a, b, c);
+}
+
+
+/*[clinic input]
+short_converter
+
+ a: short = 12
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+short_converter_impl(PyObject *module, short a)
+/*[clinic end generated code: output=1ebb7ddb64248988 input=b4e2309a66f650ae]*/
+{
+ RETURN_PACKED_ARGS(1, PyLong_FromLong, long, a);
+}
+
+
+/*[clinic input]
+unsigned_short_converter
+
+ a: unsigned_short = 12
+ b: unsigned_short(bitwise=False) = 34
+ c: unsigned_short(bitwise=True) = 56
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+unsigned_short_converter_impl(PyObject *module, unsigned short a,
+ unsigned short b, unsigned short c)
+/*[clinic end generated code: output=5f92cc72fc8707a7 input=9d15cd11e741d0c6]*/
+{
+ RETURN_PACKED_ARGS(3, PyLong_FromUnsignedLong, unsigned long, a, b, c);
+}
+
+
+/*[clinic input]
+int_converter
+
+ a: int = 12
+ b: int(accept={int}) = 34
+ c: int(accept={str}) = 45
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+int_converter_impl(PyObject *module, int a, int b, int c)
+/*[clinic end generated code: output=8e56b59be7d0c306 input=a1dbc6344853db7a]*/
+{
+ RETURN_PACKED_ARGS(3, PyLong_FromLong, long, a, b, c);
+}
+
+
+/*[clinic input]
+unsigned_int_converter
+
+ a: unsigned_int = 12
+ b: unsigned_int(bitwise=False) = 34
+ c: unsigned_int(bitwise=True) = 56
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+unsigned_int_converter_impl(PyObject *module, unsigned int a, unsigned int b,
+ unsigned int c)
+/*[clinic end generated code: output=399a57a05c494cc7 input=8427ed9a3f96272d]*/
+{
+ RETURN_PACKED_ARGS(3, PyLong_FromUnsignedLong, unsigned long, a, b, c);
+}
+
+
+/*[clinic input]
+long_converter
+
+ a: long = 12
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+long_converter_impl(PyObject *module, long a)
+/*[clinic end generated code: output=9663d936a652707a input=84ad0ef28f24bd85]*/
+{
+ RETURN_PACKED_ARGS(1, PyLong_FromLong, long, a);
+}
+
+
+/*[clinic input]
+unsigned_long_converter
+
+ a: unsigned_long = 12
+ b: unsigned_long(bitwise=False) = 34
+ c: unsigned_long(bitwise=True) = 56
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+unsigned_long_converter_impl(PyObject *module, unsigned long a,
+ unsigned long b, unsigned long c)
+/*[clinic end generated code: output=120b82ea9ebd93a8 input=440dd6f1817f5d91]*/
+{
+ RETURN_PACKED_ARGS(3, PyLong_FromUnsignedLong, unsigned long, a, b, c);
+}
+
+
+/*[clinic input]
+long_long_converter
+
+ a: long_long = 12
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+long_long_converter_impl(PyObject *module, long long a)
+/*[clinic end generated code: output=5fb5f2220770c3e1 input=730fcb3eecf4d993]*/
+{
+ RETURN_PACKED_ARGS(1, PyLong_FromLongLong, long long, a);
+}
+
+
+/*[clinic input]
+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]*/
+
+static PyObject *
+unsigned_long_long_converter_impl(PyObject *module, unsigned long long a,
+ unsigned long long b, unsigned long long c)
+/*[clinic end generated code: output=65b7273e63501762 input=300737b0bdb230e9]*/
+{
+ RETURN_PACKED_ARGS(3, PyLong_FromUnsignedLongLong, unsigned long long,
+ a, b, c);
+}
+
+
+/*[clinic input]
+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]*/
+
+static PyObject *
+py_ssize_t_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b,
+ Py_ssize_t c)
+/*[clinic end generated code: output=ce252143e0ed0372 input=76d0f342e9317a1f]*/
+{
+ RETURN_PACKED_ARGS(3, PyLong_FromSsize_t, Py_ssize_t, a, b, c);
+}
+
+
+/*[clinic input]
+slice_index_converter
+
+ a: slice_index = 12
+ b: slice_index(accept={int}) = 34
+ c: slice_index(accept={int, NoneType}) = 56
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+slice_index_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b,
+ Py_ssize_t c)
+/*[clinic end generated code: output=923c6cac77666a6b input=64f99f3f83265e47]*/
+{
+ RETURN_PACKED_ARGS(3, PyLong_FromSsize_t, Py_ssize_t, a, b, c);
+}
+
+
+/*[clinic input]
+size_t_converter
+
+ a: size_t = 12
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+size_t_converter_impl(PyObject *module, size_t a)
+/*[clinic end generated code: output=412b5b7334ab444d input=83ae7d9171fbf208]*/
+{
+ RETURN_PACKED_ARGS(1, PyLong_FromSize_t, size_t, a);
+}
+
+
+/*[clinic input]
+float_converter
+
+ a: float = 12.5
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+float_converter_impl(PyObject *module, float a)
+/*[clinic end generated code: output=1c98f64f2cf1d55c input=a625b59ad68047d8]*/
+{
+ RETURN_PACKED_ARGS(1, PyFloat_FromDouble, double, a);
+}
+
+
+/*[clinic input]
+double_converter
+
+ a: double = 12.5
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+double_converter_impl(PyObject *module, double a)
+/*[clinic end generated code: output=a4e8532d284d035d input=098df188f24e7c62]*/
+{
+ RETURN_PACKED_ARGS(1, PyFloat_FromDouble, double, a);
+}
+
+
+/*[clinic input]
+py_complex_converter
+
+ a: Py_complex
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+py_complex_converter_impl(PyObject *module, Py_complex a)
+/*[clinic end generated code: output=9e6ca2eb53b14846 input=e9148a8ca1dbf195]*/
+{
+ RETURN_PACKED_ARGS(1, PyComplex_FromCComplex, Py_complex, a);
+}
+
+
+/*[clinic input]
+str_converter
+
+ a: str = "a"
+ b: str(accept={robuffer}) = "b"
+ c: str(accept={robuffer, str}, zeroes=True) = "c"
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+str_converter_impl(PyObject *module, const char *a, const char *b,
+ const char *c, Py_ssize_t c_length)
+/*[clinic end generated code: output=475bea40548c8cd6 input=bff2656c92ee25de]*/
+{
+ assert(!PyErr_Occurred());
+ PyObject *out[3] = {NULL,};
+ int i = 0;
+ PyObject *arg;
+
+ arg = PyUnicode_FromString(a);
+ assert(arg || PyErr_Occurred());
+ if (!arg) {
+ goto error;
+ }
+ out[i++] = arg;
+
+ arg = PyUnicode_FromString(b);
+ assert(arg || PyErr_Occurred());
+ if (!arg) {
+ goto error;
+ }
+ out[i++] = arg;
+
+ arg = PyUnicode_FromStringAndSize(c, c_length);
+ assert(arg || PyErr_Occurred());
+ if (!arg) {
+ goto error;
+ }
+ out[i++] = arg;
+
+ PyObject *tuple = PyTuple_New(3);
+ if (!tuple) {
+ goto error;
+ }
+ for (int j = 0; j < 3; j++) {
+ PyTuple_SET_ITEM(tuple, j, out[j]);
+ }
+ return tuple;
+
+error:
+ for (int j = 0; j < i; j++) {
+ Py_DECREF(out[j]);
+ }
+ return NULL;
+}
+
+
+static PyObject *
+bytes_from_buffer(Py_buffer *buf)
+{
+ PyObject *bytes_obj = PyBytes_FromStringAndSize(NULL, buf->len);
+ if (!bytes_obj) {
+ return NULL;
+ }
+ void *bytes_obj_buf = ((PyBytesObject *)bytes_obj)->ob_sval;
+ if (PyBuffer_ToContiguous(bytes_obj_buf, buf, buf->len, 'C') < 0) {
+ Py_DECREF(bytes_obj);
+ return NULL;
+ }
+ return bytes_obj;
+}
+
+/*[clinic input]
+py_buffer_converter
+
+ a: Py_buffer(accept={str, buffer, NoneType})
+ b: Py_buffer(accept={rwbuffer})
+ /
+
+[clinic start generated code]*/
+
+static PyObject *
+py_buffer_converter_impl(PyObject *module, Py_buffer *a, Py_buffer *b)
+/*[clinic end generated code: output=52fb13311e3d6d03 input=775de727de5c7421]*/
+{
+ RETURN_PACKED_ARGS(2, bytes_from_buffer, Py_buffer *, a, b);
+}
+
+
+/*[clinic input]
+keywords
+
+ a: object
+ b: object
+
+[clinic start generated code]*/
+
+static PyObject *
+keywords_impl(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=850aaed53e26729e input=f44b89e718c1a93b]*/
+{
+ return pack_arguments_newref(2, a, b);
+}
+
+
+/*[clinic input]
+keywords_kwonly
+
+ a: object
+ *
+ b: object
+
+[clinic start generated code]*/
+
+static PyObject *
+keywords_kwonly_impl(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=a45c48241da584dc input=1f08e39c3312b015]*/
+{
+ return pack_arguments_newref(2, a, b);
+}
+
+
+/*[clinic input]
+keywords_opt
+
+ a: object
+ b: object = None
+ c: object = None
+
+[clinic start generated code]*/
+
+static PyObject *
+keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b, PyObject *c)
+/*[clinic end generated code: output=25e4b67d91c76a66 input=b0ba0e4f04904556]*/
+{
+ return pack_arguments_newref(3, a, b, c);
+}
+
+
+/*[clinic input]
+keywords_opt_kwonly
+
+ a: object
+ b: object = None
+ *
+ c: object = None
+ d: object = None
+
+[clinic start generated code]*/
+
+static PyObject *
+keywords_opt_kwonly_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c, PyObject *d)
+/*[clinic end generated code: output=6aa5b655a6e9aeb0 input=f79da689d6c51076]*/
+{
+ return pack_arguments_newref(4, a, b, c, d);
+}
+
+
+/*[clinic input]
+keywords_kwonly_opt
+
+ a: object
+ *
+ b: object = None
+ c: object = None
+
+[clinic start generated code]*/
+
+static PyObject *
+keywords_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c)
+/*[clinic end generated code: output=707f78eb0f55c2b1 input=e0fa1a0e46dca791]*/
+{
+ return pack_arguments_newref(3, a, b, c);
+}
+
+
+/*[clinic input]
+posonly_keywords
+
+ a: object
+ /
+ b: object
+
+[clinic start generated code]*/
+
+static PyObject *
+posonly_keywords_impl(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=6ac88f4a5f0bfc8d input=fde0a2f79fe82b06]*/
+{
+ return pack_arguments_newref(2, a, b);
+}
+
+
+/*[clinic input]
+posonly_kwonly
+
+ a: object
+ /
+ *
+ b: object
+
+[clinic start generated code]*/
+
+static PyObject *
+posonly_kwonly_impl(PyObject *module, PyObject *a, PyObject *b)
+/*[clinic end generated code: output=483e6790d3482185 input=78b3712768da9a19]*/
+{
+ return pack_arguments_newref(2, a, b);
+}
+
+
+/*[clinic input]
+posonly_keywords_kwonly
+
+ a: object
+ /
+ b: object
+ *
+ c: object
+
+[clinic start generated code]*/
+
+static PyObject *
+posonly_keywords_kwonly_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c)
+/*[clinic end generated code: output=2fae573e8cc3fad8 input=a1ad5d2295eb803c]*/
+{
+ return pack_arguments_newref(3, a, b, c);
+}
+
+
+/*[clinic input]
+posonly_keywords_opt
+
+ a: object
+ /
+ b: object
+ c: object = None
+ d: object = None
+
+[clinic start generated code]*/
+
+static PyObject *
+posonly_keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c, PyObject *d)
+/*[clinic end generated code: output=f5eb66241bcf68fb input=51c10de2a120e279]*/
+{
+ return pack_arguments_newref(4, a, b, c, d);
+}
+
+
+/*[clinic input]
+posonly_opt_keywords_opt
+
+ a: object
+ b: object = None
+ /
+ c: object = None
+ d: object = None
+
+[clinic start generated code]*/
+
+static PyObject *
+posonly_opt_keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c, PyObject *d)
+/*[clinic end generated code: output=d54a30e549296ffd input=f408a1de7dfaf31f]*/
+{
+ return pack_arguments_newref(4, a, b, c, d);
+}
+
+
+/*[clinic input]
+posonly_kwonly_opt
+
+ a: object
+ /
+ *
+ b: object
+ c: object = None
+ d: object = None
+
+[clinic start generated code]*/
+
+static PyObject *
+posonly_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c, PyObject *d)
+/*[clinic end generated code: output=a20503fe36b4fd62 input=3494253975272f52]*/
+{
+ return pack_arguments_newref(4, a, b, c, d);
+}
+
+
+/*[clinic input]
+posonly_opt_kwonly_opt
+
+ a: object
+ b: object = None
+ /
+ *
+ c: object = None
+ d: object = None
+
+[clinic start generated code]*/
+
+static PyObject *
+posonly_opt_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c, PyObject *d)
+/*[clinic end generated code: output=64f3204a3a0413b6 input=d17516581e478412]*/
+{
+ return pack_arguments_newref(4, a, b, c, d);
+}
+
+
+/*[clinic input]
+posonly_keywords_kwonly_opt
+
+ a: object
+ /
+ b: object
+ *
+ c: object
+ d: object = None
+ e: object = None
+
+[clinic start generated code]*/
+
+static PyObject *
+posonly_keywords_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c, PyObject *d, PyObject *e)
+/*[clinic end generated code: output=dbd7e7ddd6257fa0 input=33529f29e97e5adb]*/
+{
+ return pack_arguments_newref(5, a, b, c, d, e);
+}
+
+
+/*[clinic input]
+posonly_keywords_opt_kwonly_opt
+
+ a: object
+ /
+ b: object
+ c: object = None
+ *
+ d: object = None
+ e: object = None
+
+[clinic start generated code]*/
+
+static PyObject *
+posonly_keywords_opt_kwonly_opt_impl(PyObject *module, PyObject *a,
+ PyObject *b, PyObject *c, PyObject *d,
+ PyObject *e)
+/*[clinic end generated code: output=775d12ae44653045 input=4d4cc62f11441301]*/
+{
+ return pack_arguments_newref(5, a, b, c, d, e);
+}
+
+
+/*[clinic input]
+posonly_opt_keywords_opt_kwonly_opt
+
+ a: object
+ b: object = None
+ /
+ c: object = None
+ *
+ d: object = None
+
+[clinic start generated code]*/
+
+static PyObject *
+posonly_opt_keywords_opt_kwonly_opt_impl(PyObject *module, PyObject *a,
+ PyObject *b, PyObject *c,
+ PyObject *d)
+/*[clinic end generated code: output=40c6dc422591eade input=3964960a68622431]*/
+{
+ return pack_arguments_newref(4, a, b, c, d);
+}
+
+
+/*[clinic input]
+keyword_only_parameter
+
+ *
+ a: object
+
+[clinic start generated code]*/
+
+static PyObject *
+keyword_only_parameter_impl(PyObject *module, PyObject *a)
+/*[clinic end generated code: output=c454b6ce98232787 input=8d2868b8d0b27bdb]*/
+{
+ return pack_arguments_newref(1, a);
+}
+
+
+static PyMethodDef tester_methods[] = {
+ TEST_EMPTY_FUNCTION_METHODDEF
+ OBJECTS_CONVERTER_METHODDEF
+ BYTES_OBJECT_CONVERTER_METHODDEF
+ BYTE_ARRAY_OBJECT_CONVERTER_METHODDEF
+ UNICODE_CONVERTER_METHODDEF
+ BOOL_CONVERTER_METHODDEF
+ CHAR_CONVERTER_METHODDEF
+ UNSIGNED_CHAR_CONVERTER_METHODDEF
+ SHORT_CONVERTER_METHODDEF
+ UNSIGNED_SHORT_CONVERTER_METHODDEF
+ INT_CONVERTER_METHODDEF
+ UNSIGNED_INT_CONVERTER_METHODDEF
+ LONG_CONVERTER_METHODDEF
+ UNSIGNED_LONG_CONVERTER_METHODDEF
+ LONG_LONG_CONVERTER_METHODDEF
+ UNSIGNED_LONG_LONG_CONVERTER_METHODDEF
+ PY_SSIZE_T_CONVERTER_METHODDEF
+ SLICE_INDEX_CONVERTER_METHODDEF
+ SIZE_T_CONVERTER_METHODDEF
+ FLOAT_CONVERTER_METHODDEF
+ DOUBLE_CONVERTER_METHODDEF
+ PY_COMPLEX_CONVERTER_METHODDEF
+ STR_CONVERTER_METHODDEF
+ PY_BUFFER_CONVERTER_METHODDEF
+ KEYWORDS_METHODDEF
+ KEYWORDS_KWONLY_METHODDEF
+ KEYWORDS_OPT_METHODDEF
+ KEYWORDS_OPT_KWONLY_METHODDEF
+ KEYWORDS_KWONLY_OPT_METHODDEF
+ POSONLY_KEYWORDS_METHODDEF
+ POSONLY_KWONLY_METHODDEF
+ POSONLY_KEYWORDS_KWONLY_METHODDEF
+ POSONLY_KEYWORDS_OPT_METHODDEF
+ POSONLY_OPT_KEYWORDS_OPT_METHODDEF
+ POSONLY_KWONLY_OPT_METHODDEF
+ POSONLY_OPT_KWONLY_OPT_METHODDEF
+ POSONLY_KEYWORDS_KWONLY_OPT_METHODDEF
+ POSONLY_KEYWORDS_OPT_KWONLY_OPT_METHODDEF
+ POSONLY_OPT_KEYWORDS_OPT_KWONLY_OPT_METHODDEF
+ KEYWORD_ONLY_PARAMETER_METHODDEF
+ {NULL, NULL}
+};
+
+static struct PyModuleDef _testclinic_module = {
+ PyModuleDef_HEAD_INIT,
+ .m_name = "_testclinic",
+ .m_size = 0,
+ .m_methods = tester_methods,
+};
+
+PyMODINIT_FUNC
+PyInit__testclinic(void)
+{
+ return PyModule_Create(&_testclinic_module);
+}
+
+#undef RETURN_PACKED_ARGS
diff --git a/Modules/clinic/_testclinic.c.h b/Modules/clinic/_testclinic.c.h
new file mode 100644
index 000000000000..b0ac4c2eef83
--- /dev/null
+++ b/Modules/clinic/_testclinic.c.h
@@ -0,0 +1,2291 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+# include "pycore_gc.h" // PyGC_Head
+# include "pycore_runtime.h" // _Py_ID()
+#endif
+
+
+PyDoc_STRVAR(test_empty_function__doc__,
+"test_empty_function($module, /)\n"
+"--\n"
+"\n");
+
+#define TEST_EMPTY_FUNCTION_METHODDEF \
+ {"test_empty_function", (PyCFunction)test_empty_function, METH_NOARGS, test_empty_function__doc__},
+
+static PyObject *
+test_empty_function_impl(PyObject *module);
+
+static PyObject *
+test_empty_function(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
+ return test_empty_function_impl(module);
+}
+
+PyDoc_STRVAR(objects_converter__doc__,
+"objects_converter($module, a, b=<unrepresentable>, /)\n"
+"--\n"
+"\n");
+
+#define OBJECTS_CONVERTER_METHODDEF \
+ {"objects_converter", _PyCFunction_CAST(objects_converter), METH_FASTCALL, objects_converter__doc__},
+
+static PyObject *
+objects_converter_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+objects_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+ PyObject *b = NULL;
+
+ if (!_PyArg_CheckPositional("objects_converter", nargs, 1, 2)) {
+ goto exit;
+ }
+ a = args[0];
+ if (nargs < 2) {
+ goto skip_optional;
+ }
+ b = args[1];
+skip_optional:
+ return_value = objects_converter_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(bytes_object_converter__doc__,
+"bytes_object_converter($module, a, /)\n"
+"--\n"
+"\n");
+
+#define BYTES_OBJECT_CONVERTER_METHODDEF \
+ {"bytes_object_converter", (PyCFunction)bytes_object_converter, METH_O, bytes_object_converter__doc__},
+
+static PyObject *
+bytes_object_converter_impl(PyObject *module, PyBytesObject *a);
+
+static PyObject *
+bytes_object_converter(PyObject *module, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ PyBytesObject *a;
+
+ if (!PyBytes_Check(arg)) {
+ _PyArg_BadArgument("bytes_object_converter", "argument", "bytes", arg);
+ goto exit;
+ }
+ a = (PyBytesObject *)arg;
+ return_value = bytes_object_converter_impl(module, a);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(byte_array_object_converter__doc__,
+"byte_array_object_converter($module, a, /)\n"
+"--\n"
+"\n");
+
+#define BYTE_ARRAY_OBJECT_CONVERTER_METHODDEF \
+ {"byte_array_object_converter", (PyCFunction)byte_array_object_converter, METH_O, byte_array_object_converter__doc__},
+
+static PyObject *
+byte_array_object_converter_impl(PyObject *module, PyByteArrayObject *a);
+
+static PyObject *
+byte_array_object_converter(PyObject *module, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ PyByteArrayObject *a;
+
+ if (!PyByteArray_Check(arg)) {
+ _PyArg_BadArgument("byte_array_object_converter", "argument", "bytearray", arg);
+ goto exit;
+ }
+ a = (PyByteArrayObject *)arg;
+ return_value = byte_array_object_converter_impl(module, a);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(unicode_converter__doc__,
+"unicode_converter($module, a, /)\n"
+"--\n"
+"\n");
+
+#define UNICODE_CONVERTER_METHODDEF \
+ {"unicode_converter", (PyCFunction)unicode_converter, METH_O, unicode_converter__doc__},
+
+static PyObject *
+unicode_converter_impl(PyObject *module, PyObject *a);
+
+static PyObject *
+unicode_converter(PyObject *module, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ PyObject *a;
+
+ if (!PyUnicode_Check(arg)) {
+ _PyArg_BadArgument("unicode_converter", "argument", "str", arg);
+ goto exit;
+ }
+ if (PyUnicode_READY(arg) == -1) {
+ goto exit;
+ }
+ a = arg;
+ return_value = unicode_converter_impl(module, a);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(bool_converter__doc__,
+"bool_converter($module, a=True, b=True, c=True, /)\n"
+"--\n"
+"\n");
+
+#define BOOL_CONVERTER_METHODDEF \
+ {"bool_converter", _PyCFunction_CAST(bool_converter), METH_FASTCALL, bool_converter__doc__},
+
+static PyObject *
+bool_converter_impl(PyObject *module, int a, int b, int c);
+
+static PyObject *
+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("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 = bool_converter_impl(module, a, b, c);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(char_converter__doc__,
+"char_converter($module, a=b\'A\', b=b\'\\x07\', c=b\'\\x08\', d=b\'\\t\', e=b\'\\n\',\n"
+" f=b\'\\x0b\', g=b\'\\x0c\', h=b\'\\r\', i=b\'\"\', j=b\"\'\", k=b\'?\',\n"
+" l=b\'\\\\\', m=b\'\\x00\', n=b\'\\xff\', /)\n"
+"--\n"
+"\n");
+
+#define CHAR_CONVERTER_METHODDEF \
+ {"char_converter", _PyCFunction_CAST(char_converter), METH_FASTCALL, char_converter__doc__},
+
+static PyObject *
+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 *
+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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("char_converter", "argument 14", "a byte string of length 1", args[13]);
+ goto exit;
+ }
+skip_optional:
+ return_value = char_converter_impl(module, a, b, c, d, e, f, g, h, i, j, k, l, m, n);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(unsigned_char_converter__doc__,
+"unsigned_char_converter($module, a=12, b=34, c=56, /)\n"
+"--\n"
+"\n");
+
+#define UNSIGNED_CHAR_CONVERTER_METHODDEF \
+ {"unsigned_char_converter", _PyCFunction_CAST(unsigned_char_converter), METH_FASTCALL, unsigned_char_converter__doc__},
+
+static PyObject *
+unsigned_char_converter_impl(PyObject *module, unsigned char a,
+ unsigned char b, unsigned char c);
+
+static PyObject *
+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("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 = unsigned_char_converter_impl(module, a, b, c);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(short_converter__doc__,
+"short_converter($module, a=12, /)\n"
+"--\n"
+"\n");
+
+#define SHORT_CONVERTER_METHODDEF \
+ {"short_converter", _PyCFunction_CAST(short_converter), METH_FASTCALL, short_converter__doc__},
+
+static PyObject *
+short_converter_impl(PyObject *module, short a);
+
+static PyObject *
+short_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+ PyObject *return_value = NULL;
+ short a = 12;
+
+ if (!_PyArg_CheckPositional("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 = short_converter_impl(module, a);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(unsigned_short_converter__doc__,
+"unsigned_short_converter($module, a=12, b=34, c=56, /)\n"
+"--\n"
+"\n");
+
+#define UNSIGNED_SHORT_CONVERTER_METHODDEF \
+ {"unsigned_short_converter", _PyCFunction_CAST(unsigned_short_converter), METH_FASTCALL, unsigned_short_converter__doc__},
+
+static PyObject *
+unsigned_short_converter_impl(PyObject *module, unsigned short a,
+ unsigned short b, unsigned short c);
+
+static PyObject *
+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("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 = unsigned_short_converter_impl(module, a, b, c);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(int_converter__doc__,
+"int_converter($module, a=12, b=34, c=45, /)\n"
+"--\n"
+"\n");
+
+#define INT_CONVERTER_METHODDEF \
+ {"int_converter", _PyCFunction_CAST(int_converter), METH_FASTCALL, int_converter__doc__},
+
+static PyObject *
+int_converter_impl(PyObject *module, int a, int b, int c);
+
+static PyObject *
+int_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+ PyObject *return_value = NULL;
+ int a = 12;
+ int b = 34;
+ int c = 45;
+
+ if (!_PyArg_CheckPositional("int_converter", nargs, 0, 3)) {
+ goto exit;
+ }
+ if (nargs < 1) {
+ goto skip_optional;
+ }
+ a = _PyLong_AsInt(args[0]);
+ if (a == -1 && PyErr_Occurred()) {
+ goto exit;
+ }
+ if (nargs < 2) {
+ goto skip_optional;
+ }
+ b = _PyLong_AsInt(args[1]);
+ if (b == -1 && PyErr_Occurred()) {
+ goto exit;
+ }
+ if (nargs < 3) {
+ goto skip_optional;
+ }
+ if (!PyUnicode_Check(args[2])) {
+ _PyArg_BadArgument("int_converter", "argument 3", "a unicode character", args[2]);
+ goto exit;
+ }
+ if (PyUnicode_READY(args[2])) {
+ goto exit;
+ }
+ if (PyUnicode_GET_LENGTH(args[2]) != 1) {
+ _PyArg_BadArgument("int_converter", "argument 3", "a unicode character", args[2]);
+ goto exit;
+ }
+ c = PyUnicode_READ_CHAR(args[2], 0);
+skip_optional:
+ return_value = int_converter_impl(module, a, b, c);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(unsigned_int_converter__doc__,
+"unsigned_int_converter($module, a=12, b=34, c=56, /)\n"
+"--\n"
+"\n");
+
+#define UNSIGNED_INT_CONVERTER_METHODDEF \
+ {"unsigned_int_converter", _PyCFunction_CAST(unsigned_int_converter), METH_FASTCALL, unsigned_int_converter__doc__},
+
+static PyObject *
+unsigned_int_converter_impl(PyObject *module, unsigned int a, unsigned int b,
+ unsigned int c);
+
+static PyObject *
+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_CheckPositional("unsigned_int_converter", nargs, 0, 3)) {
+ goto exit;
+ }
+ if (nargs < 1) {
+ goto skip_optional;
+ }
+ if (!_PyLong_UnsignedInt_Converter(args[0], &a)) {
+ goto exit;
+ }
+ if (nargs < 2) {
+ goto skip_optional;
+ }
+ if (!_PyLong_UnsignedInt_Converter(args[1], &b)) {
+ goto exit;
+ }
+ if (nargs < 3) {
+ goto skip_optional;
+ }
+ c = (unsigned int)PyLong_AsUnsignedLongMask(args[2]);
+ if (c == (unsigned int)-1 && PyErr_Occurred()) {
+ goto exit;
+ }
+skip_optional:
+ return_value = unsigned_int_converter_impl(module, a, b, c);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(long_converter__doc__,
+"long_converter($module, a=12, /)\n"
+"--\n"
+"\n");
+
+#define LONG_CONVERTER_METHODDEF \
+ {"long_converter", _PyCFunction_CAST(long_converter), METH_FASTCALL, long_converter__doc__},
+
+static PyObject *
+long_converter_impl(PyObject *module, long a);
+
+static PyObject *
+long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+ PyObject *return_value = NULL;
+ long a = 12;
+
+ if (!_PyArg_CheckPositional("long_converter", nargs, 0, 1)) {
+ goto exit;
+ }
+ if (nargs < 1) {
+ goto skip_optional;
+ }
+ a = PyLong_AsLong(args[0]);
+ if (a == -1 && PyErr_Occurred()) {
+ goto exit;
+ }
+skip_optional:
+ return_value = long_converter_impl(module, a);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(unsigned_long_converter__doc__,
+"unsigned_long_converter($module, a=12, b=34, c=56, /)\n"
+"--\n"
+"\n");
+
+#define UNSIGNED_LONG_CONVERTER_METHODDEF \
+ {"unsigned_long_converter", _PyCFunction_CAST(unsigned_long_converter), METH_FASTCALL, unsigned_long_converter__doc__},
+
+static PyObject *
+unsigned_long_converter_impl(PyObject *module, unsigned long a,
+ unsigned long b, unsigned long c);
+
+static PyObject *
+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_CheckPositional("unsigned_long_converter", nargs, 0, 3)) {
+ goto exit;
+ }
+ if (nargs < 1) {
+ goto skip_optional;
+ }
+ if (!_PyLong_UnsignedLong_Converter(args[0], &a)) {
+ goto exit;
+ }
+ if (nargs < 2) {
+ goto skip_optional;
+ }
+ if (!_PyLong_UnsignedLong_Converter(args[1], &b)) {
+ goto exit;
+ }
+ if (nargs < 3) {
+ goto skip_optional;
+ }
+ if (!PyLong_Check(args[2])) {
+ _PyArg_BadArgument("unsigned_long_converter", "argument 3", "int", args[2]);
+ goto exit;
+ }
+ c = PyLong_AsUnsignedLongMask(args[2]);
+skip_optional:
+ return_value = unsigned_long_converter_impl(module, a, b, c);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(long_long_converter__doc__,
+"long_long_converter($module, a=12, /)\n"
+"--\n"
+"\n");
+
+#define LONG_LONG_CONVERTER_METHODDEF \
+ {"long_long_converter", _PyCFunction_CAST(long_long_converter), METH_FASTCALL, long_long_converter__doc__},
+
+static PyObject *
+long_long_converter_impl(PyObject *module, long long a);
+
+static PyObject *
+long_long_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+ PyObject *return_value = NULL;
+ long long a = 12;
+
+ if (!_PyArg_CheckPositional("long_long_converter", nargs, 0, 1)) {
+ goto exit;
+ }
+ if (nargs < 1) {
+ goto skip_optional;
+ }
+ a = PyLong_AsLongLong(args[0]);
+ if (a == -1 && PyErr_Occurred()) {
+ goto exit;
+ }
+skip_optional:
+ return_value = long_long_converter_impl(module, a);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(unsigned_long_long_converter__doc__,
+"unsigned_long_long_converter($module, a=12, b=34, c=56, /)\n"
+"--\n"
+"\n");
+
+#define UNSIGNED_LONG_LONG_CONVERTER_METHODDEF \
+ {"unsigned_long_long_converter", _PyCFunction_CAST(unsigned_long_long_converter), METH_FASTCALL, unsigned_long_long_converter__doc__},
+
+static PyObject *
+unsigned_long_long_converter_impl(PyObject *module, unsigned long long a,
+ unsigned long long b, unsigned long long c);
+
+static PyObject *
+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_CheckPositional("unsigned_long_long_converter", nargs, 0, 3)) {
+ goto exit;
+ }
+ if (nargs < 1) {
+ goto skip_optional;
+ }
+ if (!_PyLong_UnsignedLongLong_Converter(args[0], &a)) {
+ goto exit;
+ }
+ if (nargs < 2) {
+ goto skip_optional;
+ }
+ if (!_PyLong_UnsignedLongLong_Converter(args[1], &b)) {
+ goto exit;
+ }
+ if (nargs < 3) {
+ goto skip_optional;
+ }
+ if (!PyLong_Check(args[2])) {
+ _PyArg_BadArgument("unsigned_long_long_converter", "argument 3", "int", args[2]);
+ goto exit;
+ }
+ c = PyLong_AsUnsignedLongLongMask(args[2]);
+skip_optional:
+ return_value = unsigned_long_long_converter_impl(module, a, b, c);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(py_ssize_t_converter__doc__,
+"py_ssize_t_converter($module, a=12, b=34, c=56, /)\n"
+"--\n"
+"\n");
+
+#define PY_SSIZE_T_CONVERTER_METHODDEF \
+ {"py_ssize_t_converter", _PyCFunction_CAST(py_ssize_t_converter), METH_FASTCALL, py_ssize_t_converter__doc__},
+
+static PyObject *
+py_ssize_t_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b,
+ Py_ssize_t c);
+
+static PyObject *
+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_CheckPositional("py_ssize_t_converter", nargs, 0, 3)) {
+ goto exit;
+ }
+ if (nargs < 1) {
+ goto skip_optional;
+ }
+ {
+ Py_ssize_t ival = -1;
+ PyObject *iobj = _PyNumber_Index(args[0]);
+ if (iobj != NULL) {
+ ival = PyLong_AsSsize_t(iobj);
+ Py_DECREF(iobj);
+ }
+ if (ival == -1 && PyErr_Occurred()) {
+ goto exit;
+ }
+ a = ival;
+ }
+ if (nargs < 2) {
+ goto skip_optional;
+ }
+ {
+ Py_ssize_t ival = -1;
+ PyObject *iobj = _PyNumber_Index(args[1]);
+ if (iobj != NULL) {
+ ival = PyLong_AsSsize_t(iobj);
+ Py_DECREF(iobj);
+ }
+ if (ival == -1 && PyErr_Occurred()) {
+ goto exit;
+ }
+ b = ival;
+ }
+ if (nargs < 3) {
+ goto skip_optional;
+ }
+ if (!_Py_convert_optional_to_ssize_t(args[2], &c)) {
+ goto exit;
+ }
+skip_optional:
+ return_value = py_ssize_t_converter_impl(module, a, b, c);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(slice_index_converter__doc__,
+"slice_index_converter($module, a=12, b=34, c=56, /)\n"
+"--\n"
+"\n");
+
+#define SLICE_INDEX_CONVERTER_METHODDEF \
+ {"slice_index_converter", _PyCFunction_CAST(slice_index_converter), METH_FASTCALL, slice_index_converter__doc__},
+
+static PyObject *
+slice_index_converter_impl(PyObject *module, Py_ssize_t a, Py_ssize_t b,
+ Py_ssize_t c);
+
+static PyObject *
+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_CheckPositional("slice_index_converter", nargs, 0, 3)) {
+ goto exit;
+ }
+ if (nargs < 1) {
+ goto skip_optional;
+ }
+ if (!_PyEval_SliceIndex(args[0], &a)) {
+ goto exit;
+ }
+ if (nargs < 2) {
+ goto skip_optional;
+ }
+ if (!_PyEval_SliceIndexNotNone(args[1], &b)) {
+ goto exit;
+ }
+ if (nargs < 3) {
+ goto skip_optional;
+ }
+ if (!_PyEval_SliceIndex(args[2], &c)) {
+ goto exit;
+ }
+skip_optional:
+ return_value = slice_index_converter_impl(module, a, b, c);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(size_t_converter__doc__,
+"size_t_converter($module, a=12, /)\n"
+"--\n"
+"\n");
+
+#define SIZE_T_CONVERTER_METHODDEF \
+ {"size_t_converter", _PyCFunction_CAST(size_t_converter), METH_FASTCALL, size_t_converter__doc__},
+
+static PyObject *
+size_t_converter_impl(PyObject *module, size_t a);
+
+static PyObject *
+size_t_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+ PyObject *return_value = NULL;
+ size_t a = 12;
+
+ if (!_PyArg_CheckPositional("size_t_converter", nargs, 0, 1)) {
+ goto exit;
+ }
+ if (nargs < 1) {
+ goto skip_optional;
+ }
+ if (!_PyLong_Size_t_Converter(args[0], &a)) {
+ goto exit;
+ }
+skip_optional:
+ return_value = size_t_converter_impl(module, a);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(float_converter__doc__,
+"float_converter($module, a=12.5, /)\n"
+"--\n"
+"\n");
+
+#define FLOAT_CONVERTER_METHODDEF \
+ {"float_converter", _PyCFunction_CAST(float_converter), METH_FASTCALL, float_converter__doc__},
+
+static PyObject *
+float_converter_impl(PyObject *module, float a);
+
+static PyObject *
+float_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+ PyObject *return_value = NULL;
+ float a = 12.5;
+
+ if (!_PyArg_CheckPositional("float_converter", nargs, 0, 1)) {
+ goto exit;
+ }
+ if (nargs < 1) {
+ goto skip_optional;
+ }
+ if (PyFloat_CheckExact(args[0])) {
+ a = (float) (PyFloat_AS_DOUBLE(args[0]));
+ }
+ else
+ {
+ a = (float) PyFloat_AsDouble(args[0]);
+ if (a == -1.0 && PyErr_Occurred()) {
+ goto exit;
+ }
+ }
+skip_optional:
+ return_value = float_converter_impl(module, a);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(double_converter__doc__,
+"double_converter($module, a=12.5, /)\n"
+"--\n"
+"\n");
+
+#define DOUBLE_CONVERTER_METHODDEF \
+ {"double_converter", _PyCFunction_CAST(double_converter), METH_FASTCALL, double_converter__doc__},
+
+static PyObject *
+double_converter_impl(PyObject *module, double a);
+
+static PyObject *
+double_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+ PyObject *return_value = NULL;
+ double a = 12.5;
+
+ if (!_PyArg_CheckPositional("double_converter", nargs, 0, 1)) {
+ goto exit;
+ }
+ if (nargs < 1) {
+ goto skip_optional;
+ }
+ if (PyFloat_CheckExact(args[0])) {
+ a = PyFloat_AS_DOUBLE(args[0]);
+ }
+ else
+ {
+ a = PyFloat_AsDouble(args[0]);
+ if (a == -1.0 && PyErr_Occurred()) {
+ goto exit;
+ }
+ }
+skip_optional:
+ return_value = double_converter_impl(module, a);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(py_complex_converter__doc__,
+"py_complex_converter($module, a, /)\n"
+"--\n"
+"\n");
+
+#define PY_COMPLEX_CONVERTER_METHODDEF \
+ {"py_complex_converter", (PyCFunction)py_complex_converter, METH_O, py_complex_converter__doc__},
+
+static PyObject *
+py_complex_converter_impl(PyObject *module, Py_complex a);
+
+static PyObject *
+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 = py_complex_converter_impl(module, a);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(str_converter__doc__,
+"str_converter($module, a=\'a\', b=\'b\', c=\'c\', /)\n"
+"--\n"
+"\n");
+
+#define STR_CONVERTER_METHODDEF \
+ {"str_converter", _PyCFunction_CAST(str_converter), METH_FASTCALL, str_converter__doc__},
+
+static PyObject *
+str_converter_impl(PyObject *module, const char *a, const char *b,
+ const char *c, Py_ssize_t c_length);
+
+static PyObject *
+str_converter(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+ PyObject *return_value = NULL;
+ const char *a = "a";
+ const char *b = "b";
+ const char *c = "c";
+ Py_ssize_t c_length;
+
+ if (!_PyArg_ParseStack(args, nargs, "|sys#:str_converter",
+ &a, &b, &c, &c_length)) {
+ goto exit;
+ }
+ return_value = str_converter_impl(module, a, b, c, c_length);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(py_buffer_converter__doc__,
+"py_buffer_converter($module, a, b, /)\n"
+"--\n"
+"\n");
+
+#define PY_BUFFER_CONVERTER_METHODDEF \
+ {"py_buffer_converter", _PyCFunction_CAST(py_buffer_converter), METH_FASTCALL, py_buffer_converter__doc__},
+
+static PyObject *
+py_buffer_converter_impl(PyObject *module, Py_buffer *a, Py_buffer *b);
+
+static PyObject *
+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};
+
+ if (!_PyArg_ParseStack(args, nargs, "z*w*:py_buffer_converter",
+ &a, &b)) {
+ goto exit;
+ }
+ return_value = py_buffer_converter_impl(module, &a, &b);
+
+exit:
+ /* Cleanup for a */
+ if (a.obj) {
+ PyBuffer_Release(&a);
+ }
+ /* Cleanup for b */
+ if (b.obj) {
+ PyBuffer_Release(&b);
+ }
+
+ return return_value;
+}
+
+PyDoc_STRVAR(keywords__doc__,
+"keywords($module, /, a, b)\n"
+"--\n"
+"\n");
+
+#define KEYWORDS_METHODDEF \
+ {"keywords", _PyCFunction_CAST(keywords), METH_FASTCALL|METH_KEYWORDS, keywords__doc__},
+
+static PyObject *
+keywords_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+keywords(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 2
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(a), &_Py_ID(b), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"a", "b", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "keywords",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[2];
+ PyObject *a;
+ PyObject *b;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ a = args[0];
+ b = args[1];
+ return_value = keywords_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(keywords_kwonly__doc__,
+"keywords_kwonly($module, /, a, *, b)\n"
+"--\n"
+"\n");
+
+#define KEYWORDS_KWONLY_METHODDEF \
+ {"keywords_kwonly", _PyCFunction_CAST(keywords_kwonly), METH_FASTCALL|METH_KEYWORDS, keywords_kwonly__doc__},
+
+static PyObject *
+keywords_kwonly_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+keywords_kwonly(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 2
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(a), &_Py_ID(b), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"a", "b", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "keywords_kwonly",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[2];
+ PyObject *a;
+ PyObject *b;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 1, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ a = args[0];
+ b = args[1];
+ return_value = keywords_kwonly_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(keywords_opt__doc__,
+"keywords_opt($module, /, a, b=None, c=None)\n"
+"--\n"
+"\n");
+
+#define KEYWORDS_OPT_METHODDEF \
+ {"keywords_opt", _PyCFunction_CAST(keywords_opt), METH_FASTCALL|METH_KEYWORDS, keywords_opt__doc__},
+
+static PyObject *
+keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b, PyObject *c);
+
+static PyObject *
+keywords_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 3
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(a), &_Py_ID(b), &_Py_ID(c), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"a", "b", "c", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "keywords_opt",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[3];
+ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
+ PyObject *a;
+ PyObject *b = Py_None;
+ PyObject *c = Py_None;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ a = args[0];
+ if (!noptargs) {
+ goto skip_optional_pos;
+ }
+ if (args[1]) {
+ b = args[1];
+ if (!--noptargs) {
+ goto skip_optional_pos;
+ }
+ }
+ c = args[2];
+skip_optional_pos:
+ return_value = keywords_opt_impl(module, a, b, c);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(keywords_opt_kwonly__doc__,
+"keywords_opt_kwonly($module, /, a, b=None, *, c=None, d=None)\n"
+"--\n"
+"\n");
+
+#define KEYWORDS_OPT_KWONLY_METHODDEF \
+ {"keywords_opt_kwonly", _PyCFunction_CAST(keywords_opt_kwonly), METH_FASTCALL|METH_KEYWORDS, keywords_opt_kwonly__doc__},
+
+static PyObject *
+keywords_opt_kwonly_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c, PyObject *d);
+
+static PyObject *
+keywords_opt_kwonly(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 4
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(a), &_Py_ID(b), &_Py_ID(c), &_Py_ID(d), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"a", "b", "c", "d", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "keywords_opt_kwonly",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[4];
+ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
+ PyObject *a;
+ PyObject *b = Py_None;
+ PyObject *c = Py_None;
+ PyObject *d = Py_None;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ a = args[0];
+ if (!noptargs) {
+ goto skip_optional_pos;
+ }
+ if (args[1]) {
+ b = args[1];
+ if (!--noptargs) {
+ goto skip_optional_pos;
+ }
+ }
+skip_optional_pos:
+ if (!noptargs) {
+ goto skip_optional_kwonly;
+ }
+ if (args[2]) {
+ c = args[2];
+ if (!--noptargs) {
+ goto skip_optional_kwonly;
+ }
+ }
+ d = args[3];
+skip_optional_kwonly:
+ return_value = keywords_opt_kwonly_impl(module, a, b, c, d);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(keywords_kwonly_opt__doc__,
+"keywords_kwonly_opt($module, /, a, *, b=None, c=None)\n"
+"--\n"
+"\n");
+
+#define KEYWORDS_KWONLY_OPT_METHODDEF \
+ {"keywords_kwonly_opt", _PyCFunction_CAST(keywords_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, keywords_kwonly_opt__doc__},
+
+static PyObject *
+keywords_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c);
+
+static PyObject *
+keywords_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 3
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(a), &_Py_ID(b), &_Py_ID(c), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"a", "b", "c", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "keywords_kwonly_opt",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[3];
+ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
+ PyObject *a;
+ PyObject *b = Py_None;
+ PyObject *c = Py_None;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ a = args[0];
+ if (!noptargs) {
+ goto skip_optional_kwonly;
+ }
+ if (args[1]) {
+ b = args[1];
+ if (!--noptargs) {
+ goto skip_optional_kwonly;
+ }
+ }
+ c = args[2];
+skip_optional_kwonly:
+ return_value = keywords_kwonly_opt_impl(module, a, b, c);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(posonly_keywords__doc__,
+"posonly_keywords($module, a, /, b)\n"
+"--\n"
+"\n");
+
+#define POSONLY_KEYWORDS_METHODDEF \
+ {"posonly_keywords", _PyCFunction_CAST(posonly_keywords), METH_FASTCALL|METH_KEYWORDS, posonly_keywords__doc__},
+
+static PyObject *
+posonly_keywords_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+posonly_keywords(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 1
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(b), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"", "b", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "posonly_keywords",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[2];
+ PyObject *a;
+ PyObject *b;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ a = args[0];
+ b = args[1];
+ return_value = posonly_keywords_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(posonly_kwonly__doc__,
+"posonly_kwonly($module, a, /, *, b)\n"
+"--\n"
+"\n");
+
+#define POSONLY_KWONLY_METHODDEF \
+ {"posonly_kwonly", _PyCFunction_CAST(posonly_kwonly), METH_FASTCALL|METH_KEYWORDS, posonly_kwonly__doc__},
+
+static PyObject *
+posonly_kwonly_impl(PyObject *module, PyObject *a, PyObject *b);
+
+static PyObject *
+posonly_kwonly(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 1
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(b), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"", "b", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "posonly_kwonly",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[2];
+ PyObject *a;
+ PyObject *b;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 1, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ a = args[0];
+ b = args[1];
+ return_value = posonly_kwonly_impl(module, a, b);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(posonly_keywords_kwonly__doc__,
+"posonly_keywords_kwonly($module, a, /, b, *, c)\n"
+"--\n"
+"\n");
+
+#define POSONLY_KEYWORDS_KWONLY_METHODDEF \
+ {"posonly_keywords_kwonly", _PyCFunction_CAST(posonly_keywords_kwonly), METH_FASTCALL|METH_KEYWORDS, posonly_keywords_kwonly__doc__},
+
+static PyObject *
+posonly_keywords_kwonly_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c);
+
+static PyObject *
+posonly_keywords_kwonly(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 2
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(b), &_Py_ID(c), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"", "b", "c", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "posonly_keywords_kwonly",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[3];
+ PyObject *a;
+ PyObject *b;
+ PyObject *c;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 1, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ a = args[0];
+ b = args[1];
+ c = args[2];
+ return_value = posonly_keywords_kwonly_impl(module, a, b, c);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(posonly_keywords_opt__doc__,
+"posonly_keywords_opt($module, a, /, b, c=None, d=None)\n"
+"--\n"
+"\n");
+
+#define POSONLY_KEYWORDS_OPT_METHODDEF \
+ {"posonly_keywords_opt", _PyCFunction_CAST(posonly_keywords_opt), METH_FASTCALL|METH_KEYWORDS, posonly_keywords_opt__doc__},
+
+static PyObject *
+posonly_keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c, PyObject *d);
+
+static PyObject *
+posonly_keywords_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 3
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(b), &_Py_ID(c), &_Py_ID(d), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"", "b", "c", "d", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "posonly_keywords_opt",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[4];
+ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
+ PyObject *a;
+ PyObject *b;
+ PyObject *c = Py_None;
+ PyObject *d = Py_None;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 4, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ a = args[0];
+ b = args[1];
+ if (!noptargs) {
+ goto skip_optional_pos;
+ }
+ if (args[2]) {
+ c = args[2];
+ if (!--noptargs) {
+ goto skip_optional_pos;
+ }
+ }
+ d = args[3];
+skip_optional_pos:
+ return_value = posonly_keywords_opt_impl(module, a, b, c, d);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(posonly_opt_keywords_opt__doc__,
+"posonly_opt_keywords_opt($module, a, b=None, /, c=None, d=None)\n"
+"--\n"
+"\n");
+
+#define POSONLY_OPT_KEYWORDS_OPT_METHODDEF \
+ {"posonly_opt_keywords_opt", _PyCFunction_CAST(posonly_opt_keywords_opt), METH_FASTCALL|METH_KEYWORDS, posonly_opt_keywords_opt__doc__},
+
+static PyObject *
+posonly_opt_keywords_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c, PyObject *d);
+
+static PyObject *
+posonly_opt_keywords_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 2
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(c), &_Py_ID(d), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"", "", "c", "d", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "posonly_opt_keywords_opt",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[4];
+ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
+ PyObject *a;
+ PyObject *b = Py_None;
+ PyObject *c = Py_None;
+ PyObject *d = Py_None;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 4, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ a = args[0];
+ if (nargs < 2) {
+ goto skip_optional_posonly;
+ }
+ noptargs--;
+ b = args[1];
+skip_optional_posonly:
+ if (!noptargs) {
+ goto skip_optional_pos;
+ }
+ if (args[2]) {
+ c = args[2];
+ if (!--noptargs) {
+ goto skip_optional_pos;
+ }
+ }
+ d = args[3];
+skip_optional_pos:
+ return_value = posonly_opt_keywords_opt_impl(module, a, b, c, d);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(posonly_kwonly_opt__doc__,
+"posonly_kwonly_opt($module, a, /, *, b, c=None, d=None)\n"
+"--\n"
+"\n");
+
+#define POSONLY_KWONLY_OPT_METHODDEF \
+ {"posonly_kwonly_opt", _PyCFunction_CAST(posonly_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, posonly_kwonly_opt__doc__},
+
+static PyObject *
+posonly_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c, PyObject *d);
+
+static PyObject *
+posonly_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 3
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(b), &_Py_ID(c), &_Py_ID(d), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"", "b", "c", "d", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "posonly_kwonly_opt",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[4];
+ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
+ PyObject *a;
+ PyObject *b;
+ PyObject *c = Py_None;
+ PyObject *d = Py_None;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 1, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ a = args[0];
+ b = args[1];
+ if (!noptargs) {
+ goto skip_optional_kwonly;
+ }
+ if (args[2]) {
+ c = args[2];
+ if (!--noptargs) {
+ goto skip_optional_kwonly;
+ }
+ }
+ d = args[3];
+skip_optional_kwonly:
+ return_value = posonly_kwonly_opt_impl(module, a, b, c, d);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(posonly_opt_kwonly_opt__doc__,
+"posonly_opt_kwonly_opt($module, a, b=None, /, *, c=None, d=None)\n"
+"--\n"
+"\n");
+
+#define POSONLY_OPT_KWONLY_OPT_METHODDEF \
+ {"posonly_opt_kwonly_opt", _PyCFunction_CAST(posonly_opt_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, posonly_opt_kwonly_opt__doc__},
+
+static PyObject *
+posonly_opt_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c, PyObject *d);
+
+static PyObject *
+posonly_opt_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 2
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(c), &_Py_ID(d), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"", "", "c", "d", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "posonly_opt_kwonly_opt",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[4];
+ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
+ PyObject *a;
+ PyObject *b = Py_None;
+ PyObject *c = Py_None;
+ PyObject *d = Py_None;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ a = args[0];
+ if (nargs < 2) {
+ goto skip_optional_posonly;
+ }
+ noptargs--;
+ b = args[1];
+skip_optional_posonly:
+ if (!noptargs) {
+ goto skip_optional_kwonly;
+ }
+ if (args[2]) {
+ c = args[2];
+ if (!--noptargs) {
+ goto skip_optional_kwonly;
+ }
+ }
+ d = args[3];
+skip_optional_kwonly:
+ return_value = posonly_opt_kwonly_opt_impl(module, a, b, c, d);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(posonly_keywords_kwonly_opt__doc__,
+"posonly_keywords_kwonly_opt($module, a, /, b, *, c, d=None, e=None)\n"
+"--\n"
+"\n");
+
+#define POSONLY_KEYWORDS_KWONLY_OPT_METHODDEF \
+ {"posonly_keywords_kwonly_opt", _PyCFunction_CAST(posonly_keywords_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, posonly_keywords_kwonly_opt__doc__},
+
+static PyObject *
+posonly_keywords_kwonly_opt_impl(PyObject *module, PyObject *a, PyObject *b,
+ PyObject *c, PyObject *d, PyObject *e);
+
+static PyObject *
+posonly_keywords_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 4
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(b), &_Py_ID(c), &_Py_ID(d), &_Py_ID(e), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"", "b", "c", "d", "e", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "posonly_keywords_kwonly_opt",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[5];
+ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 3;
+ PyObject *a;
+ PyObject *b;
+ PyObject *c;
+ PyObject *d = Py_None;
+ PyObject *e = Py_None;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 1, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ a = args[0];
+ b = args[1];
+ c = args[2];
+ if (!noptargs) {
+ goto skip_optional_kwonly;
+ }
+ if (args[3]) {
+ d = args[3];
+ if (!--noptargs) {
+ goto skip_optional_kwonly;
+ }
+ }
+ e = args[4];
+skip_optional_kwonly:
+ return_value = posonly_keywords_kwonly_opt_impl(module, a, b, c, d, e);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(posonly_keywords_opt_kwonly_opt__doc__,
+"posonly_keywords_opt_kwonly_opt($module, a, /, b, c=None, *, d=None,\n"
+" e=None)\n"
+"--\n"
+"\n");
+
+#define POSONLY_KEYWORDS_OPT_KWONLY_OPT_METHODDEF \
+ {"posonly_keywords_opt_kwonly_opt", _PyCFunction_CAST(posonly_keywords_opt_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, posonly_keywords_opt_kwonly_opt__doc__},
+
+static PyObject *
+posonly_keywords_opt_kwonly_opt_impl(PyObject *module, PyObject *a,
+ PyObject *b, PyObject *c, PyObject *d,
+ PyObject *e);
+
+static PyObject *
+posonly_keywords_opt_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 4
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(b), &_Py_ID(c), &_Py_ID(d), &_Py_ID(e), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"", "b", "c", "d", "e", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "posonly_keywords_opt_kwonly_opt",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[5];
+ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
+ PyObject *a;
+ PyObject *b;
+ PyObject *c = Py_None;
+ PyObject *d = Py_None;
+ PyObject *e = Py_None;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 3, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ a = args[0];
+ b = args[1];
+ if (!noptargs) {
+ goto skip_optional_pos;
+ }
+ if (args[2]) {
+ c = args[2];
+ if (!--noptargs) {
+ goto skip_optional_pos;
+ }
+ }
+skip_optional_pos:
+ if (!noptargs) {
+ goto skip_optional_kwonly;
+ }
+ if (args[3]) {
+ d = args[3];
+ if (!--noptargs) {
+ goto skip_optional_kwonly;
+ }
+ }
+ e = args[4];
+skip_optional_kwonly:
+ return_value = posonly_keywords_opt_kwonly_opt_impl(module, a, b, c, d, e);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(posonly_opt_keywords_opt_kwonly_opt__doc__,
+"posonly_opt_keywords_opt_kwonly_opt($module, a, b=None, /, c=None, *,\n"
+" d=None)\n"
+"--\n"
+"\n");
+
+#define POSONLY_OPT_KEYWORDS_OPT_KWONLY_OPT_METHODDEF \
+ {"posonly_opt_keywords_opt_kwonly_opt", _PyCFunction_CAST(posonly_opt_keywords_opt_kwonly_opt), METH_FASTCALL|METH_KEYWORDS, posonly_opt_keywords_opt_kwonly_opt__doc__},
+
+static PyObject *
+posonly_opt_keywords_opt_kwonly_opt_impl(PyObject *module, PyObject *a,
+ PyObject *b, PyObject *c,
+ PyObject *d);
+
+static PyObject *
+posonly_opt_keywords_opt_kwonly_opt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 2
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(c), &_Py_ID(d), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"", "", "c", "d", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "posonly_opt_keywords_opt_kwonly_opt",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[4];
+ Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
+ PyObject *a;
+ PyObject *b = Py_None;
+ PyObject *c = Py_None;
+ PyObject *d = Py_None;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ a = args[0];
+ if (nargs < 2) {
+ goto skip_optional_posonly;
+ }
+ noptargs--;
+ b = args[1];
+skip_optional_posonly:
+ if (!noptargs) {
+ goto skip_optional_pos;
+ }
+ if (args[2]) {
+ c = args[2];
+ if (!--noptargs) {
+ goto skip_optional_pos;
+ }
+ }
+skip_optional_pos:
+ if (!noptargs) {
+ goto skip_optional_kwonly;
+ }
+ d = args[3];
+skip_optional_kwonly:
+ return_value = posonly_opt_keywords_opt_kwonly_opt_impl(module, a, b, c, d);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(keyword_only_parameter__doc__,
+"keyword_only_parameter($module, /, *, a)\n"
+"--\n"
+"\n");
+
+#define KEYWORD_ONLY_PARAMETER_METHODDEF \
+ {"keyword_only_parameter", _PyCFunction_CAST(keyword_only_parameter), METH_FASTCALL|METH_KEYWORDS, keyword_only_parameter__doc__},
+
+static PyObject *
+keyword_only_parameter_impl(PyObject *module, PyObject *a);
+
+static PyObject *
+keyword_only_parameter(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+ #define NUM_KEYWORDS 1
+ static struct {
+ PyGC_Head _this_is_not_used;
+ PyObject_VAR_HEAD
+ PyObject *ob_item[NUM_KEYWORDS];
+ } _kwtuple = {
+ .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+ .ob_item = { &_Py_ID(a), },
+ };
+ #undef NUM_KEYWORDS
+ #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+ #else // !Py_BUILD_CORE
+ # define KWTUPLE NULL
+ #endif // !Py_BUILD_CORE
+
+ static const char * const _keywords[] = {"a", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "keyword_only_parameter",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[1];
+ PyObject *a;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 0, 1, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ a = args[0];
+ return_value = keyword_only_parameter_impl(module, a);
+
+exit:
+ return return_value;
+}
+/*[clinic end generated code: output=a9212f8e6ba18bba input=a9049054013a1b77]*/
diff --git a/Tools/build/generate_stdlib_module_names.py b/Tools/build/generate_stdlib_module_names.py
index 4534c3e6a596..c8a23f41fdd4 100644
--- a/Tools/build/generate_stdlib_module_names.py
+++ b/Tools/build/generate_stdlib_module_names.py
@@ -29,6 +29,7 @@
'_ctypes_test',
'_testbuffer',
'_testcapi',
+ '_testclinic',
'_testconsole',
'_testimportmultiple',
'_testinternalcapi',
diff --git a/configure b/configure
index b5c1eb51fd3e..047fd94219d5 100755
--- a/configure
+++ b/configure
@@ -642,6 +642,8 @@ MODULE__TESTBUFFER_FALSE
MODULE__TESTBUFFER_TRUE
MODULE__TESTINTERNALCAPI_FALSE
MODULE__TESTINTERNALCAPI_TRUE
+MODULE__TESTCLINIC_FALSE
+MODULE__TESTCLINIC_TRUE
MODULE__TESTCAPI_FALSE
MODULE__TESTCAPI_TRUE
MODULE__HASHLIB_FALSE
@@ -27747,6 +27749,40 @@ fi
$as_echo "$py_cv_module__testcapi" >&6; }
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for stdlib extension module _testclinic" >&5
+$as_echo_n "checking for stdlib extension module _testclinic... " >&6; }
+ if test "$py_cv_module__testclinic" != "n/a"; then :
+
+ if test "$TEST_MODULES" = yes; then :
+ if true; then :
+ py_cv_module__testclinic=yes
+else
+ py_cv_module__testclinic=missing
+fi
+else
+ py_cv_module__testclinic=disabled
+fi
+
+fi
+ as_fn_append MODULE_BLOCK "MODULE__TESTCLINIC_STATE=$py_cv_module__testclinic$as_nl"
+ if test "x$py_cv_module__testclinic" = xyes; then :
+
+
+
+
+fi
+ if test "$py_cv_module__testclinic" = yes; then
+ MODULE__TESTCLINIC_TRUE=
+ MODULE__TESTCLINIC_FALSE='#'
+else
+ MODULE__TESTCLINIC_TRUE='#'
+ MODULE__TESTCLINIC_FALSE=
+fi
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $py_cv_module__testclinic" >&5
+$as_echo "$py_cv_module__testclinic" >&6; }
+
+
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for stdlib extension module _testinternalcapi" >&5
$as_echo_n "checking for stdlib extension module _testinternalcapi... " >&6; }
if test "$py_cv_module__testinternalcapi" != "n/a"; then :
@@ -28466,6 +28502,10 @@ if test -z "${MODULE__TESTCAPI_TRUE}" && test -z "${MODULE__TESTCAPI_FALSE}"; th
as_fn_error $? "conditional \"MODULE__TESTCAPI\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi
+if test -z "${MODULE__TESTCLINIC_TRUE}" && test -z "${MODULE__TESTCLINIC_FALSE}"; then
+ as_fn_error $? "conditional \"MODULE__TESTCLINIC\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
if test -z "${MODULE__TESTINTERNALCAPI_TRUE}" && test -z "${MODULE__TESTINTERNALCAPI_FALSE}"; then
as_fn_error $? "conditional \"MODULE__TESTINTERNALCAPI\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
diff --git a/configure.ac b/configure.ac
index 7a9b16407c61..19f12e8d5402 100644
--- a/configure.ac
+++ b/configure.ac
@@ -7350,6 +7350,7 @@ PY_STDLIB_MOD([_hashlib], [], [test "$ac_cv_working_openssl_hashlib" = yes],
dnl test modules
PY_STDLIB_MOD([_testcapi], [test "$TEST_MODULES" = yes])
+PY_STDLIB_MOD([_testclinic], [test "$TEST_MODULES" = yes])
PY_STDLIB_MOD([_testinternalcapi], [test "$TEST_MODULES" = yes])
PY_STDLIB_MOD([_testbuffer], [test "$TEST_MODULES" = yes])
PY_STDLIB_MOD([_testimportmultiple], [test "$TEST_MODULES" = yes], [test "$ac_cv_func_dlopen" = yes])
More information about the Python-checkins
mailing list