python
diff --git a/‎Lib/test/test_interpreters.py‎
Lines changed: 79 additions & 28 deletions b/‎Lib/test/test_interpreters.py‎
Lines changed: 79 additions & 28 deletions
@@ -496,6 +496,52 @@ class StartupTests(TestBase):
     # We want to ensure the initial state of subinterpreters
     # matches expectations.
 
+    _subtest_count = 0
+
+    @contextlib.contextmanager
+    def subTest(self, *args):
+        with super().subTest(*args) as ctx:
+            self._subtest_count += 1
+            try:
+                yield ctx
+            finally:
+                if self._debugged_in_subtest:
+                    if self._subtest_count == 1:
+                        # The first subtest adds a leading newline, so we
+                        # compensate here by not printing a trailing newline.
+                        print('### end subtest debug ###', end='')
+                    else:
+                        print('### end subtest debug ###')
+                self._debugged_in_subtest = False
+
+    def debug(self, msg, *, header=None):
+        if header:
+            self._debug(f'--- {header} ---')
+            if msg:
+                if msg.endswith(os.linesep):
+                    self._debug(msg[:-len(os.linesep)])
+                else:
+                    self._debug(msg)
+                    self._debug('<no newline>')
+            self._debug('------')
+        else:
+            self._debug(msg)
+
+    _debugged = False
+    _debugged_in_subtest = False
+    def _debug(self, msg):
+        if not self._debugged:
+            print()
+            self._debugged = True
+        if self._subtest is not None:
+            if True:
+                if not self._debugged_in_subtest:
+                    self._debugged_in_subtest = True
+                    print('### start subtest debug ###')
+                print(msg)
+        else:
+            print(msg)
+
     def create_temp_dir(self):
         import tempfile
         tmp = tempfile.mkdtemp(prefix='test_interpreters_')
@@ -512,36 +558,42 @@ def write_script(self, *path, text):
             outfile.write(dedent(text))
         return filename
 
-    def run_cmd(self, cmd, *, cwd=None):
+    @support.requires_subprocess()
+    def run_python(self, argv, *, cwd=None):
         # This method is inspired by
         # EmbeddingTestsMixin.run_embedded_interpreter() in test_embed.py.
         import shlex
         import subprocess
-        assert cmd.startswith('python3 '), repr(cmd)
-        if cmd.startswith('python3 '):
-            cmd = cmd.replace('python3', sys.executable, 1)
-        argv = shlex.split(cmd)
-        proc = subprocess.run(
-            argv,
-            cwd=cwd,
-            capture_output=True,
-            text=True,
-        )
-        if proc.stderr != '':
-            # This is a hack until _PyThreadState_MustExit() is fixed.
-            proc.returncode = 1
+        if isinstance(argv, str):
+            argv = shlex.split(argv)
+        argv = [sys.executable, *argv]
+        try:
+            proc = subprocess.run(
+                argv,
+                cwd=cwd,
+                capture_output=True,
+                text=True,
+            )
+        except Exception as exc:
+            self.debug(f'# cmd: {shlex.join(argv)}')
+            if isinstance(exc, FileNotFoundError) and not exc.filename:
+                if os.path.exists(argv[0]):
+                    exists = 'exists'
+                else:
+                    exists = 'does not exist'
+                self.debug(f'{argv[0]} {exists}')
+            raise  # re-raise
+        assert proc.stderr == '' or proc.returncode != 0, proc.stderr
         if proc.returncode != 0 and support.verbose:
-            print(f'--- {cmd} failed ---')
-            print(f'stdout:\n{proc.stdout}')
-            print(f'stderr:\n{proc.stderr}')
-            print('------')
+            self.debug(f'# python3 {shlex.join(argv[1:])} failed:')
+            self.debug(proc.stdout, header='stdout')
+            self.debug(proc.stderr, header='stderr')
         self.assertEqual(proc.returncode, 0)
         self.assertEqual(proc.stderr, '')
         return proc.stdout
 
     def test_sys_path_0(self):
         # The main interpreter's sys.path[0] should be used by subinterpreters.
-
         script = '''
             import sys
             from test.support import interpreters
@@ -558,7 +610,6 @@ def test_sys_path_0(self):
                 }}, indent=4), flush=True)
                 """)
             '''
-
         # <tmp>/
         #   pkg/
         #     __init__.py
@@ -572,15 +623,15 @@ def test_sys_path_0(self):
         self.write_script(cwd, 'script.py', text=script)
 
         cases = [
-            ('python3 script.py', cwd),
-            ('python3 -m script', cwd),
-            ('python3 -m pkg', cwd),
-            ('python3 -m pkg.script', cwd),
-            ('python3 -c "import script"', ''),
+            ('script.py', cwd),
+            ('-m script', cwd),
+            ('-m pkg', cwd),
+            ('-m pkg.script', cwd),
+            ('-c "import script"', ''),
         ]
-        for cmd, expected in cases:
-            with self.subTest(cmd):
-                out = self.run_cmd(cmd, cwd=cwd)
+        for argv, expected in cases:
+            with self.subTest(f'python3 {argv}'):
+                out = self.run_python(argv, cwd=cwd)
                 data = json.loads(out)
                 sp0_main, sp0_sub = data['main'], data['sub']
                 self.assertEqual(sp0_sub, sp0_main)