Simplify some test cases

Author: cmaloney

Lib/test/test_clinic.py

@@ -2751,47 +2751,6 @@ class Foo "FooObject *" "Foo_Type"
         self.assertTrue(func.vectorcall)
         self.assertTrue(func.vectorcall_exact_only)
 
-    def test_vectorcall_init_with_kwargs(self):
-        block = """
-            module m
-            class Foo "FooObject *" "Foo_Type"
-            @vectorcall
-            Foo.__init__
-                source: object = NULL
-                encoding: str = NULL
-                errors: str = NULL
-        """
-        func = self.parse_function(block, signatures_in_block=3,
-                                   function_index=2)
-        self.assertTrue(func.vectorcall)
-
-    def test_vectorcall_new_with_kwargs(self):
-        block = """
-            module m
-            class Foo "FooObject *" "Foo_Type"
-            @classmethod
-            @vectorcall
-            Foo.__new__
-                source: object = NULL
-                *
-                encoding: str = NULL
-                errors: str = NULL
-        """
-        func = self.parse_function(block, signatures_in_block=3,
-                                   function_index=2)
-        self.assertTrue(func.vectorcall)
-
-    def test_vectorcall_init_no_args(self):
-        block = """
-            module m
-            class Foo "FooObject *" "Foo_Type"
-            @vectorcall
-            Foo.__init__
-        """
-        func = self.parse_function(block, signatures_in_block=3,
-                                   function_index=2)
-        self.assertTrue(func.vectorcall)
-
     def test_vectorcall_zero_arg(self):
         block = """
             module m
@@ -4478,33 +4437,19 @@ def test_kwds_with_pos_only_and_stararg(self):
 class VectorcallFunctionalTest(unittest.TestCase):
     """Runtime tests for @vectorcall exemplar types."""
 
-    def test_vc_new_no_args(self):
-        obj = ac_tester.VcNew()
-        self.assertIsInstance(obj, ac_tester.VcNew)
-
-    def test_vc_new_with_arg(self):
-        obj = ac_tester.VcNew(1)
-        self.assertIsInstance(obj, ac_tester.VcNew)
-
-    def test_vc_new_with_kwarg(self):
-        obj = ac_tester.VcNew(a=1)
-        self.assertIsInstance(obj, ac_tester.VcNew)
+    def test_vc_new(self):
+        self.assertIsInstance(ac_tester.VcNew(), ac_tester.VcNew)
+        self.assertIsInstance(ac_tester.VcNew(1), ac_tester.VcNew)
+        self.assertIsInstance(ac_tester.VcNew(a=1), ac_tester.VcNew)
 
     def test_vc_new_rejects_extra_args(self):
         with self.assertRaises(TypeError):
             ac_tester.VcNew(1, 2)
 
-    def test_vc_init_required_pos_only(self):
-        obj = ac_tester.VcInit(1)
-        self.assertIsInstance(obj, ac_tester.VcInit)
-
-    def test_vc_init_with_keyword(self):
-        obj = ac_tester.VcInit(1, b=2)
-        self.assertIsInstance(obj, ac_tester.VcInit)
-
-    def test_vc_init_with_positional_optional(self):
-        obj = ac_tester.VcInit(1, 2)
-        self.assertIsInstance(obj, ac_tester.VcInit)
+    def test_vc_init(self):
+        self.assertIsInstance(ac_tester.VcInit(1), ac_tester.VcInit)
+        self.assertIsInstance(ac_tester.VcInit(1, 2), ac_tester.VcInit)
+        self.assertIsInstance(ac_tester.VcInit(1, b=2), ac_tester.VcInit)
 
     def test_vc_init_missing_required(self):
         with self.assertRaises(TypeError):
@@ -4515,13 +4460,9 @@ def test_vc_init_rejects_a_as_keyword(self):
         with self.assertRaises(TypeError):
             ac_tester.VcInit(a=1)
 
-    def test_vc_new_exact_one_arg(self):
-        obj = ac_tester.VcNewExact(1)
-        self.assertIsInstance(obj, ac_tester.VcNewExact)
-
-    def test_vc_new_exact_two_args(self):
-        obj = ac_tester.VcNewExact(1, 2)
-        self.assertIsInstance(obj, ac_tester.VcNewExact)
+    def test_vc_new_exact(self):
+        self.assertIsInstance(ac_tester.VcNewExact(1), ac_tester.VcNewExact)
+        self.assertIsInstance(ac_tester.VcNewExact(1, 2), ac_tester.VcNewExact)
 
     def test_vc_new_exact_missing_required(self):
         with self.assertRaises(TypeError):
@@ -4539,17 +4480,10 @@ def test_vc_new_zeroarg_no_args(self):
         result = ac_tester.VcNewZeroArg()
         self.assertIs(result, None)
 
-    def test_vc_new_zeroarg_with_pos(self):
-        obj = ac_tester.VcNewZeroArg(1)
-        self.assertIsInstance(obj, ac_tester.VcNewZeroArg)
-
-    def test_vc_new_zeroarg_with_kwonly(self):
-        obj = ac_tester.VcNewZeroArg(b=2)
-        self.assertIsInstance(obj, ac_tester.VcNewZeroArg)
-
-    def test_vc_new_zeroarg_with_both(self):
-        obj = ac_tester.VcNewZeroArg(1, b=2)
-        self.assertIsInstance(obj, ac_tester.VcNewZeroArg)
+    def test_vc_new_zeroarg_with_args(self):
+        self.assertIsInstance(ac_tester.VcNewZeroArg(1), ac_tester.VcNewZeroArg)
+        self.assertIsInstance(ac_tester.VcNewZeroArg(b=2), ac_tester.VcNewZeroArg)
+        self.assertIsInstance(ac_tester.VcNewZeroArg(1, b=2), ac_tester.VcNewZeroArg)
 
     def test_vc_new_zeroarg_rejects_a_as_keyword(self):
         # 'a' is positional-only

Modules/_testclinic.c

@@ -2322,16 +2322,9 @@ output pop
 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=e7c7c42daced52b0]*/
 
 
-/*
- * Vectorcall exemplars.
- *
- * Each type exercises a different @vectorcall code-generation path.
- * There is one type per exemplar because tp_vectorcall is a single slot.
- */
-
+/* @vectorcall test types. One type per exemplar because tp_vectorcall is a single slot. */
 
-/* --- VcNew: @vectorcall on __new__, single pos-or-kw optional
- *     (general + kw fast-path, METHOD_NEW finale) --- */
+/* VcNew: __new__ with one optional positional-or-keyword arg */
 
 /*[clinic input]
 class _testclinic.VcNew "PyObject *" "&VcNew_Type"
@@ -2358,8 +2351,7 @@ static PyTypeObject VcNew_Type = {
 };
 
 
-/* --- VcInit: @vectorcall on __init__, pos-only + pos-or-kw optional
- *     (general + kw fast-path) --- */
+/* VcInit: __init__ with one required positional-only and one optional keyword arg */
 
 /*[clinic input]
 class _testclinic.VcInit "PyObject *" "&VcInit_Type"
@@ -2388,8 +2380,7 @@ static PyTypeObject VcInit_Type = {
 };
 
 
-/* --- VcNewExact: @vectorcall exact_only on __new__, pos-only required +
- *     pos-or-kw optional (general + kw fast-path + exact_only guard) --- */
+/* VcNewExact: __new__ with exact_only; subclasses fall back to tp_new */
 
 /*[clinic input]
 class _testclinic.VcNewExact "PyObject *" "&VcNewExact_Type"
@@ -2418,8 +2409,7 @@ static PyTypeObject VcNewExact_Type = {
 };
 
 
-/* --- VcNewZeroArg: @vectorcall zero_arg on __new__, pos-only optional +
- *     kw-only optional (general path, no kw fast-path + zero_arg) --- */
+/* VcNewZeroArg: __new__ with zero_arg; returns Py_None when called with no args */
 
 /*[clinic input]
 class _testclinic.VcNewZeroArg "PyObject *" "&VcNewZeroArg_Type"