Revert to original (main)

Author: neonene

Lib/test/datetimetester.py

@@ -7155,73 +7155,48 @@ def test_datetime_from_timestamp(self):
 
                     self.assertEqual(dt_orig, dt_rt)
 
-    def assert_python_ok_in_subinterp(self, script, init='', fini='',
-                                      repeat=1, config='isolated'):
+    def test_type_check_in_subinterp(self):
         # iOS requires the use of the custom framework loader,
         # not the ExtensionFileLoader.
         if sys.platform == "ios":
             extension_loader = "AppleFrameworkLoader"
         else:
             extension_loader = "ExtensionFileLoader"
 
-        code = textwrap.dedent(f'''
-            subinterp_code = """
+        script = textwrap.dedent(f"""
             if {_interpreters is None}:
-                import _testcapi
+                import _testcapi as module
+                module.test_datetime_capi()
             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)
-            interp_index = $INTERP_INDEX$
-            setup = _testcapi.test_datetime_capi_newinterp  # call it if needed
-            $SCRIPT$
-            """
+                module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(module)
 
-            import _testcapi
-            from test import support
-            setup = _testcapi.test_datetime_capi_newinterp
-            $INIT$
-
-            for idx in range({repeat}):
-                subcode = subinterp_code.replace('$INTERP_INDEX$', str(idx))
-                if {_interpreters is None}:
-                    ret = support.run_in_subinterp(subcode)
-                else:
-                    import _interpreters
-                    config = _interpreters.new_config('{config}').__dict__
-                    ret = support.run_in_subinterp_with_config(subcode, **config)
-                assert ret == 0
-            $FINI$
-        ''')
-        code = code.replace('$INIT$', init).replace('$FINI$', fini)
-        code = code.replace('$SCRIPT$', script)
-
-        res = script_helper.assert_python_ok('-c', code)
-        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')
 
-            setup()
             import _datetime
-            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())
-            """)
-        self.assert_python_ok_in_subinterp(script)
-        if _interpreters is not None:
-            with self.subTest(name := 'legacy'):
-                self.assert_python_ok_in_subinterp(script, config=name)
+            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())
+        """)
+        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)
 
 
 class ExtensionModuleTests(unittest.TestCase):
@@ -7230,9 +7205,6 @@ def setUp(self):
         if self.__class__.__name__.endswith('Pure'):
             self.skipTest('Not relevant in pure Python')
 
-    def assert_python_ok_in_subinterp(self, *args, **kwargs):
-        return CapiTest.assert_python_ok_in_subinterp(self, *args, **kwargs)
-
     @support.cpython_only
     def test_gh_120161(self):
         with self.subTest('simple'):
@@ -7298,117 +7270,8 @@ def test_update_type_cache(self):
                 assert isinstance(_datetime.timezone.utc, _datetime.tzinfo)
                 del sys.modules['_datetime']
             """)
-        res = script_helper.assert_python_ok('-c', script)
-        self.assertFalse(res.err)
-
-    def test_module_free(self):
-        script = textwrap.dedent("""
-            import sys
-            import gc
-            import weakref
-            ws = weakref.WeakSet()
-            for _ in range(3):
-                import _datetime
-                timedelta = _datetime.timedelta  # static type
-                ws.add(_datetime)
-                del sys.modules['_datetime']
-                del _datetime
-                gc.collect()
-                assert len(ws) == 1  # only one remains
-            """)
         script_helper.assert_python_ok('-c', script)
 
-    @unittest.skipIf(not support.Py_DEBUG, "Debug builds only")
-    def test_no_leak(self):
-        script = textwrap.dedent("""
-            import datetime
-            datetime.datetime.strptime('20000101', '%Y%m%d').strftime('%Y%m%d')
-            """)
-        res = script_helper.assert_python_ok('-X', 'showrefcount', '-c', script)
-        self.assertIn(b'[0 refs, 0 blocks]', res.err)
-
-    def test_static_type_on_subinterp(self):
-        script = textwrap.dedent("""
-            date = _testcapi.get_capi_types()['date']
-            date.today
-            """)
-        with_setup = 'setup()' + script
-        with self.subTest('[PyDateTime_IMPORT] main: no, sub: yes'):
-            self.assert_python_ok_in_subinterp(with_setup)
-
-        with self.subTest('[PyDateTime_IMPORT] main: yes, sub: yes'):
-            # Fails if the setup() means test_datetime_capi() rather than
-            # test_datetime_capi_newinterp()
-            self.assert_python_ok_in_subinterp(with_setup, 'setup()')
-            self.assert_python_ok_in_subinterp('setup()', fini=with_setup)
-            self.assert_python_ok_in_subinterp(with_setup, repeat=2)
-
-        with_import = 'import _datetime' + script
-        with self.subTest('Explicit import'):
-            self.assert_python_ok_in_subinterp(with_import, 'setup()')
-
-        with_import = textwrap.dedent("""
-            timedelta = _testcapi.get_capi_types()['timedelta']
-            timedelta(days=1)
-            """) + script
-        with self.subTest('Implicit import'):
-            self.assert_python_ok_in_subinterp(with_import, 'setup()')
-
-    def test_static_type_at_shutdown(self):
-        # gh-132413
-        script = textwrap.dedent("""
-            import sys
-            import _datetime
-            timedelta = _datetime.timedelta
-
-            def gen():
-                try:
-                    yield
-                finally:
-                    # Exceptions are ignored here
-                    assert not sys.modules
-                    td = _datetime.timedelta(days=1)
-                    assert td.days == 1
-                    td = timedelta(days=1)
-                    assert td.days == 1
-                    assert not sys.modules
-
-            it = gen()
-            next(it)
-            """)
-        with self.subTest('MainInterpreter'):
-            res = script_helper.assert_python_ok('-c', script)
-            self.assertFalse(res.err)
-        with self.subTest('Subinterpreter'):
-            res = self.assert_python_ok_in_subinterp(script)
-            self.assertFalse(res.err)
-
-        script = textwrap.dedent("""
-            import sys
-            timedelta = _testcapi.get_capi_types()['timedelta']
-
-            def gen():
-                try:
-                    yield
-                finally:
-                    # Exceptions are ignored here
-                    assert not sys.modules
-                    td = timedelta(days=1)
-                    assert td.days == 1
-                    assert not sys.modules
-
-            it = gen()
-            next(it)
-            """)
-        with self.subTest('[PyDateTime_IMPORT] main: yes, sub: no'):
-            res = self.assert_python_ok_in_subinterp(script, 'setup()')
-            self.assertIn(b'ImportError: sys.meta_path is None', res.err)
-
-        with_import = 'setup()' + script
-        with self.subTest('[PyDateTime_IMPORT] main: no, sub: yes'):
-            res = self.assert_python_ok_in_subinterp(with_import)
-            self.assertFalse(res.err)
-
 
 def load_tests(loader, standard_tests, pattern):
     standard_tests.addTest(ZoneInfoCompleteTest())

Lib/test/test_embed.py

@@ -440,34 +440,6 @@ def test_datetime_reset_strptime(self):
         out, err = self.run_embedded_interpreter("test_repeated_init_exec", code)
         self.assertEqual(out, '20000101\n' * INIT_LOOPS)
 
-    def test_datetime_capi_at_shutdown(self):
-        # gh-132413: datetime module is currently tested in an interp's life.
-        # PyDateTime_IMPORT needs to be called at least once after the restart.
-        code = textwrap.dedent("""
-            import sys
-            import _testcapi
-            _testcapi.test_datetime_capi_newinterp()
-            timedelta = _testcapi.get_capi_types()['timedelta']
-
-            def gen():
-                try:
-                    yield
-                finally:
-                    assert not sys.modules
-                    res = 0
-                    try:
-                        timedelta(days=1)
-                        res = 1
-                    except ImportError:
-                        res = 2
-                    print(res)
-
-            it = gen()
-            next(it)
-        """)
-        out, err = self.run_embedded_interpreter("test_repeated_init_exec", code)
-        self.assertEqual(out, '1\n' * INIT_LOOPS)
-
     def test_static_types_inherited_slots(self):
         script = textwrap.dedent("""
             import test.support