@@ -1,4 +1,3 @@
-import html
 import os
 import random
 import re
@@ -493,30 +492,14 @@ def write_github_summary(self) -> None:
                                              self.fail_rerun)
         if not self.github_summary or not failed or not exitcode:
             return
-        cases = [(result.errors or []) + (result.failures or [])
-                 for result in failed]
-        ncases = sum(map(len, cases))
+        ncases = sum(len(result.test_cases) for result in failed)
         with open(self.github_summary, "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(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 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>{html.escape(name)}</summary>")
-                    write(f"```pytb\n{decolor(traceback).rstrip()}\n```")
-                    write("</details>")
+            fp.write(f"## {decolor(self.get_state())}: "
+                     f"{count(len(failed), 'test file')} and "
+                     f"{count(ncases, 'test case')} failed\n\n")
+            for result in failed:
+                # Expand the tracebacks of up to 5 test cases
+                fp.write(result.format_github_summary(expand=ncases <= 5))
 
     def display_summary(self) -> None:
         if self.first_runtests is None:
 
@@ -1,7 +1,8 @@
 import dataclasses
+import html
 import json
-import os
-from _colorize import get_colors  # type: ignore[import-not-found]
+import pathlib
+from _colorize import decolor, get_colors  # type: ignore[import-not-found]
 from typing import Any
 
 from .findtests import findtestdir
@@ -182,25 +183,49 @@ def __str__(self) -> str:
     def has_meaningful_duration(self):
         return State.has_meaningful_duration(self.state)
 
+    @property
+    def test_cases(self) -> list[tuple[str, str]]:
+        """Failed test cases: list of (name, traceback)."""
+        return (self.errors or []) + (self.failures or [])
+
+    def format_github_summary(self, expand: bool) -> str:
+        """Format the Markdown section of the GitHub Actions job summary."""
+        blocks = [f"### {decolor(str(self))}"]
+        if self.env_changed_reasons:
+            blocks.append("\n".join(f"- {reason}"
+                                    for reason in self.env_changed_reasons))
+        for name, traceback in self.test_cases:
+            # Expand the tracebacks if they fit on a screen: a traceback of
+            # less than 30 lines
+            is_open = expand and traceback.count("\n") < 30
+            blocks += [f"<details{' open' if is_open else ''}>"
+                       f"<summary>{html.escape(name)}</summary>",
+                       f"```pytb\n{decolor(traceback).rstrip()}\n```",
+                       "</details>"]
+        # Separate Markdown blocks with an empty line
+        return "".join(f"{block}\n\n" for block in blocks)
+
     def print_github_annotation(self, runtests: RunTests) -> None:
-        """Annotate a failed test without test case failures.
+        """Annotate each failed test case, or else the failed test file.
 
-        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()).
+        For example, the test file for a crash, timeout or env changed.
         """
-        if (runtests.github_annotations
-                and self.is_failed(runtests.fail_env_changed)
-                and not self.errors and not self.failures):
+        if not (runtests.github_annotations
+                and self.is_failed(runtests.fail_env_changed)):
+            return
+        # Test file: "test_x" is test_x.py or test_x/__init__.py,
+        # "test.test_x.test_y" is test_x/test_y.py
+        name = self.test_name.removeprefix("test.")
+        path = pathlib.Path(findtestdir(runtests.test_dir), *name.split("."))
+        filename = path.with_suffix(".py")
+        if not filename.exists():
+            filename = path / "__init__.py"
+        test_cases = self.test_cases
+        if not test_cases:
             message = "\n".join([str(self), *(self.env_changed_reasons or ())])
-            # Test file: "test_x" is test_x.py or test_x/__init__.py,
-            # "test.test_x.test_y" is test_x/test_y.py
-            name = self.test_name.removeprefix("test.")
-            path = os.path.join(findtestdir(runtests.test_dir), *name.split("."))
-            filename = path + ".py"
-            if not os.path.exists(filename):
-                filename = os.path.join(path, "__init__.py")
-            print_github_annotation(self.test_name, message, filename)
+            test_cases = [(self.test_name, message)]
+        for title, message in test_cases:
+            print_github_annotation(title, message, str(filename))
 
     def set_env_changed(self, *reasons):
         if self.state is None or self.state == State.PASSED:
 
@@ -12,7 +12,6 @@
 
 from .filter import set_match_tests
 from .runtests import RunTests
-lazy from .testresult import RegressionTestResult
 from .utils import (
     setup_unraisable_hook, setup_threading_excepthook,
     adjust_rlimit_nofile)
@@ -113,9 +112,9 @@ def setup_tests(runtests: RunTests) -> None:
 
     set_match_tests(runtests.match_tests)
 
-    RegressionTestResult.GITHUB_ANNOTATIONS = runtests.github_annotations
     if runtests.use_junit:
         support.junit_xml_list = []
+        from .testresult import RegressionTestResult
         RegressionTestResult.USE_XML = True
     else:
         support.junit_xml_list = None
 
@@ -9,11 +9,10 @@
 import traceback
 import unittest
 from test import support
-from test.libregrtest.utils import print_github_annotation, sanitize_xml
+from test.libregrtest.utils import sanitize_xml
 
 class RegressionTestResult(unittest.TextTestResult):
     USE_XML = False
-    GITHUB_ANNOTATIONS = False
 
     def __init__(self, stream, descriptions, verbosity):
         super().__init__(stream=stream, descriptions=descriptions,
@@ -131,14 +130,6 @@ def addUnexpectedSuccess(self, test):
         self._add_result(test, outcome='UNEXPECTED_SUCCESS')
         super().addUnexpectedSuccess(test)
 
-    def printErrorList(self, flavour, errors):
-        for test, err in errors:
-            super().printErrorList(flavour, [(test, err)])
-            # Annotate just after the failure report, so that the annotation
-            # links to the report in the job log
-            if self.GITHUB_ANNOTATIONS:
-                print_github_annotation(str(test), err, file=self.stream)
-
     def get_xml_element(self):
         if not self.USE_XML:
             raise ValueError("USE_XML is false")
 
@@ -148,26 +148,25 @@ def print_warning(msg: str) -> None:
                                                              ",": "%2C"})
 
 
-def print_github_annotation(title: str, message: str,
-                            filename: str | None = None, file=None) -> None:
+def print_github_annotation(title: str, message: str, filename: str) -> None:
     """Print 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 traceback frame in a test file, or else at the
     first frame (the test), or else in filename (the test file).
     """
+    if not filename:
+        raise ValueError(f"missing test file of annotation {title!r}")
     message = decolor(message)
     line = None
     # Traceback frames ('  File "filename", line 123') and failed doctest
     # examples (same, but not indented)
     if frames := re.findall(r'^ *File "(.*)", line (\d+)', message,
                             re.MULTILINE):
         test_frames = [frame for frame in frames
-                       if os.path.basename(frame[0]).startswith('test_')]
+                       if pathlib.Path(frame[0]).name.startswith('test_')]
         filename, line = test_frames[-1] if test_frames else frames[0]
-    if not filename:
-        raise ValueError(f"missing test file of annotation {title!r}")
     # In the job, the stdlib can be outside of the repository checkout
     path = pathlib.Path(filename)
     stdlib_dir = pathlib.Path(os.__file__).parent
@@ -181,7 +180,7 @@ def print_github_annotation(title: str, message: str,
     props_text = ",".join(f"{key}={value.translate(GITHUB_ESCAPE_PROPERTY)}"
                           for key, value in props.items() if value)
     print(f"::error {props_text}::{message.translate(GITHUB_ESCAPE_DATA)}",
-          file=file, flush=True)
+          flush=True)
 
 
 def regrtest_unraisable_hook(unraisable) -> None: