@@ -1,3 +1,4 @@
+import html
 import os
 import random
 import re
@@ -397,7 +398,7 @@ def run_test(
 
         self.results.accumulate_result(result, runtests)
         if runtests.github_annotations:
-            result.print_github_crash_annotation(runtests.fail_env_changed)
+            result.print_github_annotation(runtests)
 
         return result
 
@@ -487,34 +488,35 @@ def finalize_tests(self, coverage: trace.CoverageResults | None) -> None:
 
     def write_github_summary(self) -> None:
         filename = os.environ.get("GITHUB_STEP_SUMMARY")
+        # Tests which failed in the last run (the re-run, if any)
+        failed = self.results.rerun_results
         # Only write a summary on failure: a CI run has many test jobs
         exitcode = self.results.get_exitcode(self.fail_env_changed,
                                              self.fail_rerun)
-        if not filename or not exitcode:
+        if not filename or not failed or not exitcode:
             return
-        # Tests which failed in the last run (the re-run, if any)
-        failed = self.results.rerun_results
         cases = [(result.errors or []) + (result.failures or [])
                  for result in failed]
-        ncase = sum(map(len, cases))
+        ncases = sum(map(len, cases))
         with open(filename, "a", encoding="utf-8") as fp:
             def write(text: str) -> None:
                 # Separate Markdown blocks with an empty line
                 print(text, end="\n\n", file=fp)
 
             write(f"## {decolor(self.get_state())}: "
                   f"{count(len(failed), 'test file')} and "
-                  f"{count(ncase, 'test case')} failed")
+                  f"{count(ncases, 'test case')} failed")
             for result, result_cases in zip(failed, cases):
                 write(f"### {decolor(str(result))}")
                 if result.env_changed_reasons:
                     write("\n".join(f"- {reason}"
                                     for reason in result.env_changed_reasons))
                 for name, traceback in result_cases:
-                    # Expand short tracebacks when there are only a few
-                    is_open = ncase <= 5 and traceback.count("\n") < 30
+                    # Expand the tracebacks if they fit on a screen: up to 5
+                    # test cases with a traceback of less than 30 lines
+                    is_open = ncases <= 5 and traceback.count("\n") < 30
                     write(f"<details{' open' if is_open else ''}>"
-                          f"<summary>{name}</summary>")
+                          f"<summary>{html.escape(name)}</summary>")
                     write(f"```pytb\n{decolor(traceback).rstrip()}\n```")
                     write("</details>")
 
@@ -538,6 +540,12 @@ def display_summary(self) -> None:
         print(f"Result: {state}")
 
     def create_run_tests(self, tests: TestTuple) -> RunTests:
+        # Annotate test failures in the GitHub Actions job log of the last
+        # run (the re-run, if any), if it reports failures
+        will_rerun = self.want_rerun and not self.python_cmd
+        github_annotations = (bool(os.environ.get("GITHUB_STEP_SUMMARY"))
+                              and not will_rerun
+                              and bool(self.verbose or self.output_on_failure))
         return RunTests(
             tests,
             fail_fast=self.fail_fast,
@@ -555,10 +563,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),
-            # Only annotate failures of the last run: the re-run, if any
-            github_annotations=(bool(os.environ.get("GITHUB_STEP_SUMMARY"))
-                                and not (self.want_rerun
-                                         and not self.python_cmd)),
+            github_annotations=github_annotations,
             coverage=self.coverage,
             memory_limit=self.memory_limit,
             gc_threshold=self.gc_threshold,
 
@@ -1,10 +1,12 @@
 import dataclasses
+import importlib.util
 import json
 from _colorize import get_colors  # type: ignore[import-not-found]
 from typing import Any
 
+from .runtests import RunTests
 from .utils import (
-    StrJSON, TestName, FilterTuple,
+    StrJSON, TestName, FilterTuple, abs_module_name,
     format_duration, normalize_test_name, print_warning, github_annotation)
 
 
@@ -178,17 +180,21 @@ def __str__(self) -> str:
     def has_meaningful_duration(self):
         return State.has_meaningful_duration(self.state)
 
-    def print_github_crash_annotation(self, fail_env_changed: bool) -> None:
+    def print_github_annotation(self, runtests: RunTests) -> None:
         """Annotate a failed test without test case failures.
 
-        For example: crash, timeout, env changed. Test case failures are
-        annotated by the test runner, where they are reported (see
-        RegressionTestResult.printErrorList()).
+        For example: crash, timeout, env changed. Locate the annotation in the
+        test file. Test case failures are annotated by the test runner, where
+        they are reported (see RegressionTestResult.printErrorList()).
         """
-        if (self.is_failed(fail_env_changed)
+        if (self.is_failed(runtests.fail_env_changed)
                 and not self.errors and not self.failures):
             message = "\n".join([str(self), *(self.env_changed_reasons or ())])
-            print(github_annotation(self.test_name, message), flush=True)
+            spec = importlib.util.find_spec(
+                abs_module_name(self.test_name, runtests.test_dir))
+            filename = spec.origin if spec is not None else None
+            print(github_annotation(self.test_name, message, filename),
+                  flush=True)
 
     def set_env_changed(self, *reasons):
         if self.state is None or self.state == State.PASSED:
 
@@ -614,7 +614,7 @@ def _process_result(self, item: QueueOutput) -> TestResult:
         self.results.accumulate_result(result, self.runtests)
         self.display_result(mp_result)
         if self.runtests.github_annotations:
-            result.print_github_crash_annotation(self.runtests.fail_env_changed)
+            result.print_github_annotation(self.runtests)
 
         # Display worker stdout
         if not self.runtests.output_on_failure:
 
@@ -93,7 +93,7 @@ class RunTests:
     hunt_refleak: HuntRefleak | None
     test_dir: StrPath | None
     use_junit: bool
-    # Print a GitHub Actions error annotation before each failure report
+    # Annotate test failures in the GitHub Actions job log
     github_annotations: bool
     coverage: bool
     memory_limit: str | None
 
@@ -112,14 +112,12 @@ def setup_tests(runtests: RunTests) -> None:
 
     set_match_tests(runtests.match_tests)
 
+    from .testresult import RegressionTestResult
     if runtests.use_junit:
         support.junit_xml_list = []
-        from .testresult import RegressionTestResult
         RegressionTestResult.USE_XML = True
     else:
         support.junit_xml_list = None
-
-    from .testresult import RegressionTestResult
     RegressionTestResult.GITHUB_ANNOTATIONS = runtests.github_annotations
 
     if runtests.memory_limit is not None:
 
@@ -4,6 +4,7 @@
 
 import functools
 import io
+import re
 import sys
 import time
 import traceback
@@ -132,19 +133,25 @@ def addUnexpectedSuccess(self, test):
         super().addUnexpectedSuccess(test)
 
     def printErrorList(self, flavour, errors):
-        if not self.GITHUB_ANNOTATIONS:
-            super().printErrorList(flavour, errors)
-            return
         for test, err in errors:
-            # Precede each failure report with a GitHub Actions annotation,
-            # so that the annotation links to the report in the job log
-            # Locate the annotation in the test file
-            case = getattr(test, "test_case", test)  # subTest()
-            module = sys.modules.get(type(case).__module__)
-            self.stream.writeln(github_annotation(
-                str(test), err, getattr(module, "__file__", None)))
+            if self.GITHUB_ANNOTATIONS:
+                # Write the annotation just before the failure report, so
+                # that it links to the report in the job log
+                self.stream.writeln(github_annotation(str(test), err,
+                                                      self._test_file(test)))
             super().printErrorList(flavour, [(test, err)])
 
+    @staticmethod
+    def _test_file(test):
+        # Test id: "module.Class.method", "module.function" (doctest), or
+        # "setUpClass (module.Class)" (error in a class or module fixture)
+        name = getattr(test, 'test_case', test).id()  # subTest()
+        if match := re.fullmatch(r'\w+ \((.+)\)', name):
+            name = match[1]
+        while name and name not in sys.modules:
+            name = name.rpartition('.')[0]
+        return getattr(sys.modules.get(name), '__file__', None)
+
     def get_xml_element(self):
         if not self.USE_XML:
             raise ValueError("USE_XML is false")
@@ -156,16 +163,11 @@ def get_xml_element(self):
 
 class QuietRegressionTestRunner:
     def __init__(self, stream, buffer=False):
-        # Wrap the stream as TextTestRunner does, for printErrors()
-        stream = unittest.runner._WritelnDecorator(stream)
         self.result = RegressionTestResult(stream, None, 0)
         self.result.buffer = buffer
 
     def run(self, test):
         test(self.result)
-        if self.result.GITHUB_ANNOTATIONS:
-            # Report annotated failures, as in verbose mode
-            self.result.printErrors()
         return self.result
 
 def get_test_runner_class(verbosity, buffer=False):
 
@@ -141,14 +141,30 @@ def print_warning(msg: str) -> None:
 orig_unraisablehook: Callable[..., None] | None = None
 
 
+def repository_path(filename: str) -> str:
+    """Path of a stdlib file relative to the repository.
+
+    Map the stdlib directory (Lib/ in a source checkout or an installed
+    lib/python3.X/) to Lib/. Return other paths unchanged.
+    """
+    stdlib_dir = os.path.dirname(os.__file__) + os.sep
+    if not filename.startswith(stdlib_dir):
+        return filename
+    return "Lib/" + filename.removeprefix(stdlib_dir).replace(os.sep, "/")
+
+
 def github_annotation(title: str, message: str,
-                      filename: str | None = None) -> str:
+                      filename: str | None) -> str:
     """Format a GitHub Actions error annotation.
 
     message is a traceback or a failure description. Only keep the exception
     which ends the traceback: the job log has the full traceback. Locate the
-    annotation at the last frame of the traceback in filename, if any.
+    annotation in filename, the test file, at the last frame of the traceback
+    in this file, if any.
     """
+    if not filename:
+        raise ValueError(f"missing test file of annotation {title!r}")
+
     def escape(text: str) -> str:
         return (text.replace("%", "%25").replace("\r", "%0D")
                 .replace("\n", "%0A"))
@@ -157,18 +173,15 @@ def escape_property(text: str) -> str:
         return escape(text).replace(":", "%3A").replace(",", "%2C")
 
     message = decolor(message)
-    props: dict[str, str] = {}
-    # Map the stdlib directory (Lib/ in a source checkout or an installed
-    # lib/python3.X/) to Lib/ in the repository
-    stdlib_dir = os.path.dirname(os.__file__) + os.sep
-    if filename and filename.startswith(stdlib_dir):
-        lines = re.findall(rf'^  File "{re.escape(filename)}", line (\d+)',
-                           message, re.MULTILINE)
-        if lines:
-            relpath = filename.removeprefix(stdlib_dir).replace(os.sep, "/")
-            props |= {"file": f"Lib/{relpath}", "line": lines[-1]}
+    props = {"file": repository_path(filename)}
+    # Line of the last traceback frame ('  File "filename", line 123') or
+    # failed doctest example (same, but not indented) in filename
+    if lines := re.findall(rf'^ *File "{re.escape(filename)}", line (\d+)',
+                           message, re.MULTILINE):
+        props["line"] = lines[-1]
     props["title"] = title
-    # Strip the frames: each "  File" line and its indented source lines
+    # Only keep the exception: strip the traceback frames, each one a
+    # '  File' line followed by its indented source lines
     message = re.split(r'^  File .*\n(?:    .*\n)*', message,
                        flags=re.MULTILINE)[-1].strip()
     props_text = ",".join(f"{key}={escape_property(value)}"