<form method="POST">
    <h3>Editing: CliTestDoxPrinter.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (c) Sebastian Bergmann &lt;sebastian@phpunit.de&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PHPUnit\Util\TestDox;

use const PHP_EOL;
use function array_map;
use function ceil;
use function count;
use function explode;
use function get_class;
use function implode;
use function preg_match;
use function sprintf;
use function strlen;
use function strpos;
use function trim;
use PHPUnit\Framework\Exception;
use PHPUnit\Framework\Test;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\TestFailure;
use PHPUnit\Framework\TestResult;
use PHPUnit\Runner\BaseTestRunner;
use PHPUnit\Runner\PhptTestCase;
use PHPUnit\Util\Color;
use PHPUnit\Util\Filter;
use SebastianBergmann\RecursionContext\InvalidArgumentException;
use SebastianBergmann\Timer\ResourceUsageFormatter;
use SebastianBergmann\Timer\Timer;
use Throwable;

/**
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
 */
class CliTestDoxPrinter extends TestDoxPrinter
{
    /**
     * The default Testdox left margin for messages is a vertical line.
     */
    private const PREFIX_SIMPLE = [
        'default' =&gt; '│',
        'start'   =&gt; '│',
        'message' =&gt; '│',
        'diff'    =&gt; '│',
        'trace'   =&gt; '│',
        'last'    =&gt; '│',
    ];

    /**
     * Colored Testdox use box-drawing for a more textured map of the message.
     */
    private const PREFIX_DECORATED = [
        'default' =&gt; '│',
        'start'   =&gt; '┐',
        'message' =&gt; '├',
        'diff'    =&gt; '┊',
        'trace'   =&gt; '╵',
        'last'    =&gt; '┴',
    ];

    private const SPINNER_ICONS = [
        &quot; \e[36m◐\e[0m running tests&quot;,
        &quot; \e[36m◓\e[0m running tests&quot;,
        &quot; \e[36m◑\e[0m running tests&quot;,
        &quot; \e[36m◒\e[0m running tests&quot;,
    ];
    private const STATUS_STYLES = [
        BaseTestRunner::STATUS_PASSED =&gt; [
            'symbol' =&gt; '✔',
            'color'  =&gt; 'fg-green',
        ],
        BaseTestRunner::STATUS_ERROR =&gt; [
            'symbol'  =&gt; '✘',
            'color'   =&gt; 'fg-yellow',
            'message' =&gt; 'bg-yellow,fg-black',
        ],
        BaseTestRunner::STATUS_FAILURE =&gt; [
            'symbol'  =&gt; '✘',
            'color'   =&gt; 'fg-red',
            'message' =&gt; 'bg-red,fg-white',
        ],
        BaseTestRunner::STATUS_SKIPPED =&gt; [
            'symbol'  =&gt; '↩',
            'color'   =&gt; 'fg-cyan',
            'message' =&gt; 'fg-cyan',
        ],
        BaseTestRunner::STATUS_RISKY =&gt; [
            'symbol'  =&gt; '☢',
            'color'   =&gt; 'fg-yellow',
            'message' =&gt; 'fg-yellow',
        ],
        BaseTestRunner::STATUS_INCOMPLETE =&gt; [
            'symbol'  =&gt; '∅',
            'color'   =&gt; 'fg-yellow',
            'message' =&gt; 'fg-yellow',
        ],
        BaseTestRunner::STATUS_WARNING =&gt; [
            'symbol'  =&gt; '⚠',
            'color'   =&gt; 'fg-yellow',
            'message' =&gt; 'fg-yellow',
        ],
        BaseTestRunner::STATUS_UNKNOWN =&gt; [
            'symbol'  =&gt; '?',
            'color'   =&gt; 'fg-blue',
            'message' =&gt; 'fg-white,bg-blue',
        ],
    ];

    /**
     * @var int[]
     */
    private $nonSuccessfulTestResults = [];

    /**
     * @var Timer
     */
    private $timer;

    /**
     * @param null|resource|string $out
     * @param int|string           $numberOfColumns
     *
     * @throws Exception
     */
    public function __construct($out = null, bool $verbose = false, string $colors = self::COLOR_DEFAULT, bool $debug = false, $numberOfColumns = 80, bool $reverse = false)
    {
        parent::__construct($out, $verbose, $colors, $debug, $numberOfColumns, $reverse);

        $this-&gt;timer = new Timer;

        $this-&gt;timer-&gt;start();
    }

    public function printResult(TestResult $result): void
    {
        $this-&gt;printHeader($result);

        $this-&gt;printNonSuccessfulTestsSummary($result-&gt;count());

        $this-&gt;printFooter($result);
    }

    protected function printHeader(TestResult $result): void
    {
        $this-&gt;write(&quot;\n&quot; . (new ResourceUsageFormatter)-&gt;resourceUsage($this-&gt;timer-&gt;stop()) . &quot;\n\n&quot;);
    }

    protected function formatClassName(Test $test): string
    {
        if ($test instanceof TestCase) {
            return $this-&gt;prettifier-&gt;prettifyTestClass(get_class($test));
        }

        return get_class($test);
    }

    /**
     * @throws InvalidArgumentException
     */
    protected function registerTestResult(Test $test, ?Throwable $t, int $status, float $time, bool $verbose): void
    {
        if ($status !== BaseTestRunner::STATUS_PASSED) {
            $this-&gt;nonSuccessfulTestResults[] = $this-&gt;testIndex;
        }

        parent::registerTestResult($test, $t, $status, $time, $verbose);
    }

    /**
     * @throws InvalidArgumentException
     */
    protected function formatTestName(Test $test): string
    {
        if ($test instanceof TestCase) {
            return $this-&gt;prettifier-&gt;prettifyTestCase($test);
        }

        return parent::formatTestName($test);
    }

    protected function writeTestResult(array $prevResult, array $result): void
    {
        // spacer line for new suite headers and after verbose messages
        if ($prevResult['testName'] !== '' &amp;&amp;
            (!empty($prevResult['message']) || $prevResult['className'] !== $result['className'])) {
            $this-&gt;write(PHP_EOL);
        }

        // suite header
        if ($prevResult['className'] !== $result['className']) {
            $this-&gt;write($this-&gt;colorizeTextBox('underlined', $result['className']) . PHP_EOL);
        }

        // test result line
        if ($this-&gt;colors &amp;&amp; $result['className'] === PhptTestCase::class) {
            $testName = Color::colorizePath($result['testName'], $prevResult['testName'], true);
        } else {
            $testName = $result['testMethod'];
        }

        $style = self::STATUS_STYLES[$result['status']];
        $line  = sprintf(
            ' %s %s%s' . PHP_EOL,
            $this-&gt;colorizeTextBox($style['color'], $style['symbol']),
            $testName,
            $this-&gt;verbose ? ' ' . $this-&gt;formatRuntime($result['time'], $style['color']) : '',
        );

        $this-&gt;write($line);

        // additional information when verbose
        $this-&gt;write($result['message']);
    }

    protected function formatThrowable(Throwable $t, ?int $status = null): string
    {
        return trim(TestFailure::exceptionToString($t));
    }

    protected function colorizeMessageAndDiff(string $style, string $buffer): array
    {
        $lines      = $buffer ? array_map('\rtrim', explode(PHP_EOL, $buffer)) : [];
        $message    = [];
        $diff       = [];
        $insideDiff = false;

        foreach ($lines as $line) {
            if ($line === '--- Expected') {
                $insideDiff = true;
            }

            if (!$insideDiff) {
                $message[] = $line;
            } else {
                if (strpos($line, '-') === 0) {
                    $line = Color::colorize('fg-red', Color::visualizeWhitespace($line, true));
                } elseif (strpos($line, '+') === 0) {
                    $line = Color::colorize('fg-green', Color::visualizeWhitespace($line, true));
                } elseif ($line === '@@ @@') {
                    $line = Color::colorize('fg-cyan', $line);
                }
                $diff[] = $line;
            }
        }
        $diff = implode(PHP_EOL, $diff);

        if (!empty($message)) {
            $message = $this-&gt;colorizeTextBox($style, implode(PHP_EOL, $message));
        }

        return [$message, $diff];
    }

    protected function formatStacktrace(Throwable $t): string
    {
        $trace = Filter::getFilteredStacktrace($t);

        if (!$this-&gt;colors) {
            return $trace;
        }

        $lines    = [];
        $prevPath = '';

        foreach (explode(PHP_EOL, $trace) as $line) {
            if (preg_match('/^(.*):(\d+)$/', $line, $matches)) {
                $lines[] = Color::colorizePath($matches[1], $prevPath) .
                    Color::dim(':') .
                    Color::colorize('fg-blue', $matches[2]) .
                    &quot;\n&quot;;
                $prevPath = $matches[1];
            } else {
                $lines[]  = $line;
                $prevPath = '';
            }
        }

        return implode('', $lines);
    }

    protected function formatTestResultMessage(Throwable $t, array $result, ?string $prefix = null): string
    {
        $message = $this-&gt;formatThrowable($t, $result['status']);
        $diff    = '';

        if (!($this-&gt;verbose || $result['verbose'])) {
            return '';
        }

        if ($message &amp;&amp; $this-&gt;colors) {
            $style            = self::STATUS_STYLES[$result['status']]['message'] ?? '';
            [$message, $diff] = $this-&gt;colorizeMessageAndDiff($style, $message);
        }

        if ($prefix === null || !$this-&gt;colors) {
            $prefix = self::PREFIX_SIMPLE;
        }

        if ($this-&gt;colors) {
            $color  = self::STATUS_STYLES[$result['status']]['color'] ?? '';
            $prefix = array_map(static function ($p) use ($color)
            {
                return Color::colorize($color, $p);
            }, self::PREFIX_DECORATED);
        }

        $trace = $this-&gt;formatStacktrace($t);
        $out   = $this-&gt;prefixLines($prefix['start'], PHP_EOL) . PHP_EOL;

        if ($message) {
            $out .= $this-&gt;prefixLines($prefix['message'], $message . PHP_EOL) . PHP_EOL;
        }

        if ($diff) {
            $out .= $this-&gt;prefixLines($prefix['diff'], $diff . PHP_EOL) . PHP_EOL;
        }

        if ($trace) {
            if ($message || $diff) {
                $out .= $this-&gt;prefixLines($prefix['default'], PHP_EOL) . PHP_EOL;
            }
            $out .= $this-&gt;prefixLines($prefix['trace'], $trace . PHP_EOL) . PHP_EOL;
        }
        $out .= $this-&gt;prefixLines($prefix['last'], PHP_EOL) . PHP_EOL;

        return $out;
    }

    protected function drawSpinner(): void
    {
        if ($this-&gt;colors) {
            $id = $this-&gt;spinState % count(self::SPINNER_ICONS);
            $this-&gt;write(self::SPINNER_ICONS[$id]);
        }
    }

    protected function undrawSpinner(): void
    {
        if ($this-&gt;colors) {
            $id = $this-&gt;spinState % count(self::SPINNER_ICONS);
            $this-&gt;write(&quot;\e[1K\e[&quot; . strlen(self::SPINNER_ICONS[$id]) . 'D');
        }
    }

    private function formatRuntime(float $time, string $color = ''): string
    {
        if (!$this-&gt;colors) {
            return sprintf('[%.2f ms]', $time * 1000);
        }

        if ($time &gt; 1) {
            $color = 'fg-magenta';
        }

        return Color::colorize($color, ' ' . (int) ceil($time * 1000) . ' ' . Color::dim('ms'));
    }

    private function printNonSuccessfulTestsSummary(int $numberOfExecutedTests): void
    {
        if (empty($this-&gt;nonSuccessfulTestResults)) {
            return;
        }

        if ((count($this-&gt;nonSuccessfulTestResults) / $numberOfExecutedTests) &gt;= 0.7) {
            return;
        }

        $this-&gt;write(&quot;Summary of non-successful tests:\n\n&quot;);

        $prevResult = $this-&gt;getEmptyTestResult();

        foreach ($this-&gt;nonSuccessfulTestResults as $testIndex) {
            $result = $this-&gt;testResults[$testIndex];
            $this-&gt;writeTestResult($prevResult, $result);
            $prevResult = $result;
        }
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>