minimize test

Author: neonene

Lib/test/datetimetester.py

@@ -7275,61 +7275,24 @@ def test_update_type_cache(self):
             """)
         script_helper.assert_python_ok('-c', script)
 
-    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) == 0
-            """)
-        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_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
+                    # sys.modules is empty
+                    _datetime.timedelta(days=1)
+                    timedelta(days=1)
 
             it = gen()
             next(it)
             """)
-        res = script_helper.assert_python_ok('-c', script)
-        self.assertFalse(res.err)
-
-        if support.Py_DEBUG:
-            with self.subTest('Refleak'):
-                res = script_helper.assert_python_ok('-X', 'showrefcount', '-c', script)
-                self.assertIn(b'[0 refs, 0 blocks]', res.err)
+        script_helper.assert_python_ok('-c', script)
 
 
 def load_tests(loader, standard_tests, pattern):

Lib/test/test_embed.py

@@ -440,49 +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_type_address(self):
-        # Check if the C-API types keep their addresses until runtime shutdown
-        code = textwrap.dedent("""
-            import _datetime as d
-            print(
-                f'{id(d.date)}'
-                f'{id(d.time)}'
-                f'{id(d.datetime)}'
-                f'{id(d.timedelta)}'
-                f'{id(d.tzinfo)}'
-            )
-        """)
-        out, err = self.run_embedded_interpreter("test_repeated_init_exec", code)
-        self.assertEqual(len(set(out.splitlines())), 1)
-
-    def test_datetime_capi_at_shutdown(self):
-        # gh-132413: Users need to call PyDateTime_IMPORT every time
-        # after starting an interpreter.
-        code = textwrap.dedent("""
-            import sys
-            import _testcapi
-            _testcapi.test_datetime_capi()  # PyDateTime_IMPORT only once
-            timedelta = type(_testcapi.get_delta_fromdsu(False, 1, 0, 0))
-
-            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' + '2\n' * (INIT_LOOPS - 1))
-
     def test_static_types_inherited_slots(self):
         script = textwrap.dedent("""
             import test.support