Add lru_cache tests for overridden methods calling super().

Cover the case where a subclass method decorated with lru_cache calls
the base class method via super(), verifying both bodies execute, the
base and derived methods cache independently, and no recursion occurs.

Author: GrahamDumpleton

tests/core/test_lru_cache.py

@@ -267,6 +267,75 @@ def test_access_via_instance(self):
         self.assertEqual(info.misses, 1)
 
 
+class OverrideBase:
+    def __init__(self):
+        self.base_calls = 0
+        self.derived_calls = 0
+
+    @wrapt.lru_cache
+    def compute(self, x):
+        self.base_calls += 1
+        return x * 2
+
+
+class OverrideDerived(OverrideBase):
+    @wrapt.lru_cache
+    def compute(self, x):
+        self.derived_calls += 1
+        return super().compute(x) + 1
+
+
+class TestOverriddenMethodWithSuper(unittest.TestCase):
+    def test_super_call_returns_correct_result(self):
+        obj = OverrideDerived()
+        self.assertEqual(obj.compute(10), 21)
+
+    def test_super_call_does_not_recurse(self):
+        # Regression test: a subclass method decorated with lru_cache that
+        # called the base method via super() used to recurse forever because
+        # the base and derived methods shared a single per-instance cache
+        # slot derived from the method name alone.
+        obj = OverrideDerived()
+        try:
+            result = obj.compute(10)
+        except RecursionError:
+            self.fail("super() call recursed instead of reaching base method")
+        self.assertEqual(result, 21)
+
+    def test_both_bodies_execute_once(self):
+        obj = OverrideDerived()
+        obj.compute(10)
+        self.assertEqual(obj.derived_calls, 1)
+        self.assertEqual(obj.base_calls, 1)
+
+    def test_base_and_derived_cached_independently(self):
+        obj = OverrideDerived()
+        obj.compute(10)
+        obj.compute(10)
+        # Second call is served from both caches, so neither body re-runs.
+        self.assertEqual(obj.derived_calls, 1)
+        self.assertEqual(obj.base_calls, 1)
+        info = obj.compute.cache_info()
+        self.assertEqual(info.hits, 1)
+        self.assertEqual(info.misses, 1)
+
+    def test_base_class_instance_unaffected(self):
+        obj = OverrideBase()
+        self.assertEqual(obj.compute(10), 20)
+        self.assertEqual(obj.base_calls, 1)
+        self.assertEqual(obj.derived_calls, 0)
+
+    def test_separate_instances_have_separate_caches(self):
+        obj1 = OverrideDerived()
+        obj2 = OverrideDerived()
+        obj1.compute(10)
+        obj2.compute(10)
+        self.assertEqual(obj1.derived_calls, 1)
+        self.assertEqual(obj2.derived_calls, 1)
+        self.assertEqual(obj1.base_calls, 1)
+        self.assertEqual(obj2.base_calls, 1)
+
+
 class TestIntrospection(unittest.TestCase):
     def test_function_name(self):
         self.assertEqual(cached_function.__name__, "cached_function")