Improve unit tests.

The test_contains_frozenset() was not actually doing anything useful,
rewrite it.  Add test_contains_hash_mutate() which triggers unusual
code paths due to `__hash__` on the key mutating the container.

Author: nascheme

Lib/test/test_free_threading/test_set.py

@@ -12,7 +12,7 @@ def test_repr_clear(self):
         """Test repr() of a set while another thread is calling clear()"""
         NUM_ITERS = 10
         NUM_REPR_THREADS = 10
-        barrier = Barrier(NUM_REPR_THREADS + 1)
+        barrier = Barrier(NUM_REPR_THREADS + 1, timeout=2)
         s = {1, 2, 3, 4, 5, 6, 7, 8}
 
         def clear_set():
@@ -38,12 +38,12 @@ def repr_set():
 
     def test_contains_mutate(self):
         """Test set contains operation combined with mutation."""
-        barrier = Barrier(2)
+        barrier = Barrier(2, timeout=2)
         s = set()
         done = False
 
-        NUM_ITEMS = 2_000
-        NUM_LOOPS = 20
+        NUM_ITEMS = 200
+        NUM_LOOPS = 200
 
         def read_set():
             barrier.wait()
@@ -72,29 +72,82 @@ def mutate_set():
             t.join()
 
     def test_contains_frozenset(self):
-        barrier = Barrier(3)
+        barrier = Barrier(3, timeout=2)
         done = False
 
-        NUM_ITEMS = 2_000
-        NUM_LOOPS = 20
+        NUM_LOOPS = 1_000
 
-        s = frozenset()
-        def make_set():
-            nonlocal s
+        # This mutates the key used for contains test, not the container
+        # itself.  This works because frozenset allows the key to be a set().
+        s = set()
+
+        def mutate_set():
             barrier.wait()
             while not done:
-                s = frozenset(range(NUM_ITEMS))
+                s.add(0)
+                s.add(1)
+                s.clear()
 
         def read_set():
             nonlocal done
             barrier.wait()
+            container = frozenset([frozenset([0])])
+            self.assertTrue(set([0]) in container)
             for _ in range(NUM_LOOPS):
-                for i in range(NUM_ITEMS):
-                    item = i >> 1
-                    result = item in s
+                # Will return True when {0} is the key and False otherwise
+                result = s in container
             done = True
 
-        threads = [Thread(target=read_set), Thread(target=read_set), Thread(target=make_set)]
+        threads = [
+            Thread(target=read_set),
+            Thread(target=read_set),
+            Thread(target=mutate_set),
+        ]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+    def test_contains_hash_mutate(self):
+        """Test set contains operation with mutating hash method."""
+        barrier = Barrier(2, timeout=2)
+
+        NUM_ITEMS = 20  # should be larger than PySet_MINSIZE
+        NUM_LOOPS = 1_000
+
+        s = set(range(NUM_ITEMS))
+
+        class Key:
+            def __init__(self):
+                self.count = 0
+                self.value = 0
+
+            def __hash__(self):
+                self.count += 1
+                # This intends to trigger the SET_LOOKKEY_CHANGED case
+                # of set_lookkey_threadsafe() since calling clear()
+                # will cause the 'table' pointer to change.
+                if self.count % 2 == 0:
+                    s.clear()
+                else:
+                    s.update(range(NUM_ITEMS))
+                return hash(self.value)
+
+            def __eq__(self, other):
+                return self.value == other
+
+        key = Key()
+        self.assertTrue(key in s)
+        self.assertFalse(key in s)
+        self.assertTrue(key in s)
+        self.assertFalse(key in s)
+
+        def read_set():
+            barrier.wait()
+            for i in range(NUM_LOOPS):
+                result = key in s
+
+        threads = [Thread(target=read_set), Thread(target=read_set)]
         for t in threads:
             t.start()
         for t in threads: