[brain tests] Burst threading from the main file

Author: Pierre-Sassoulas

tests/brain/test_brain.py

@@ -100,49 +100,6 @@ def test_extension_modules(self) -> None:
             extender(n)
 
 
-class ThreadingBrainTest(unittest.TestCase):
-    def test_lock(self) -> None:
-        lock_instance = builder.extract_node(
-            """
-        import threading
-        threading.Lock()
-        """
-        )
-        inferred = next(lock_instance.infer())
-        self.assert_is_valid_lock(inferred)
-
-        acquire_method = inferred.getattr("acquire")[0]
-        parameters = [param.name for param in acquire_method.args.args[1:]]
-        assert parameters == ["blocking", "timeout"]
-
-        assert inferred.getattr("locked")
-
-    def test_rlock(self) -> None:
-        self._test_lock_object("RLock")
-
-    def test_semaphore(self) -> None:
-        self._test_lock_object("Semaphore")
-
-    def test_boundedsemaphore(self) -> None:
-        self._test_lock_object("BoundedSemaphore")
-
-    def _test_lock_object(self, object_name: str) -> None:
-        lock_instance = builder.extract_node(
-            f"""
-        import threading
-        threading.{object_name}()
-        """
-        )
-        inferred = next(lock_instance.infer())
-        self.assert_is_valid_lock(inferred)
-
-    def assert_is_valid_lock(self, inferred: Instance) -> None:
-        self.assertIsInstance(inferred, astroid.Instance)
-        self.assertEqual(inferred.root().name, "threading")
-        for method in ("acquire", "release", "__enter__", "__exit__"):
-            self.assertIsInstance(next(inferred.igetattr(method)), astroid.BoundMethod)
-
-
 def streams_are_fine():
     """Check if streams are being overwritten,
     for example, by pytest

tests/brain/test_exceptions.py

@@ -0,0 +1,54 @@
+# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
+# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+from __future__ import annotations
+
+import unittest
+
+import astroid
+from astroid import builder
+from astroid.bases import Instance
+
+
+class ThreadingBrainTest(unittest.TestCase):
+    def test_lock(self) -> None:
+        lock_instance = builder.extract_node(
+            """
+        import threading
+        threading.Lock()
+        """
+        )
+        inferred = next(lock_instance.infer())
+        self.assert_is_valid_lock(inferred)
+
+        acquire_method = inferred.getattr("acquire")[0]
+        parameters = [param.name for param in acquire_method.args.args[1:]]
+        assert parameters == ["blocking", "timeout"]
+
+        assert inferred.getattr("locked")
+
+    def test_rlock(self) -> None:
+        self._test_lock_object("RLock")
+
+    def test_semaphore(self) -> None:
+        self._test_lock_object("Semaphore")
+
+    def test_boundedsemaphore(self) -> None:
+        self._test_lock_object("BoundedSemaphore")
+
+    def _test_lock_object(self, object_name: str) -> None:
+        lock_instance = builder.extract_node(
+            f"""
+        import threading
+        threading.{object_name}()
+        """
+        )
+        inferred = next(lock_instance.infer())
+        self.assert_is_valid_lock(inferred)
+
+    def assert_is_valid_lock(self, inferred: Instance) -> None:
+        self.assertIsInstance(inferred, astroid.Instance)
+        self.assertEqual(inferred.root().name, "threading")
+        for method in ("acquire", "release", "__enter__", "__exit__"):
+            self.assertIsInstance(next(inferred.igetattr(method)), astroid.BoundMethod)