Use subTest to break up tests

Author: csm10495

Lib/test/test_concurrent_futures/test_process_pool.py

@@ -230,56 +230,59 @@ def mock_start_new_thread(func, *args, **kwargs):
 
     def test_process_pool_executor_terminate_kill_workers(self):
         for function_name in ('terminate_workers', 'kill_workers'):
-            manager = multiprocessing.Manager()
-            q = manager.Queue()
+            with self.subTest(function_name=function_name):
+                manager = multiprocessing.Manager()
+                q = manager.Queue()
 
-            with futures.ProcessPoolExecutor(max_workers=1) as executor:
-                executor.submit(_put_sleep_put, q)
+                with futures.ProcessPoolExecutor(max_workers=1) as executor:
+                    executor.submit(_put_sleep_put, q)
 
-                # We should get started, but not finished since we'll terminate the workers just after
-                self.assertEqual(q.get(timeout=5), 'started')
+                    # We should get started, but not finished since we'll terminate the workers just after
+                    self.assertEqual(q.get(timeout=5), 'started')
 
-                worker_process = list(executor._processes.values())[0]
-                getattr(executor, function_name)()
-                worker_process.join()
+                    worker_process = list(executor._processes.values())[0]
+                    getattr(executor, function_name)()
+                    worker_process.join()
 
-                if function_name == 'terminate_workers' or sys.platform == 'win32':
-                    # On windows, kill and terminate both send SIGTERM
-                    self.assertEqual(worker_process.exitcode, -signal.SIGTERM)
-                elif function_name == 'kill_workers':
-                    self.assertEqual(worker_process.exitcode, -signal.SIGKILL)
+                    if function_name == 'terminate_workers' or sys.platform == 'win32':
+                        # On windows, kill and terminate both send SIGTERM
+                        self.assertEqual(worker_process.exitcode, -signal.SIGTERM)
+                    elif function_name == 'kill_workers':
+                        self.assertEqual(worker_process.exitcode, -signal.SIGKILL)
 
-                self.assertRaises(queue.Empty, q.get, timeout=1)
+                    self.assertRaises(queue.Empty, q.get, timeout=1)
 
     def test_process_pool_executor_terminate_kill_workers_dead_workers(self):
         for function_name in ('terminate_workers', 'kill_workers'):
-            with futures.ProcessPoolExecutor(max_workers=1) as executor:
-                future = executor.submit(os._exit, 1)
-                self.assertRaises(BrokenProcessPool, future.result)
+            with self.subTest(function_name=function_name):
+                with futures.ProcessPoolExecutor(max_workers=1) as executor:
+                    future = executor.submit(os._exit, 1)
+                    self.assertRaises(BrokenProcessPool, future.result)
 
-                # even though the pool is broken, this shouldn't raise
-                getattr(executor, function_name)()
+                    # even though the pool is broken, this shouldn't raise
+                    getattr(executor, function_name)()
 
     def test_process_pool_executor_terminate_kill_workers_not_started_yet(self):
         for function_name in ('terminate_workers', 'kill_workers'):
+            with self.subTest(function_name=function_name):
+                context_with_mocked_process = multiprocessing.get_context()
+                with unittest.mock.patch.object(context_with_mocked_process, 'Process') as mock_process:
+                    with futures.ProcessPoolExecutor(max_workers=1, mp_context=context_with_mocked_process) as executor:
+                        # The worker has not been started yet, terminate/kill_workers should basically no-op
+                        getattr(executor, function_name)()
 
-            context_with_mocked_process = multiprocessing.get_context()
-            with unittest.mock.patch.object(context_with_mocked_process, 'Process') as mock_process:
-                with futures.ProcessPoolExecutor(max_workers=1, mp_context=context_with_mocked_process) as executor:
-                    # The worker has not been started yet, terminate/kill_workers should basically no-op
-                    getattr(executor, function_name)()
-
-                mock_process.return_value.kill.assert_not_called()
-                mock_process.return_value.terminate.assert_not_called()
+                    mock_process.return_value.kill.assert_not_called()
+                    mock_process.return_value.terminate.assert_not_called()
 
     def test_process_pool_executor_terminate_kill_workers_stops_pool(self):
         for function_name in ('terminate_workers', 'kill_workers'):
-            with futures.ProcessPoolExecutor(max_workers=1) as executor:
-                executor.submit(time.sleep, 0).result()
+            with self.subTest(function_name=function_name):
+                with futures.ProcessPoolExecutor(max_workers=1) as executor:
+                    executor.submit(time.sleep, 0).result()
 
-                getattr(executor, function_name)()
+                    getattr(executor, function_name)()
 
-                self.assertRaises(RuntimeError, executor.submit, time.sleep, 0)
+                    self.assertRaises(RuntimeError, executor.submit, time.sleep, 0)
 
     def test_process_pool_executor_terminate_workers(self):
         with futures.ProcessPoolExecutor(max_workers=1) as executor: