<form method="POST">
    <h3>Editing: TestDoxPrinter.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 get_class;
use function implode;
use function method_exists;
use function preg_split;
use function trim;
use PHPUnit\Framework\AssertionFailedError;
use PHPUnit\Framework\Exception;
use PHPUnit\Framework\Reorderable;
use PHPUnit\Framework\Test;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\TestFailure;
use PHPUnit\Framework\TestResult;
use PHPUnit\Framework\TestSuite;
use PHPUnit\Framework\Warning;
use PHPUnit\Runner\BaseTestRunner;
use PHPUnit\Runner\PhptTestCase;
use PHPUnit\TextUI\DefaultResultPrinter;
use PHPUnit\Util\Filter;
use SebastianBergmann\RecursionContext\InvalidArgumentException;
use Throwable;

/**
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
 */
class TestDoxPrinter extends DefaultResultPrinter
{
    /**
     * @var NamePrettifier
     */
    protected $prettifier;

    /**
     * @var int The number of test results received from the TestRunner
     */
    protected $testIndex = 0;

    /**
     * @var int The number of test results already sent to the output
     */
    protected $testFlushIndex = 0;

    /**
     * @var array&lt;int, array&gt; Buffer for test results
     */
    protected $testResults = [];

    /**
     * @var array&lt;string, int&gt; Lookup table for testname to testResults[index]
     */
    protected $testNameResultIndex = [];

    /**
     * @var bool
     */
    protected $enableOutputBuffer = false;

    /**
     * @var array array&lt;string&gt;
     */
    protected $originalExecutionOrder = [];

    /**
     * @var int
     */
    protected $spinState = 0;

    /**
     * @var bool
     */
    protected $showProgress = true;

    /**
     * @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;prettifier = new NamePrettifier($this-&gt;colors);
    }

    public function setOriginalExecutionOrder(array $order): void
    {
        $this-&gt;originalExecutionOrder = $order;
        $this-&gt;enableOutputBuffer     = !empty($order);
    }

    public function setShowProgressAnimation(bool $showProgress): void
    {
        $this-&gt;showProgress = $showProgress;
    }

    public function printResult(TestResult $result): void
    {
    }

    /**
     * @throws InvalidArgumentException
     */
    public function endTest(Test $test, float $time): void
    {
        if (!$test instanceof TestCase &amp;&amp; !$test instanceof PhptTestCase &amp;&amp; !$test instanceof TestSuite) {
            return;
        }

        if ($this-&gt;testHasPassed()) {
            $this-&gt;registerTestResult($test, null, BaseTestRunner::STATUS_PASSED, $time, false);
        }

        if ($test instanceof TestCase || $test instanceof PhptTestCase) {
            $this-&gt;testIndex++;
        }

        parent::endTest($test, $time);
    }

    /**
     * @throws InvalidArgumentException
     */
    public function addError(Test $test, Throwable $t, float $time): void
    {
        $this-&gt;registerTestResult($test, $t, BaseTestRunner::STATUS_ERROR, $time, true);
    }

    /**
     * @throws InvalidArgumentException
     */
    public function addWarning(Test $test, Warning $e, float $time): void
    {
        $this-&gt;registerTestResult($test, $e, BaseTestRunner::STATUS_WARNING, $time, true);
    }

    /**
     * @throws InvalidArgumentException
     */
    public function addFailure(Test $test, AssertionFailedError $e, float $time): void
    {
        $this-&gt;registerTestResult($test, $e, BaseTestRunner::STATUS_FAILURE, $time, true);
    }

    /**
     * @throws InvalidArgumentException
     */
    public function addIncompleteTest(Test $test, Throwable $t, float $time): void
    {
        $this-&gt;registerTestResult($test, $t, BaseTestRunner::STATUS_INCOMPLETE, $time, false);
    }

    /**
     * @throws InvalidArgumentException
     */
    public function addRiskyTest(Test $test, Throwable $t, float $time): void
    {
        $this-&gt;registerTestResult($test, $t, BaseTestRunner::STATUS_RISKY, $time, false);
    }

    /**
     * @throws InvalidArgumentException
     */
    public function addSkippedTest(Test $test, Throwable $t, float $time): void
    {
        $this-&gt;registerTestResult($test, $t, BaseTestRunner::STATUS_SKIPPED, $time, false);
    }

    public function writeProgress(string $progress): void
    {
        $this-&gt;flushOutputBuffer();
    }

    public function flush(): void
    {
        $this-&gt;flushOutputBuffer(true);
    }

    /**
     * @throws InvalidArgumentException
     */
    protected function registerTestResult(Test $test, ?Throwable $t, int $status, float $time, bool $verbose): void
    {
        $testName = $test instanceof Reorderable ? $test-&gt;sortId() : $test-&gt;getName();

        $result = [
            'className'  =&gt; $this-&gt;formatClassName($test),
            'testName'   =&gt; $testName,
            'testMethod' =&gt; $this-&gt;formatTestName($test),
            'message'    =&gt; '',
            'status'     =&gt; $status,
            'time'       =&gt; $time,
            'verbose'    =&gt; $verbose,
        ];

        if ($t !== null) {
            $result['message'] = $this-&gt;formatTestResultMessage($t, $result);
        }

        $this-&gt;testResults[$this-&gt;testIndex]  = $result;
        $this-&gt;testNameResultIndex[$testName] = $this-&gt;testIndex;
    }

    protected function formatTestName(Test $test): string
    {
        return method_exists($test, 'getName') ? $test-&gt;getName() : '';
    }

    protected function formatClassName(Test $test): string
    {
        return get_class($test);
    }

    protected function testHasPassed(): bool
    {
        if (!isset($this-&gt;testResults[$this-&gt;testIndex]['status'])) {
            return true;
        }

        if ($this-&gt;testResults[$this-&gt;testIndex]['status'] === BaseTestRunner::STATUS_PASSED) {
            return true;
        }

        return false;
    }

    protected function flushOutputBuffer(bool $forceFlush = false): void
    {
        if ($this-&gt;testFlushIndex === $this-&gt;testIndex) {
            return;
        }

        if ($this-&gt;testFlushIndex &gt; 0) {
            if ($this-&gt;enableOutputBuffer &amp;&amp;
                isset($this-&gt;originalExecutionOrder[$this-&gt;testFlushIndex - 1])) {
                $prevResult = $this-&gt;getTestResultByName($this-&gt;originalExecutionOrder[$this-&gt;testFlushIndex - 1]);
            } else {
                $prevResult = $this-&gt;testResults[$this-&gt;testFlushIndex - 1];
            }
        } else {
            $prevResult = $this-&gt;getEmptyTestResult();
        }

        if (!$this-&gt;enableOutputBuffer) {
            $this-&gt;writeTestResult($prevResult, $this-&gt;testResults[$this-&gt;testFlushIndex++]);
        } else {
            do {
                $flushed = false;

                if (!$forceFlush &amp;&amp; isset($this-&gt;originalExecutionOrder[$this-&gt;testFlushIndex])) {
                    $result = $this-&gt;getTestResultByName($this-&gt;originalExecutionOrder[$this-&gt;testFlushIndex]);
                } else {
                    // This test(name) cannot found in original execution order,
                    // flush result to output stream right away
                    $result = $this-&gt;testResults[$this-&gt;testFlushIndex];
                }

                if (!empty($result)) {
                    $this-&gt;hideSpinner();
                    $this-&gt;writeTestResult($prevResult, $result);
                    $this-&gt;testFlushIndex++;
                    $prevResult = $result;
                    $flushed    = true;
                } else {
                    $this-&gt;showSpinner();
                }
            } while ($flushed &amp;&amp; $this-&gt;testFlushIndex &lt; $this-&gt;testIndex);
        }
    }

    protected function showSpinner(): void
    {
        if (!$this-&gt;showProgress) {
            return;
        }

        if ($this-&gt;spinState) {
            $this-&gt;undrawSpinner();
        }

        $this-&gt;spinState++;
        $this-&gt;drawSpinner();
    }

    protected function hideSpinner(): void
    {
        if (!$this-&gt;showProgress) {
            return;
        }

        if ($this-&gt;spinState) {
            $this-&gt;undrawSpinner();
        }

        $this-&gt;spinState = 0;
    }

    protected function drawSpinner(): void
    {
        // optional for CLI printers: show the user a 'buffering output' spinner
    }

    protected function undrawSpinner(): void
    {
        // remove the spinner from the current line
    }

    protected function writeTestResult(array $prevResult, array $result): void
    {
    }

    protected function getEmptyTestResult(): array
    {
        return [
            'className' =&gt; '',
            'testName'  =&gt; '',
            'message'   =&gt; '',
            'failed'    =&gt; '',
            'verbose'   =&gt; '',
        ];
    }

    protected function getTestResultByName(?string $testName): array
    {
        if (isset($this-&gt;testNameResultIndex[$testName])) {
            return $this-&gt;testResults[$this-&gt;testNameResultIndex[$testName]];
        }

        return [];
    }

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

        if ($message) {
            $message .= PHP_EOL . PHP_EOL . $this-&gt;formatStacktrace($t);
        } else {
            $message = $this-&gt;formatStacktrace($t);
        }

        return $message;
    }

    protected function formatStacktrace(Throwable $t): string
    {
        return Filter::getFilteredStacktrace($t);
    }

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

        if ($message === '') {
            return '';
        }

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

        return $this-&gt;prefixLines($prefix, $message);
    }

    protected function prefixLines(string $prefix, string $message): string
    {
        $message = trim($message);

        return implode(
            PHP_EOL,
            array_map(
                static function (string $text) use ($prefix)
                {
                    return '   ' . $prefix . ($text ? ' ' . $text : '');
                },
                preg_split('/\r\n|\r|\n/', $message),
            ),
        );
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>