Personal review fixes

Author: cmaloney

Lib/test/libregrtest/main.py

@@ -525,7 +525,7 @@ def create_run_tests(self, tests: TestTuple) -> RunTests:
             hunt_refleak=self.hunt_refleak,
             test_dir=self.test_dir,
             use_junit=(self.junit_filename is not None),
-            final_run=not (self.want_rerun and not self.python_cmd),
+            final_run=not self.want_rerun or bool(self.python_cmd),
             coverage=self.coverage,
             memory_limit=self.memory_limit,
             gc_threshold=self.gc_threshold,

Lib/test/libregrtest/reporter.py

@@ -7,7 +7,7 @@
 
 from .findtests import findtestdir
 from .result import TestResult
-lazy from .results import TestResults
+from .results import TestResults
 from .runtests import RunTests
 from .utils import count
 
@@ -31,20 +31,20 @@ def summary(self, results: TestResults, state: str) -> None:
     @staticmethod
     def parse_traceback(traceback: str) -> tuple[str | None, str | None, str]:
         """Return (filename, line, exception) of a failure."""
-        frames = re.findall(r'^ *File "(.*)", line (\d+)', traceback,
-                            re.MULTILINE)
-        test_frames = [frame for frame in frames
-                       if pathlib.Path(frame[0]).name.startswith('test_')]
+        # A frame is its "File" line and its source lines
+        frames = list(re.finditer(
+            r'^ *File "(.*)", line (\d+).*\n(?:    .*\n)*', traceback,
+            re.MULTILINE))
+        filename = line = None
+        exception = traceback
+        if frames:
+            filename, line = frames[0].groups()
+            exception = traceback[frames[-1].end():]
         # Prefer the last frame in a test file, the assertion
-        if test_frames:
-            filename, line = test_frames[-1]
-        elif frames:
-            filename, line = frames[0]
-        else:
-            filename = line = None
-        exception = re.split(r'^  File .*\n(?:    .*\n)*', traceback,
-                             flags=re.MULTILINE)[-1].strip()
-        return filename, line, exception
+        for frame in frames:
+            if pathlib.Path(frame[1]).name.startswith("test_"):
+                filename, line = frame.groups()
+        return filename, line, exception.strip()
 
 
 def get_reporter() -> Reporter:
@@ -93,7 +93,8 @@ def test_result(self, result: TestResult) -> None:
         self.annotate(result.test_name, decolor(message), filename)
 
     def annotate(self, title: str, message: str, filename: str | None,
-                 line: str | None = None, stream: TextIO | None = None) -> None:
+                 line: str | None = None,
+                 stream: TextIO | None = None) -> None:
         if filename:
             # Make installed stdlib paths relative to the checkout
             path = pathlib.Path(filename)
@@ -120,8 +121,8 @@ def summary(self, results: TestResults, state: str) -> None:
         for result in failed:
             blocks.append(f"### {decolor(str(result))}")
             if result.env_changed_reasons:
-                blocks.append("\n".join(f"- {reason}"
-                                        for reason in result.env_changed_reasons))
+                blocks.append("\n".join(
+                    f"- {reason}" for reason in result.env_changed_reasons))
             for name, traceback in result.failed_test_cases:
                 # Expand short tracebacks if there are only a few
                 if ncases <= 5 and traceback.count("\n") < 30:

Lib/test/libregrtest/setup.py

@@ -13,7 +13,7 @@
 from .filter import set_match_tests
 from .reporter import get_reporter
 from .runtests import RunTests
-lazy from .testresult import RegressionTestResult
+from .testresult import RegressionTestResult
 from .utils import (
     setup_unraisable_hook, setup_threading_excepthook,
     adjust_rlimit_nofile)

Lib/test/test_regrtest.py

@@ -1657,35 +1657,23 @@ def test_fail(self):
         fail = self.create_test('reporter_fail', code)
         crash = self.create_test('reporter_crash',
                                  code.replace('self.fail()', 'os._exit(1)'))
-        fail_case = (os.path.join(self.tmptestdir, f'{fail}.py'), '6',
-                     f'test_fail ({fail}.Tests.test_fail)')
-        filename = os.path.join(self.tmptestdir, 'github_step_summary.md')
-        env = dict(os.environ, GITHUB_STEP_SUMMARY=filename)
+        summary = os.path.join(self.tmptestdir, 'summary.md')
+        env = dict(os.environ, GITHUB_STEP_SUMMARY=summary)
 
-        def reported(output):
-            return re.findall(r'^::error file=(.*),line=(\d+),title=(.*)::',
-                              output, re.MULTILINE)
+        def reported(*args, exitcode=EXITCODE_BAD_TEST):
+            output = self.run_tests('-j1', *args, env=env, exitcode=exitcode)
+            return re.findall(r'^::error file=.*,title=(\w+)', output,
+                              re.MULTILINE)
 
+        self.assertEqual(reported(self.create_test(), exitcode=0), [])
+        self.assertFalse(os.path.exists(summary))
+        # Quiet mode doesn't print the failure, but reports it
+        self.assertEqual(reported(fail), ['test_fail'])
         # Only the re-run is reported
-        output = self.run_tests('-j1', '--rerun', fail, crash,
-                                env=env, exitcode=EXITCODE_BAD_TEST)
-        self.assertEqual(reported(output), [
-            fail_case,
-            (os.path.join(self.tmptestdir, f'{crash}.py'), '1', crash),
-        ], output)
-        with open(filename, encoding='utf-8') as fp:
+        self.assertEqual(reported('--rerun', fail, crash),
+                         ['test_fail', crash])
+        with open(summary, encoding='utf-8') as fp:
             self.assertIn('2 test files and 1 test case failed', fp.read())
-        os_helper.unlink(filename)
-
-        # Quiet mode doesn't print the failure, but reports it
-        output = self.run_tests('-j1', fail, env=env,
-                                exitcode=EXITCODE_BAD_TEST)
-        self.assertEqual(reported(output), [fail_case], output)
-        os_helper.unlink(filename)
-
-        output = self.run_tests(self.create_test(), env=env)
-        self.assertEqual(reported(output), [])
-        self.assertFalse(os.path.exists(filename))
 
     def test_rerun_fail(self):
         # FAILURE then FAILURE