Make tests generic

python · neonene · Apr 16, 2025 · Apr 16, 2025 · Apr 16, 2025 · Apr 16, 2025
commit db47683afae91061a22b543158543162cb961c0a
@@ -7155,49 +7155,75 @@ def test_datetime_from_timestamp(self):
 
                     self.assertEqual(dt_orig, dt_rt)
 
-    def test_type_check_in_subinterp(self):
+    def assert_python_ok_in_subinterp(self, script,
+                                      setup='_testcapi.test_datetime_capi()',
+                                      mainsetup='_testcapi.test_datetime_capi()',
+                                      config='isolated'):
         # iOS requires the use of the custom framework loader,
         # not the ExtensionFileLoader.
         if sys.platform == "ios":
             extension_loader = "AppleFrameworkLoader"
         else:
             extension_loader = "ExtensionFileLoader"
 
-        script = textwrap.dedent(f"""
+        maincode = textwrap.dedent(f'''
+            import textwrap
+            from test import support
+
+            subcode = textwrap.dedent("""
+                if {_interpreters is None}:
+                    import _testcapi
+                else:
+                    import importlib.machinery
+                    import importlib.util
+                    fullname = '_testcapi_datetime'
+                    origin = importlib.util.find_spec('_testcapi').origin
+                    loader = importlib.machinery.{extension_loader}(fullname, origin)
+                    spec = importlib.util.spec_from_loader(fullname, loader)
+                    _testcapi = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(_testcapi)
+
+            $SETUP$
+            $SCRIPT$
+            """)
+
+            import _testcapi
+            $MAINSETUP$
+
             if {_interpreters is None}:
-                import _testcapi as module
-                module.test_datetime_capi()
+                ret = support.run_in_subinterp(subcode)
             else:
-                import importlib.machinery
-                import importlib.util
-                fullname = '_testcapi_datetime'
-                origin = importlib.util.find_spec('_testcapi').origin
-                loader = importlib.machinery.{extension_loader}(fullname, origin)
-                spec = importlib.util.spec_from_loader(fullname, loader)
-                module = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(module)
-                module.test_datetime_capi()
+                import _interpreters
+                config = _interpreters.new_config('{config}').__dict__
+                ret = support.run_in_subinterp_with_config(subcode, **config)
+
+            assert ret == 0
+
+        ''').replace('$MAINSETUP$', mainsetup)
+        maincode = maincode.replace('$SETUP$', textwrap.indent(setup, '\x20'*4))
+        maincode = maincode.replace('$SCRIPT$', textwrap.indent(script, '\x20'*4))
+
+        res = script_helper.assert_python_ok('-c', maincode)
+        return res
 
+    def test_type_check_in_subinterp(self):
+        script = textwrap.dedent(f"""
             def run(type_checker, obj):
                 if not type_checker(obj, True):
                     raise TypeError(f'{{type(obj)}} is not C API type')
 
             import _datetime
-            run(module.datetime_check_date,     _datetime.date.today())
-            run(module.datetime_check_datetime, _datetime.datetime.now())
-            run(module.datetime_check_time,     _datetime.time(12, 30))
-            run(module.datetime_check_delta,    _datetime.timedelta(1))
-            run(module.datetime_check_tzinfo,   _datetime.tzinfo())
+            run(_testcapi.datetime_check_date,     _datetime.date.today())
+            run(_testcapi.datetime_check_datetime, _datetime.datetime.now())
+            run(_testcapi.datetime_check_time,     _datetime.time(12, 30))
+            run(_testcapi.datetime_check_delta,    _datetime.timedelta(1))
+            run(_testcapi.datetime_check_tzinfo,   _datetime.tzinfo())
         """)
-        if _interpreters is None:
-            ret = support.run_in_subinterp(script)
-            self.assertEqual(ret, 0)
-        else:
-            for name in ('isolated', 'legacy'):
-                with self.subTest(name):
-                    config = _interpreters.new_config(name).__dict__
-                    ret = support.run_in_subinterp_with_config(script, **config)
-                    self.assertEqual(ret, 0)
+        self.assert_python_ok_in_subinterp(script, mainsetup='')
+        if _interpreters is not None:
+            with self.subTest('legacy'):
+                self.assert_python_ok_in_subinterp(script, mainsetup='',
+                                                   config='legacy')
 
 
 class ExtensionModuleTests(unittest.TestCase):
@@ -7284,6 +7310,7 @@ def gen():
                 try:
                     yield
                 finally:
+                    # Exceptions are ignored here
                     assert not sys.modules
                     td = _datetime.timedelta(days=1)
                     assert td.days == 1
@@ -7315,55 +7342,9 @@ def gen():
         res = script_helper.assert_python_ok('-c', script)
         self.assertFalse(res.err)
 
-    def run_script_132413(self, script):
-        # iOS requires the use of the custom framework loader,
-        # not the ExtensionFileLoader.
-        if sys.platform == "ios":
-            extension_loader = "AppleFrameworkLoader"
-        else:
-            extension_loader = "ExtensionFileLoader"
-
-        main_interp_script = textwrap.dedent(f'''
-            import textwrap
-            from test import support
-
-            sub_script = textwrap.dedent("""
-                if {_interpreters is None}:
-                    import _testcapi as module
-                else:
-                    import importlib.machinery
-                    import importlib.util
-                    fullname = '_testcapi_datetime'
-                    origin = importlib.util.find_spec('_testcapi').origin
-                    loader = importlib.machinery.{extension_loader}(fullname, origin)
-                    spec = importlib.util.spec_from_loader(fullname, loader)
-                    module = importlib.util.module_from_spec(spec)
-                    spec.loader.exec_module(module)
-
-                # Skip calling test_datetime_capi()
-                $REPLACE_ME$
-            """)
-
-            import _testcapi
-            _testcapi.test_datetime_capi()
-
-            if {_interpreters is None}:
-                ret = support.run_in_subinterp(sub_script)
-            else:
-                import _interpreters
-                config = _interpreters.new_config('isolated').__dict__
-                ret = support.run_in_subinterp_with_config(sub_script, **config)
-
-            assert ret == 0
-
-        ''').replace('$REPLACE_ME$', textwrap.indent(script, '\x20'*4))
-
-        res = script_helper.assert_python_ok('-c', main_interp_script)
-        return res
-
     def test_static_type_at_shutdown3(self):
         script = textwrap.dedent("""
-            timedelta = module.get_delta_type()
+            timedelta = _testcapi.get_capi_types()['timedelta']
 
             def gen():
                 try:
@@ -7374,19 +7355,18 @@ def gen():
             it = gen()
             next(it)
         """)
-        res = self.run_script_132413(script)
+        res = CapiTest.assert_python_ok_in_subinterp(self, script, setup='')
         self.assertIn(b'ImportError: sys.meta_path is None', res.err)
 
     def test_static_type_before_shutdown(self):
         script = textwrap.dedent(f"""
             import sys
             assert '_datetime' not in sys.modules
-            timedelta = module.get_delta_type()
+            timedelta = _testcapi.get_capi_types()['timedelta']
             timedelta(days=1)
             assert '_datetime' in sys.modules
         """)
-        res = self.run_script_132413(script)
-        self.assertFalse(res.err)
+        CapiTest.assert_python_ok_in_subinterp(self, script, setup='')
 
     def test_remain_only_one_module(self):
         script = textwrap.dedent("""
@@ -7403,8 +7383,7 @@ def test_remain_only_one_module(self):
                 gc.collect()
                 assert len(ws) == 1
         """)
-        res = script_helper.assert_python_ok('-c', script)
-        self.assertFalse(res.err)
+        script_helper.assert_python_ok('-c', script)
 
     @unittest.skipIf(not support.Py_DEBUG, "Debug builds only")
     def test_no_leak(self):

diff --git a/Modules/_testcapi/datetime.c b/Modules/_testcapi/datetime.c
@@ -454,9 +454,34 @@
 }
 
 static PyObject *
-get_delta_type(PyObject *self, PyObject *args)
+get_capi_types(PyObject *self, PyObject *args)
 {
-    return PyDateTimeAPI ? Py_NewRef(PyDateTimeAPI->DeltaType) : Py_None;
+    if (PyDateTimeAPI == NULL) {
+        Py_RETURN_NONE;
+    }
+    PyObject *dict = PyDict_New();
+    if (dict == NULL) {
+        return NULL;
+    }
+    if (PyDict_SetItemString(dict, "date", PyDateTimeAPI->DateType) < 0) {
+        goto error;
+    }
+    if (PyDict_SetItemString(dict, "time", PyDateTimeAPI->TimeType) < 0) {
+        goto error;
+    }
+    if (PyDict_SetItemString(dict, "datetime", PyDateTimeAPI->DateTimeType) < 0) {
+        goto error;
+    }
+    if (PyDict_SetItemString(dict, "timedelta", PyDateTimeAPI->DeltaType) < 0) {
+        goto error;
+    }
+    if (PyDict_SetItemString(dict, "tzinfo", PyDateTimeAPI->TZInfoType) < 0) {
+        goto error;
+    }
+    return dict;
+error:
+    Py_DECREF(dict);
+    return NULL;
 }
 
 static PyMethodDef test_methods[] = {
@@ -475,11 +500,11 @@
     {"get_datetime_fromdateandtimeandfold", get_datetime_fromdateandtimeandfold, METH_VARARGS},
     {"get_datetime_fromtimestamp",  get_datetime_fromtimestamp,     METH_VARARGS},
     {"get_delta_fromdsu",           get_delta_fromdsu,              METH_VARARGS},
-    {"get_delta_type",               get_delta_type,                METH_NOARGS},
     {"get_time_fromtime",           get_time_fromtime,              METH_VARARGS},
     {"get_time_fromtimeandfold",    get_time_fromtimeandfold,       METH_VARARGS},
     {"get_timezone_utc_capi",       get_timezone_utc_capi,          METH_VARARGS},
     {"get_timezones_offset_zero",   get_timezones_offset_zero,      METH_NOARGS},
+    {"get_capi_types",              get_capi_types,                 METH_NOARGS},
     {"make_timezones_capi",         make_timezones_capi,            METH_NOARGS},
     {"test_datetime_capi",          test_datetime_capi,             METH_NOARGS},
     {NULL},