+  # GitLab's log viewer renders ANSI colors, but stdout here is not a tty,

+  # so the driver must be told to emit them.

+  RUNTEST_ARGS="${RUNTEST_ARGS:-} --force-colors"

+

+parser.add_argument("--force-colors", action="store_true",

+                        help="emit ANSI colors even when stdout is not a tty (e.g. for CI logs)")

+# config.supports_colors deliberately stays tty-based: it also guards

+# terminal-title updates, which must not end up in a CI log.

+term_color.enable_color = config.supports_colors or args.force_colors

+    summary(t, sys.stdout, color=term_color.enable_color, junit_path=args.junit)

+# Whether to emit color escapes; set in runtests.py.

+# For renderers that serve several sinks: `enabled` says whether *this* sink

+# takes color (the summary is written both to stdout and to a plain-text file).

+def colored_if(enabled: bool, color: Color, s: str) -> str:

+    return colored(color, s) if enabled else s

+from term_color import Color, colored_if

+def _result_directory(opts: TestOptions) -> str:

+    # The test's source directory, relative to the GHC source root, so it reads

+    # the same regardless of which directory `make` was invoked from.

+    srcdir = opts.srcdir

+    if srcdir is None:

+        return ''

+    try:

+        return os.path.relpath(srcdir, config.top.parent)

+    except ValueError:

+        # No relative path exists (e.g. different Windows drives); the

+        # absolute path is still more useful than nothing.

+        return str(srcdir)

+

+    directory = _result_directory(opts)

+      directory = _result_directory(opts)

+    directory = _result_directory(opts)

+        return failBecause(message,

+                           stderr=read_stderr(name),

+                           stdout=read_stdout(name))

+        # The diff already contains the mismatching stream; see Note [Redundant

+        # output in test results].

+                           stderr=None if stderr_match.diff else read_stderr(name),

+                           stdout=None if stdout_match.diff else read_stdout(name),

+        # See Note [Redundant output in test results].

+                           stderr=None if stderr_match.diff else read_stderr(name),

+                           stdout=None if stdout_match.diff else read_stdout(name),

+        return path.read_text(encoding='UTF-8', errors='replace')

+        diff = diff_file.read_text(encoding='UTF-8', errors='replace')

+        return path.read_text(encoding='UTF-8', errors='replace')

+        return path.read_text(encoding='UTF-8', errors='replace')

+def summary(t: TestRun, file: TextIO, color=False, junit_path: Optional[Path]=None) -> None:

+

+    if t.unexpected_failures:

+        # Count output blocks rather than results: a test failing in many ways

+        # collapses to a single block.

+        groups = groupTestOutput(t.unexpected_failures)

+        if len(groups) <= MAX_SUMMARY_OUTPUT_TESTS:

+            printTestOutputSummary(file, groups, color, junit_path)

+        else:

+            where = '; see {}'.format(junit_path) if junit_path else ''

+            header = ('Unexpected failures (more than {}, output omitted{}):'

+                      .format(MAX_SUMMARY_OUTPUT_TESTS, where))

+            file.write(colored_if(color, Color.RED, header) + '\n')

+            printTestInfosSummary(file, t.unexpected_failures)

+

+    if t.unexpected_passes:

+        header = 'Unexpected passes:'

+        file.write(colored_if(color, Color.RED, header) + '\n')

+        printTestInfosSummary(file, t.unexpected_passes)

+

+    if t.unexpected_stat_failures:

+        header = 'Unexpected stat failures:'

+        file.write(colored_if(color, Color.RED, header) + '\n')

+        printTestInfosSummary(file, t.unexpected_stat_failures)

+

+    if t.framework_failures:

+        header = 'Framework failures:'

+        file.write(colored_if(color, Color.RED, header) + '\n')

+        printTestInfosSummary(file, t.framework_failures)

+

+    if t.framework_warnings:

+        header = 'Framework warnings:'

+        file.write(colored_if(color, Color.YELLOW, header) + '\n')

+        printTestInfosSummary(file, t.framework_warnings)

+

+    if stopping():

+        warning = 'WARNING: Testsuite run was terminated early'

+        file.write(colored_if(color, Color.YELLOW, warning) + '\n')

+

+         t.unexpected_stat_failures, t.framework_failures], color)

+    summary_header = colored_if(color, summary_color, 'SUMMARY')

+    file.write(summary_header + ' for test run started at '

+def printUnexpectedTests(file: TextIO, testInfoss, color=False):

+        header = 'Unexpected results from:'

+        file.write(colored_if(color, Color.RED, header) + '\n')

+# Per-stream cap on a failing test's output repeated in the final summary.

+MAX_SUMMARY_OUTPUT_LINES = 100

+

+# Above this many output blocks, skip repeating output entirely: the dump

+# would drown out the summary.

+MAX_SUMMARY_OUTPUT_TESTS = 20

+

+# Note [Redundant output in test results]

+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+# A failing test result carries up to three pieces of output: `diff`, `stdout`

+# and `stderr`. For an output mismatch these overlap: the diff's `+` lines are

+# the very stream that mismatched, normalised. Reporting both would print the

+# same text twice, so the mismatching stream is dropped at the call sites in

+# favour of the diff, which additionally shows what was expected. The *other*

+# stream is kept: on a stdout mismatch, stderr is independent context.

+#

+# The drop is conditional on there being a diff at all: compare_outputs only

+# runs `diff` when config.verbose >= 1, so under -v0 the stream is the only

+# output there is.

+#

+# Note that, since the drop happens at result construction, it also affects the

+# JUnit report (junit.py).

+

+def strip_diff_header(diff: Optional[str]) -> Optional[str]:

+    # Drop diff(1)'s ---/+++ lines: they name normalised files in the test

+    # directory and carry timestamps, which would also keep otherwise

+    # identical failures from being grouped.

+    if diff is None:

+        return None

+    lines = diff.split('\n')

+    if len(lines) >= 2 and lines[0].startswith('--- ') and lines[1].startswith('+++ '):

+        return '\n'.join(lines[2:])

+    return diff

+

+def sorted_results(testInfos: List[TestResult]) -> List[TestResult]:

+    return sorted(testInfos, key=lambda r: (r.testname.lower(), r.directory, r.way))

+

+# A failure-output block: a representative result, its header-stripped diff,

+# and the ways that share it.

+OutputGroup = Tuple[TestResult, Optional[str], List[WayName]]

+

+# Tests that fail identically in several ways (e.g. normal and g1) share one

+# output block, with the ways collected in the header.

+def groupTestOutput(testInfos: List[TestResult]) -> List[OutputGroup]:

+    # Relies on dicts preserving insertion order.

+    groups = {} # type: Dict[Tuple, OutputGroup]

+    for result in sorted_results(testInfos):

+        diff = strip_diff_header(result.diff)

+        key = (result.testname, result.directory, result.reason,

+               diff, result.stdout, result.stderr)

+        groups.setdefault(key, (result, diff, []))[2].append(result.way)

+    return list(groups.values())

+

+def printTestOutputSummary(file: TextIO,

+                           groups: List[OutputGroup],

+                           color: bool=False,

+                           junit_path: Optional[Path]=None) -> None:

+    # Repeat failing tests' captured output in the summary, so one needn't

+    # hunt for it earlier in a possibly very long log; see #16720.

+    header = '=====> Unexpected failures output summary'

+    file.write(colored_if(color, Color.RED, header) + '\n\n')

+

+    where = ', see {}'.format(junit_path) if junit_path else ''

+    for result, diff, ways in groups:

+        header = '=====> {}({}) ({}) [{}]'.format(

+            result.testname, ', '.join(ways), result.directory + os.sep, result.reason)

+        file.write(colored_if(color, Color.RED, header) + '\n')

+        # See Note [Redundant output in test results] for why these don't overlap.

+        for label, contents in [('Output diff (expected vs actual):', diff),

+                                ('Captured stdout:', result.stdout),

+                                ('Captured stderr:', result.stderr)]:

+            if contents and contents.strip():

+                lines = contents.rstrip('\n').split('\n')

+                if len(lines) > MAX_SUMMARY_OUTPUT_LINES:

+                    omitted = len(lines) - MAX_SUMMARY_OUTPUT_LINES

+                    lines = lines[:MAX_SUMMARY_OUTPUT_LINES] \

+                        + ['... ({} more lines omitted{})'.format(omitted, where)]

+                s = colored_if(color, Color.CYAN, label) + '\n' \

+                    + ''.join(l + '\n' for l in lines)

+                # Test output can contain characters that file's encoding

+                # cannot represent; replace rather than crash (cf safe_print).

+                enc = getattr(file, 'encoding', None) or 'utf-8'

+                file.write(s.encode(enc, errors='replace').decode(enc))

+    footer = '<===== end of unexpected failures output summary'

+    file.write(colored_if(color, Color.RED, footer) + '\n\n')

+

+    for result in sorted_results(testInfos):

+        path = os.path.join(result.directory, result.testname)

+        file.write('   {path} [{r.reason}] ({r.way})\n'.format(r=result, path=path))