gh-152548: Rename isolated() to runInSubprocess() and address review

Rename the decorator to runInSubprocess() and the flag to runningInSubprocess
so the subprocess mechanism (and the skip when it is unavailable) is explicit.
Suppress Windows CRT assertion dialogs in the isolated child so a debug build
does not hang on a modal dialog, and add a subclass fixture-binding test.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: serhiy-storchaka

Doc/library/test.rst

@@ -963,10 +963,10 @@ The :mod:`!test.support` module defines the following functions:
 
 .. currentmodule:: test.support.isolation
 
-.. decorator:: isolated()
+.. decorator:: runInSubprocess()
 
-   Decorator that runs the decorated test in isolation, in a fresh interpreter
-   subprocess, so that it does not share global or interpreter state with the
+   Decorator that runs the decorated test in a fresh interpreter subprocess, in
+   isolation, so that it does not share global or interpreter state with the
    rest of the test run.  It can decorate a test method or a whole
    :class:`~unittest.TestCase` subclass.  Decorated methods must take no extra
    arguments.  A failure, error or skip in the subprocess is reported for the
@@ -989,7 +989,7 @@ The :mod:`!test.support` module defines the following functions:
    :meth:`~unittest.TestCase.setUpClass` in the subprocess is reported for the
    whole class.  ``setUpModule()`` cannot be controlled by a class decorator,
    so it still runs in the parent process too; test it with
-   :data:`running_isolated` if needed.
+   :data:`runningInSubprocess` if needed.
 
    The subprocess inherits the enabled resources (``-u``), memory limit
    (``-M``) and verbosity (``-v``) of the parent test run, so that
@@ -1000,11 +1000,11 @@ The :mod:`!test.support` module defines the following functions:
    The test is skipped on platforms without subprocess support.
 
 
-.. data:: running_isolated
+.. data:: runningInSubprocess
 
    ``True`` while the code runs in the isolated subprocess spawned by
-   :func:`isolated`, and ``False`` otherwise (including in the parent process
-   and in a normal, non-isolated test run).  Fixtures such as
+   :func:`runInSubprocess`, and ``False`` otherwise (including in the parent
+   process and in a normal, non-isolated test run).  Fixtures such as
    :meth:`~unittest.TestCase.setUp`, :meth:`~unittest.TestCase.tearDown`,
    :meth:`~unittest.TestCase.setUpClass`, :meth:`~unittest.TestCase.tearDownClass`,
    ``setUpModule()`` and ``tearDownModule()`` can test it to choose which code

Lib/test/_isolated_sample.py

@@ -1,54 +1,53 @@
 """Sample tests driven by test.test_support.TestIsolated.
 
 This module is imported, never run as a test file, so that
-:func:`test.support.isolation.isolated` has a real, importable target to run in
+:func:`test.support.isolation.runInSubprocess` has a real, importable target to run in
 a subprocess.  Several of these tests fail, error or are skipped on purpose.
 """
 
 import time
 import unittest
 from test.support import isolation
 
-# A test in DurationSample sleeps this long in the subprocess; the parent
-# replays it instantly, so a parent-reported duration close to this proves the
-# subprocess timing was forwarded rather than the replay time measured.
+# DurationSample sleeps this long in the subprocess; a parent-reported duration
+# close to it proves the subprocess timing was forwarded, not the replay time.
 DURATION_SLEEP = 0.2
 
 
 class MethodSample(unittest.TestCase):
 
-    @isolation.isolated()
+    @isolation.runInSubprocess()
     def test_pass(self):
-        self.assertTrue(isolation.running_isolated)
+        self.assertTrue(isolation.runningInSubprocess)
 
-    @isolation.isolated()
+    @isolation.runInSubprocess()
     def test_fail(self):
         self.assertEqual(1, 2)
 
-    @isolation.isolated()
+    @isolation.runInSubprocess()
     def test_error(self):
         raise RuntimeError('boom')
 
-    @isolation.isolated()
+    @isolation.runInSubprocess()
     def test_skip(self):
         self.skipTest('nope')
 
-    @isolation.isolated()
+    @isolation.runInSubprocess()
     @unittest.expectedFailure
     def test_expected_failure(self):
         self.assertEqual(1, 2)
 
-    @isolation.isolated()
+    @isolation.runInSubprocess()
     @unittest.expectedFailure
     def test_unexpected_success(self):
         pass
 
 
-@isolation.isolated()
+@isolation.runInSubprocess()
 class ClassSample(unittest.TestCase):
 
     def test_pass(self):
-        self.assertTrue(isolation.running_isolated)
+        self.assertTrue(isolation.runningInSubprocess)
 
     def test_fail(self):
         self.assertEqual(1, 2)
@@ -60,15 +59,32 @@ def test_expected_failure(self):
 
 class SubtestSample(unittest.TestCase):
 
-    @isolation.isolated()
+    @isolation.runInSubprocess()
     def test_subtests(self):
         for i in range(3):
             with self.subTest(i=i):
                 self.assertNotEqual(i, 1)
 
 
-@isolation.isolated()
+@isolation.runInSubprocess()
 class DurationSample(unittest.TestCase):
 
     def test_slow(self):
         time.sleep(DURATION_SLEEP)
+
+
+@isolation.runInSubprocess()
+class FixtureBindingSample(unittest.TestCase):
+    # setUpClass must run bound to the runtime class, so a subclass sees its own
+    # name here rather than the base class's.
+
+    @classmethod
+    def setUpClass(cls):
+        cls.setup_class_name = cls.__name__
+
+    def test_runtime_class(self):
+        self.assertEqual(self.setup_class_name, type(self).__name__)
+
+
+class FixtureBindingSubclassSample(FixtureBindingSample):
+    pass

Lib/test/support/isolation.py

@@ -1,4 +1,4 @@
-"""Run tests in isolated subprocesses (the test.support.isolation.isolated decorator).
+"""Run tests in isolated subprocesses (the test.support.isolation.runInSubprocess decorator).
 
 A failure, error or skip that happens in the subprocess is replayed in the
 parent process so that the test runner records it.  The original (subprocess)
@@ -11,10 +11,8 @@
 import sys
 import unittest
 
-# Mark this module's frames as belonging to the test machinery, so that
-# unittest strips them from reported tracebacks (see TestResult._clean_tracebacks
-# in Lib/unittest/result.py).  Only the original subprocess traceback, attached
-# as the cause, is then shown -- not the parent-side replay frames.
+# Let unittest strip this module's frames from tracebacks, so only the original
+# subprocess traceback (attached as the cause) is shown, not the replay frames.
 __unittest = True
 
 # Environment variable set in the child process so that the decorated test
@@ -39,23 +37,23 @@ def _child_config():
     return {name: getattr(support, name) for name in _PROPAGATED_CONFIG}
 
 def _apply_child_config():
-    """Mirror the parent's test.support configuration in the subprocess.
+    """Set up the child to run the test like a regrtest worker would.
 
-    Called by subprocess_runner before loading the test, so that import-time
-    decorators (e.g. requires_resource) and runtime checks see the same -u/-M/-v
-    configuration as the parent process.
+    Mirror the parent's -u/-M/-v config, then suppress the Windows CRT assertion
+    dialogs that would otherwise block a debug build on a modal dialog and hang
+    the parent.
     """
     import json
     import test.support as support
     data = os.environ.get(_CONFIG_ENV)
     if data:
         for name, value in json.loads(data).items():
             setattr(support, name, value)
+    support.suppress_msvcrt_asserts(support.verbose >= 2)
 
-# True while running inside the isolated subprocess spawned by @isolated().
-# setUp()/tearDown() and the class- and module-level fixtures can test it to
-# decide which code to run in the subprocess as opposed to the parent process.
-running_isolated = bool(os.environ.get(_RUN_IN_SUBPROCESS_ENV))
+# True inside the subprocess spawned by @runInSubprocess().  Fixtures can test
+# it to decide what to run in the subprocess as opposed to the parent process.
+runningInSubprocess = bool(os.environ.get(_RUN_IN_SUBPROCESS_ENV))
 
 
 class _RemoteTraceback(Exception):
@@ -82,8 +80,8 @@ def _remote(detail):
 
 
 def _check_subprocess_support():
-    # isolated() always runs the test in a subprocess, so skip (in the parent)
-    # on platforms that do not support spawning one.
+    # runInSubprocess() always runs the test in a subprocess, so skip (in the
+    # parent) on platforms that do not support spawning one.
     import test.support as support
     if not support.has_subprocess_support:
         raise unittest.SkipTest('requires subprocess support')
@@ -127,9 +125,9 @@ def _replay_outcome(test, outcome):
     if kind == 'skipped':
         test.skipTest(detail)  # the detail is the skip reason, not a traceback
     elif kind in ('failure', 'expected_failure'):
-        # An expected failure is replayed like a failure: the wrapper carries
-        # the @expectedFailure marker (copied by functools.wraps), so the parent
-        # records the raised exception as an expectedFailure, not a failure.
+        # Replay an expected failure like a failure: the wrapper keeps the
+        # @expectedFailure marker (via functools.wraps), so the parent records
+        # the raised exception as an expectedFailure.
         exc = test.failureException('test failed in the subprocess')
         raise exc from _remote(detail)
     else:  # 'error'
@@ -163,7 +161,7 @@ def _raise_fixture_outcome(outcome):
 def _isolate_method(func):
     @functools.wraps(func)
     def wrapper(self, /, *args, **kwargs):
-        if running_isolated:
+        if runningInSubprocess:
             # Already running in the subprocess: run the real test.
             return func(self, *args, **kwargs)
         _check_subprocess_support()
@@ -182,17 +180,17 @@ def wrapper(self, /, *args, **kwargs):
 
 
 def _isolate_class(cls):
-    # Unwrap to the plain functions: the replacements below call them with the
-    # runtime cls, so a subclass of an isolated class runs the fixtures bound to
-    # itself (a bound classmethod would freeze the decoration-time class).
+    # Unwrap to the plain functions so the replacements can call them with the
+    # runtime cls; a bound classmethod would freeze the decoration-time class
+    # and a subclass would run the fixtures bound to the base class.
     orig_setUpClass = cls.setUpClass.__func__
     orig_tearDownClass = cls.tearDownClass.__func__
     orig_setUp = cls.setUp
     orig_tearDown = cls.tearDown
     orig_addDuration = getattr(cls, '_addDuration', None)
 
     def setUpClass(cls):
-        if running_isolated:
+        if runningInSubprocess:
             orig_setUpClass(cls)
             return
         _check_subprocess_support()
@@ -215,26 +213,25 @@ def setUpClass(cls):
         cls._isolated_durations = dict(payload.get('durations', ()))
 
     def tearDownClass(cls):
-        if running_isolated:
+        if runningInSubprocess:
             orig_tearDownClass(cls)
         else:
             cls._isolated_outcomes = None
             cls._isolated_durations = None
 
     def setUp(self):
         # In the parent the real test does not run, so neither should setUp().
-        if running_isolated:
+        if runningInSubprocess:
             orig_setUp(self)
 
     def tearDown(self):
-        if running_isolated:
+        if runningInSubprocess:
             orig_tearDown(self)
 
     def _addDuration(self, result, elapsed):
-        # In the parent, report the per-test duration measured in the subprocess
-        # rather than the replay time (subprocess startup is paid once, in
-        # setUpClass).
-        if not running_isolated:
+        # In the parent, report the subprocess timing rather than the (instant)
+        # replay time; subprocess startup is paid once, in setUpClass.
+        if not runningInSubprocess:
             durations = getattr(type(self), '_isolated_durations', None) or {}
             elapsed = durations.get(self.id(), elapsed)
         orig_addDuration(self, result, elapsed)
@@ -253,15 +250,15 @@ def replay(self):
         method = getattr(cls, name)
         @functools.wraps(method)
         def wrapper(self, /, *args, __func=method, **kwargs):
-            if running_isolated:
+            if runningInSubprocess:
                 return __func(self, *args, **kwargs)
             replay(self)
         setattr(cls, name, wrapper)
     return cls
 
 
-def isolated():
-    """Decorator to run a test method or class in isolation from the rest.
+def runInSubprocess():
+    """Decorator to run a test method or class in a fresh subprocess.
 
     The decorated test runs in a separate, fresh Python process, so it does not
     share global or interpreter state with the rest of the test run.  When a
@@ -274,7 +271,7 @@ def isolated():
     individual subtests (:meth:`~unittest.TestCase.subTest`) that fail or are
     skipped are reported individually.  The original subprocess traceback is
     shown as the cause of a reported failure or error.  Use
-    :data:`running_isolated` in fixtures to choose what to run in the subprocess.
+    :data:`runningInSubprocess` in fixtures to choose what to run in the subprocess.
 
     The test is skipped on platforms without subprocess support, since it must
     spawn one.

Lib/test/support/subprocess_runner.py

@@ -1,7 +1,7 @@
 """Run a single test method in this (sub)process and report the result.
 
 Invoked as ``python -m test.support.subprocess_runner MODULE QUALNAME OUTFILE``
-by :func:`test.support.isolation.isolated`.  The outcome of the test (including
+by :func:`test.support.isolation.runInSubprocess`.  The outcome of the test (including
 that of each individual subtest) is written as JSON to OUTFILE.  This module is
 not meant to be imported.
 """
@@ -23,8 +23,8 @@
 qualname = sys.argv[2]
 outfile = sys.argv[3]
 
-# Mirror the parent's regrtest configuration (-u, -M, -v, ...) before importing
-# the test, so resource gating and bigmem sizing match the parent process.
+# Set up the child (mirror the parent's -u/-M/-v config, suppress Windows CRT
+# assertion dialogs, ...) before importing the test.
 from test.support.isolation import _apply_child_config
 _apply_child_config()
 

Lib/test/test_support.py

@@ -1078,8 +1078,8 @@ def test_disable_hash_md5_in_fips_mode_allow_all(self):
 
 class TestIsolated(unittest.TestCase):
     # Drive the sample tests in test._isolated_sample (which really spawn
-    # subprocesses through @isolation.isolated()) under a private TestResult,
-    # and check that each subprocess outcome is replayed in the parent.
+    # subprocesses through @isolation.runInSubprocess()) under a private
+    # TestResult, and check that each subprocess outcome is replayed in the parent.
 
     @staticmethod
     def _run(name):
@@ -1161,6 +1161,17 @@ def test_durations_forwarded_for_class(self):
         self.assertEqual(name.split()[0], 'test_slow')
         self.assertGreaterEqual(elapsed, DURATION_SLEEP / 2)
 
+    @support.requires_subprocess()
+    def test_subclass_fixtures_bound_to_runtime_class(self):
+        # A decorated class and a subclass of it each run setUpClass bound to
+        # their own class; both samples pass only if that holds.
+        for name in ('FixtureBindingSample', 'FixtureBindingSubclassSample'):
+            with self.subTest(sample=name):
+                result = self._run(name)
+                self.assertEqual(result.testsRun, 1)
+                self.assertEqual(result.failures, [])
+                self.assertEqual(result.errors, [])
+
     def test_skipped_without_subprocess_support(self):
         # On a platform without subprocess support the test is skipped in the
         # parent, before any subprocess is spawned.

Misc/NEWS.d/next/Tests/2026-06-29-10-14-09.gh-issue-152548.Khw9J7.rst

@@ -1,3 +1,3 @@
-Add the :func:`test.support.isolation.isolated` decorator to run a test method or
+Add the :func:`test.support.isolation.runInSubprocess` decorator to run a test method or
 ``TestCase`` subclass in a fresh interpreter subprocess, isolated from the rest
 of the test run.