python · serhiy-storchaka · Jul 1, 2025 · Mar 11, 2021 · May 14, 2023 · Jan 5, 2024
diff --git a/Lib/test/test_zoneinfo/test_zoneinfo.py b/Lib/test/test_zoneinfo/test_zoneinfo.py
@@ -58,6 +58,10 @@ def tearDownModule():
     shutil.rmtree(TEMP_DIR)
 
 
+class CustomError(Exception):
+    pass
+
+
 class TzPathUserMixin:
     """
     Adds a setUp() and tearDown() to make TZPATH manipulations thread-safe.
@@ -404,6 +408,25 @@ def test_time_fixed_offset(self):
                 self.assertEqual(t.utcoffset(), offset.utcoffset)
                 self.assertEqual(t.dst(), offset.dst)
 
+    def test_cache_exception(self):
+        class Incomparable(str):
+            eq_called = False
+            def __eq__(self, other):
+                self.eq_called = True
+                raise CustomError
+            __hash__ = str.__hash__
+
+        key = "America/Los_Angeles"
+        tz1 = self.klass(key)
+        key = Incomparable(key)
+        try:
+            tz2 = self.klass(key)
+        except CustomError:
+            self.assertTrue(key.eq_called)
+        else:
+            self.assertFalse(key.eq_called)
+            self.assertIs(tz2, tz1)
+
 
 class CZoneInfoTest(ZoneInfoTest):
     module = c_zoneinfo
@@ -1507,6 +1530,26 @@ def test_clear_cache_two_keys(self):
         self.assertIsNot(dub0, dub1)
         self.assertIs(tok0, tok1)
 
+    def test_clear_cache_refleak(self):
-    def test_clear_cache_refleak(self):
+    def test_clear_cache_refleak(self):
+        # bpo-43132: The portion of the C implementation of ZoneInfo that
+        # ejects specific keys from the strong cache (i.e. the LRU cache) was
+        # leaking references if comparing to the key object failed; because the
+        # strong cache is not currently implemented for subclasses, this test
+        # only really applies to the C implementation of the ZoneInfo class.
-    def test_clear_cache_refleak(self):
+    def test_clear_cache_refleak(self):
+        # bpo-43132: The portion of the C implementation of ZoneInfo that
+        # ejects specific keys from the strong cache (i.e. the LRU cache) was
+        # leaking references if comparing to the key object failed; because the
+        # strong cache is not currently implemented for subclasses, this test
+        # only really applies to the C implementation of the ZoneInfo class.
+        class Stringy(str):
+            allow_comparisons = True
+            def __eq__(self, other):
+                if not self.allow_comparisons:
+                    raise CustomError
+                return super().__eq__(other)
+            __hash__ = str.__hash__
+
+        key = Stringy("America/Los_Angeles")
+        self.klass(key)
-        self.klass(key)
+        self.klass.clear_cache(only_keys="America/Los_Angeles")
+        self.klass(key)
-        self.klass(key)
+        self.klass.clear_cache(only_keys="America/Los_Angeles")
+        self.klass(key)
+        key.allow_comparisons = False
+        try:
+            # Note: This is try/except rather than assertRaises because
+            # there is no guarantee that the key is even still in the cache,
+            # or that the key for the cache is the original `key` object.
+            self.klass.clear_cache(only_keys="America/Los_Angeles")
+        except CustomError:
+            pass
+
 
 class CZoneInfoCacheTest(ZoneInfoCacheTest):
     module = c_zoneinfo