Remove obvious comments and improve import style in tests

- Remove comments that restate what the code obviously does
- Change from 'from multiprocessing.forkserver import _handle_preload'
  to 'from multiprocessing import forkserver' and use qualified calls
- Makes code cleaner and follows better import conventions

Author: gpshead

Lib/test/test_multiprocessing_forkserver/test_preload.py

@@ -1,23 +1,20 @@
 """Tests for forkserver preload functionality."""
 
 import multiprocessing
-import multiprocessing.forkserver
 import tempfile
 import unittest
-from multiprocessing.forkserver import _handle_preload
+from multiprocessing import forkserver
 
 
 class TestForkserverPreload(unittest.TestCase):
     """Tests for forkserver preload functionality."""
 
     def setUp(self):
         self.ctx = multiprocessing.get_context('forkserver')
-        # Ensure clean state for each test
-        multiprocessing.forkserver._forkserver._stop()
+        forkserver._forkserver._stop()
 
     def tearDown(self):
-        # Clean up after tests
-        multiprocessing.forkserver._forkserver._stop()
+        forkserver._forkserver._stop()
         self.ctx.set_forkserver_preload([])
 
     @staticmethod
@@ -27,10 +24,8 @@ def _send_value(conn, value):
 
     def test_preload_on_error_ignore_default(self):
         """Test that invalid modules are silently ignored by default."""
-        # With on_error='ignore' (default), invalid module is ignored
         self.ctx.set_forkserver_preload(['nonexistent_module_xyz'])
 
-        # Should be able to start a process without errors
         r, w = self.ctx.Pipe(duplex=False)
         p = self.ctx.Process(target=self._send_value, args=(w, 42))
         p.start()
@@ -46,7 +41,6 @@ def test_preload_on_error_ignore_explicit(self):
         """Test that invalid modules are silently ignored with on_error='ignore'."""
         self.ctx.set_forkserver_preload(['nonexistent_module_xyz'], on_error='ignore')
 
-        # Should be able to start a process without errors
         r, w = self.ctx.Pipe(duplex=False)
         p = self.ctx.Process(target=self._send_value, args=(w, 99))
         p.start()
@@ -62,7 +56,6 @@ def test_preload_on_error_warn(self):
         """Test that invalid modules emit warnings with on_error='warn'."""
         self.ctx.set_forkserver_preload(['nonexistent_module_xyz'], on_error='warn')
 
-        # Should still be able to start a process, warnings are in subprocess
         r, w = self.ctx.Pipe(duplex=False)
         p = self.ctx.Process(target=self._send_value, args=(w, 123))
         p.start()
@@ -78,26 +71,20 @@ def test_preload_on_error_fail_breaks_context(self):
         """Test that invalid modules with on_error='fail' breaks the forkserver."""
         self.ctx.set_forkserver_preload(['nonexistent_module_xyz'], on_error='fail')
 
-        # The forkserver should fail to start when it tries to import
-        # The exception is raised during p.start() when trying to communicate
-        # with the failed forkserver process
         r, w = self.ctx.Pipe(duplex=False)
         try:
             p = self.ctx.Process(target=self._send_value, args=(w, 42))
             with self.assertRaises((EOFError, ConnectionError, BrokenPipeError)) as cm:
-                p.start()  # Exception raised here
-            # Verify that the helpful note was added
+                p.start()
             notes = getattr(cm.exception, '__notes__', [])
             self.assertTrue(notes, "Expected exception to have __notes__")
             self.assertIn('Forkserver process may have crashed', notes[0])
         finally:
-            # Ensure pipes are closed even if exception is raised
             w.close()
             r.close()
 
     def test_preload_valid_modules_with_on_error_fail(self):
         """Test that valid modules work fine with on_error='fail'."""
-        # Valid modules should work even with on_error='fail'
         self.ctx.set_forkserver_preload(['os', 'sys'], on_error='fail')
 
         r, w = self.ctx.Pipe(duplex=False)
@@ -127,7 +114,7 @@ def test_handle_preload_main_on_error_fail(self):
             f.write('raise RuntimeError("test error in __main__")\n')
             f.flush()
             with self.assertRaises(RuntimeError) as cm:
-                _handle_preload(['__main__'], main_path=f.name, on_error='fail')
+                forkserver._handle_preload(['__main__'], main_path=f.name, on_error='fail')
             self.assertIn("test error in __main__", str(cm.exception))
 
     def test_handle_preload_main_on_error_warn(self):
@@ -136,7 +123,7 @@ def test_handle_preload_main_on_error_warn(self):
             f.write('raise ImportError("test import error")\n')
             f.flush()
             with self.assertWarns(ImportWarning) as cm:
-                _handle_preload(['__main__'], main_path=f.name, on_error='warn')
+                forkserver._handle_preload(['__main__'], main_path=f.name, on_error='warn')
             self.assertIn("Failed to preload __main__", str(cm.warning))
             self.assertIn("test import error", str(cm.warning))
 
@@ -145,40 +132,36 @@ def test_handle_preload_main_on_error_ignore(self):
         with tempfile.NamedTemporaryFile(mode='w', suffix='.py') as f:
             f.write('raise ImportError("test import error")\n')
             f.flush()
-            # Should not raise
-            _handle_preload(['__main__'], main_path=f.name, on_error='ignore')
+            forkserver._handle_preload(['__main__'], main_path=f.name, on_error='ignore')
 
     def test_handle_preload_main_valid(self):
         """Test that valid __main__ preload works."""
         with tempfile.NamedTemporaryFile(mode='w', suffix='.py') as f:
             f.write('test_var = 42\n')
             f.flush()
-            _handle_preload(['__main__'], main_path=f.name, on_error='fail')
-            # Should complete without raising
+            forkserver._handle_preload(['__main__'], main_path=f.name, on_error='fail')
 
     def test_handle_preload_module_on_error_fail(self):
         """Test that module import failures raise with on_error='fail'."""
         with self.assertRaises(ModuleNotFoundError):
-            _handle_preload(['nonexistent_test_module_xyz'], on_error='fail')
+            forkserver._handle_preload(['nonexistent_test_module_xyz'], on_error='fail')
 
     def test_handle_preload_module_on_error_warn(self):
         """Test that module import failures warn with on_error='warn'."""
         with self.assertWarns(ImportWarning) as cm:
-            _handle_preload(['nonexistent_test_module_xyz'], on_error='warn')
+            forkserver._handle_preload(['nonexistent_test_module_xyz'], on_error='warn')
         self.assertIn("Failed to preload module", str(cm.warning))
 
     def test_handle_preload_module_on_error_ignore(self):
         """Test that module import failures are ignored with on_error='ignore'."""
-        # Should not raise
-        _handle_preload(['nonexistent_test_module_xyz'], on_error='ignore')
+        forkserver._handle_preload(['nonexistent_test_module_xyz'], on_error='ignore')
 
     def test_handle_preload_combined(self):
         """Test preloading both __main__ and modules."""
         with tempfile.NamedTemporaryFile(mode='w', suffix='.py') as f:
             f.write('import sys\n')
             f.flush()
-            _handle_preload(['__main__', 'os', 'sys'], main_path=f.name, on_error='fail')
-            # Should complete without raising
+            forkserver._handle_preload(['__main__', 'os', 'sys'], main_path=f.name, on_error='fail')
 
 
 if __name__ == '__main__':