Move test to test_generators.

Author: ZeroIntensity

Lib/test/test_generators.py

@@ -10,6 +10,7 @@
 import types
 
 from test import support
+from test.support import threading_helper
 
 try:
     import _testcapi
@@ -268,6 +269,47 @@ def loop():
         #This should not raise
         loop()
 
+    @support.requires_resource("cpu")
+    def test_list_init_thread_safety(self):
+        # GH-126369: generators were not thread safe
+        from threading import Thread, Lock
+        import contextlib
+
+        def my_generator():
+            for i in range(1000000):
+                yield i
+
+
+        lock = Lock()
+        amount = 0
+        thread_count = 10
+
+        def gen_to_list(gen):
+            # Note: it's intentional to throw out the exception here. Generators
+            # aren't thread safe, so who knows what will happen. Right now, it just spams
+            # a lot of ValueError's, but that might change if we decide to make generators
+            # thread safe in the future. We're just making sure it doesn't crash.
+            with contextlib.suppress(ValueError):
+                list(gen)
+
+            with lock:
+                nonlocal amount
+                amount += 1
+
+        generator = my_generator()
+        with threading_helper.catch_threading_exception() as cm:
+            ts = [Thread(target=gen_to_list, args=(generator,)) for _ in range(thread_count)]
+            for t in ts:
+                t.start()
+
+            for t in ts:
+                t.join()
+
+            self.assertIsNone(cm.exc_value)
+
+        self.assertEqual(amount, thread_count)
+
+
 
 class ModifyUnderlyingIterableTest(unittest.TestCase):
     iterables = [

Lib/test/test_list.py

@@ -1,7 +1,6 @@
 import sys
 from test import list_tests
 from test import support
-from test.support import threading_helper
 from test.support import cpython_only
 import pickle
 import unittest
@@ -311,46 +310,6 @@ def test_tier2_invalidates_iterator(self):
             a.append(4)
             self.assertEqual(list(it), [])
 
-    @support.requires_resource("cpu")
-    def test_list_init_thread_safety(self):
-        # GH-126369: list.__init__() didn't lock iterables
-        from threading import Thread, Lock
-        import contextlib
-
-        def my_generator():
-            for i in range(1000000):
-                yield i
-
-
-        lock = Lock()
-        amount = 0
-        thread_count = 10
-
-        def gen_to_list(gen):
-            # Note: it's intentional to throw out the exception here. Generators
-            # aren't thread safe, so who knows what will happen. Right now, it just spams
-            # a lot of ValueError's, but that might change if we decide to make generators
-            # thread safe in the future. We're just making sure it doesn't crash.
-            with contextlib.suppress(ValueError):
-                list(gen)
-
-            with lock:
-                nonlocal amount
-                amount += 1
-
-        generator = my_generator()
-        with threading_helper.catch_threading_exception() as cm:
-            ts = [Thread(target=gen_to_list, args=(generator,)) for _ in range(thread_count)]
-            for t in ts:
-                t.start()
-
-            for t in ts:
-                t.join()
-
-            self.assertIsNone(cm.exc_value)
-
-        self.assertEqual(amount, thread_count)
-
 
 if __name__ == "__main__":
     unittest.main()