<form method="POST">
    <h3>Editing: TestRunner.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\TextUI;

use const PHP_EOL;
use const PHP_SAPI;
use const PHP_VERSION;
use function array_diff;
use function array_map;
use function array_merge;
use function assert;
use function class_exists;
use function count;
use function dirname;
use function file_put_contents;
use function htmlspecialchars;
use function is_array;
use function is_int;
use function is_string;
use function mt_srand;
use function range;
use function realpath;
use function sort;
use function sprintf;
use function time;
use PHPUnit\Framework\Exception;
use PHPUnit\Framework\TestResult;
use PHPUnit\Framework\TestSuite;
use PHPUnit\Runner\AfterLastTestHook;
use PHPUnit\Runner\BaseTestRunner;
use PHPUnit\Runner\BeforeFirstTestHook;
use PHPUnit\Runner\DefaultTestResultCache;
use PHPUnit\Runner\Extension\ExtensionHandler;
use PHPUnit\Runner\Filter\ExcludeGroupFilterIterator;
use PHPUnit\Runner\Filter\Factory;
use PHPUnit\Runner\Filter\IncludeGroupFilterIterator;
use PHPUnit\Runner\Filter\NameFilterIterator;
use PHPUnit\Runner\Hook;
use PHPUnit\Runner\NullTestResultCache;
use PHPUnit\Runner\ResultCacheExtension;
use PHPUnit\Runner\StandardTestSuiteLoader;
use PHPUnit\Runner\TestHook;
use PHPUnit\Runner\TestListenerAdapter;
use PHPUnit\Runner\TestSuiteLoader;
use PHPUnit\Runner\TestSuiteSorter;
use PHPUnit\Runner\Version;
use PHPUnit\TextUI\XmlConfiguration\CodeCoverage\FilterMapper;
use PHPUnit\TextUI\XmlConfiguration\Configuration;
use PHPUnit\TextUI\XmlConfiguration\Loader;
use PHPUnit\TextUI\XmlConfiguration\PhpHandler;
use PHPUnit\Util\Filesystem;
use PHPUnit\Util\Log\JUnit;
use PHPUnit\Util\Log\TeamCity;
use PHPUnit\Util\Printer;
use PHPUnit\Util\TestDox\CliTestDoxPrinter;
use PHPUnit\Util\TestDox\HtmlResultPrinter;
use PHPUnit\Util\TestDox\TextResultPrinter;
use PHPUnit\Util\TestDox\XmlResultPrinter;
use PHPUnit\Util\XdebugFilterScriptGenerator;
use PHPUnit\Util\Xml\SchemaDetector;
use ReflectionClass;
use ReflectionException;
use SebastianBergmann\CodeCoverage\CodeCoverage;
use SebastianBergmann\CodeCoverage\Driver\Selector;
use SebastianBergmann\CodeCoverage\Exception as CodeCoverageException;
use SebastianBergmann\CodeCoverage\Filter as CodeCoverageFilter;
use SebastianBergmann\CodeCoverage\Report\Clover as CloverReport;
use SebastianBergmann\CodeCoverage\Report\Cobertura as CoberturaReport;
use SebastianBergmann\CodeCoverage\Report\Crap4j as Crap4jReport;
use SebastianBergmann\CodeCoverage\Report\Html\Facade as HtmlReport;
use SebastianBergmann\CodeCoverage\Report\PHP as PhpReport;
use SebastianBergmann\CodeCoverage\Report\Text as TextReport;
use SebastianBergmann\CodeCoverage\Report\Xml\Facade as XmlReport;
use SebastianBergmann\Comparator\Comparator;
use SebastianBergmann\Environment\Runtime;
use SebastianBergmann\Invoker\Invoker;
use SebastianBergmann\Timer\Timer;

/**
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
 */
final class TestRunner extends BaseTestRunner
{
    public const SUCCESS_EXIT   = 0;
    public const FAILURE_EXIT   = 1;
    public const EXCEPTION_EXIT = 2;

    /**
     * @var CodeCoverageFilter
     */
    private $codeCoverageFilter;

    /**
     * @var TestSuiteLoader
     */
    private $loader;

    /**
     * @var ResultPrinter
     */
    private $printer;

    /**
     * @var bool
     */
    private $messagePrinted = false;

    /**
     * @var Hook[]
     */
    private $extensions = [];

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

    public function __construct(?TestSuiteLoader $loader = null, ?CodeCoverageFilter $filter = null)
    {
        if ($filter === null) {
            $filter = new CodeCoverageFilter;
        }

        $this-&gt;codeCoverageFilter = $filter;
        $this-&gt;loader             = $loader;
        $this-&gt;timer              = new Timer;
    }

    /**
     * @throws \PHPUnit\Runner\Exception
     * @throws Exception
     * @throws XmlConfiguration\Exception
     */
    public function run(TestSuite $suite, array $arguments = [], array $warnings = [], bool $exit = true): TestResult
    {
        if (isset($arguments['configuration'])) {
            $GLOBALS['__PHPUNIT_CONFIGURATION_FILE'] = $arguments['configuration'];
        }

        $this-&gt;handleConfiguration($arguments);

        $warnings = array_merge($warnings, $arguments['warnings']);

        if (is_int($arguments['columns']) &amp;&amp; $arguments['columns'] &lt; 16) {
            $arguments['columns']   = 16;
            $tooFewColumnsRequested = true;
        }

        if (isset($arguments['bootstrap'])) {
            $GLOBALS['__PHPUNIT_BOOTSTRAP'] = $arguments['bootstrap'];
        }

        if ($arguments['backupGlobals'] === true) {
            $suite-&gt;setBackupGlobals(true);
        }

        if ($arguments['backupStaticAttributes'] === true) {
            $suite-&gt;setBackupStaticAttributes(true);
        }

        if ($arguments['beStrictAboutChangesToGlobalState'] === true) {
            $suite-&gt;setBeStrictAboutChangesToGlobalState(true);
        }

        if ($arguments['executionOrder'] === TestSuiteSorter::ORDER_RANDOMIZED) {
            mt_srand($arguments['randomOrderSeed']);
        }

        if ($arguments['cacheResult']) {
            if (!isset($arguments['cacheResultFile'])) {
                if (isset($arguments['configurationObject'])) {
                    assert($arguments['configurationObject'] instanceof Configuration);

                    $cacheLocation = $arguments['configurationObject']-&gt;filename();
                } else {
                    $cacheLocation = $_SERVER['PHP_SELF'];
                }

                $arguments['cacheResultFile'] = null;

                $cacheResultFile = realpath($cacheLocation);

                if ($cacheResultFile !== false) {
                    $arguments['cacheResultFile'] = dirname($cacheResultFile);
                }
            }

            $cache = new DefaultTestResultCache($arguments['cacheResultFile']);

            $this-&gt;addExtension(new ResultCacheExtension($cache));
        }

        if ($arguments['executionOrder'] !== TestSuiteSorter::ORDER_DEFAULT || $arguments['executionOrderDefects'] !== TestSuiteSorter::ORDER_DEFAULT || $arguments['resolveDependencies']) {
            $cache = $cache ?? new NullTestResultCache;

            $cache-&gt;load();

            $sorter = new TestSuiteSorter($cache);

            $sorter-&gt;reorderTestsInSuite($suite, $arguments['executionOrder'], $arguments['resolveDependencies'], $arguments['executionOrderDefects']);
            $originalExecutionOrder = $sorter-&gt;getOriginalExecutionOrder();

            unset($sorter);
        }

        if (is_int($arguments['repeat']) &amp;&amp; $arguments['repeat'] &gt; 0) {
            $_suite = new TestSuite;

            /* @noinspection PhpUnusedLocalVariableInspection */
            foreach (range(1, $arguments['repeat']) as $step) {
                $_suite-&gt;addTest($suite);
            }

            $suite = $_suite;

            unset($_suite);
        }

        $result = $this-&gt;createTestResult();

        $listener       = new TestListenerAdapter;
        $listenerNeeded = false;

        foreach ($this-&gt;extensions as $extension) {
            if ($extension instanceof TestHook) {
                $listener-&gt;add($extension);

                $listenerNeeded = true;
            }
        }

        if ($listenerNeeded) {
            $result-&gt;addListener($listener);
        }

        unset($listener, $listenerNeeded);

        if ($arguments['convertDeprecationsToExceptions']) {
            $result-&gt;convertDeprecationsToExceptions(true);
        }

        if (!$arguments['convertErrorsToExceptions']) {
            $result-&gt;convertErrorsToExceptions(false);
        }

        if (!$arguments['convertNoticesToExceptions']) {
            $result-&gt;convertNoticesToExceptions(false);
        }

        if (!$arguments['convertWarningsToExceptions']) {
            $result-&gt;convertWarningsToExceptions(false);
        }

        if ($arguments['stopOnError']) {
            $result-&gt;stopOnError(true);
        }

        if ($arguments['stopOnFailure']) {
            $result-&gt;stopOnFailure(true);
        }

        if ($arguments['stopOnWarning']) {
            $result-&gt;stopOnWarning(true);
        }

        if ($arguments['stopOnIncomplete']) {
            $result-&gt;stopOnIncomplete(true);
        }

        if ($arguments['stopOnRisky']) {
            $result-&gt;stopOnRisky(true);
        }

        if ($arguments['stopOnSkipped']) {
            $result-&gt;stopOnSkipped(true);
        }

        if ($arguments['stopOnDefect']) {
            $result-&gt;stopOnDefect(true);
        }

        if ($arguments['registerMockObjectsFromTestArgumentsRecursively']) {
            $result-&gt;setRegisterMockObjectsFromTestArgumentsRecursively(true);
        }

        if ($this-&gt;printer === null) {
            if (isset($arguments['printer'])) {
                if ($arguments['printer'] instanceof ResultPrinter) {
                    $this-&gt;printer = $arguments['printer'];
                } elseif (is_string($arguments['printer']) &amp;&amp; class_exists($arguments['printer'], false)) {
                    try {
                        $reflector = new ReflectionClass($arguments['printer']);

                        if ($reflector-&gt;implementsInterface(ResultPrinter::class)) {
                            $this-&gt;printer = $this-&gt;createPrinter($arguments['printer'], $arguments);
                        }

                        // @codeCoverageIgnoreStart
                    } catch (ReflectionException $e) {
                        throw new Exception(
                            $e-&gt;getMessage(),
                            $e-&gt;getCode(),
                            $e,
                        );
                    }
                    // @codeCoverageIgnoreEnd
                }
            } else {
                $this-&gt;printer = $this-&gt;createPrinter(DefaultResultPrinter::class, $arguments);
            }
        }

        if (isset($originalExecutionOrder) &amp;&amp; $this-&gt;printer instanceof CliTestDoxPrinter) {
            assert($this-&gt;printer instanceof CliTestDoxPrinter);

            $this-&gt;printer-&gt;setOriginalExecutionOrder($originalExecutionOrder);
            $this-&gt;printer-&gt;setShowProgressAnimation(!$arguments['noInteraction']);
        }

        $this-&gt;write(Version::getVersionString() . &quot;\n&quot;);

        foreach ($arguments['listeners'] as $listener) {
            $result-&gt;addListener($listener);
        }

        $result-&gt;addListener($this-&gt;printer);

        $coverageFilterFromConfigurationFile = false;
        $coverageFilterFromOption            = false;
        $codeCoverageReports                 = 0;

        if (isset($arguments['testdoxHTMLFile'])) {
            $result-&gt;addListener(
                new HtmlResultPrinter(
                    $arguments['testdoxHTMLFile'],
                    $arguments['testdoxGroups'],
                    $arguments['testdoxExcludeGroups'],
                ),
            );
        }

        if (isset($arguments['testdoxTextFile'])) {
            $result-&gt;addListener(
                new TextResultPrinter(
                    $arguments['testdoxTextFile'],
                    $arguments['testdoxGroups'],
                    $arguments['testdoxExcludeGroups'],
                ),
            );
        }

        if (isset($arguments['testdoxXMLFile'])) {
            $result-&gt;addListener(
                new XmlResultPrinter(
                    $arguments['testdoxXMLFile'],
                ),
            );
        }

        if (isset($arguments['teamcityLogfile'])) {
            $result-&gt;addListener(
                new TeamCity($arguments['teamcityLogfile']),
            );
        }

        if (isset($arguments['junitLogfile'])) {
            $result-&gt;addListener(
                new JUnit(
                    $arguments['junitLogfile'],
                    $arguments['reportUselessTests'],
                ),
            );
        }

        if (isset($arguments['coverageClover'])) {
            $codeCoverageReports++;
        }

        if (isset($arguments['coverageCobertura'])) {
            $codeCoverageReports++;
        }

        if (isset($arguments['coverageCrap4J'])) {
            $codeCoverageReports++;
        }

        if (isset($arguments['coverageHtml'])) {
            $codeCoverageReports++;
        }

        if (isset($arguments['coveragePHP'])) {
            $codeCoverageReports++;
        }

        if (isset($arguments['coverageText'])) {
            $codeCoverageReports++;
        }

        if (isset($arguments['coverageXml'])) {
            $codeCoverageReports++;
        }

        if ($codeCoverageReports &gt; 0 || isset($arguments['xdebugFilterFile'])) {
            if (isset($arguments['coverageFilter'])) {
                if (!is_array($arguments['coverageFilter'])) {
                    $coverageFilterDirectories = [$arguments['coverageFilter']];
                } else {
                    $coverageFilterDirectories = $arguments['coverageFilter'];
                }

                foreach ($coverageFilterDirectories as $coverageFilterDirectory) {
                    $this-&gt;codeCoverageFilter-&gt;includeDirectory($coverageFilterDirectory);
                }

                $coverageFilterFromOption = true;
            }

            if (isset($arguments['configurationObject'])) {
                assert($arguments['configurationObject'] instanceof Configuration);

                $codeCoverageConfiguration = $arguments['configurationObject']-&gt;codeCoverage();

                if ($codeCoverageConfiguration-&gt;hasNonEmptyListOfFilesToBeIncludedInCodeCoverageReport()) {
                    $coverageFilterFromConfigurationFile = true;

                    (new FilterMapper)-&gt;map(
                        $this-&gt;codeCoverageFilter,
                        $codeCoverageConfiguration,
                    );
                }
            }
        }

        if ($codeCoverageReports &gt; 0) {
            try {
                if (isset($codeCoverageConfiguration) &amp;&amp;
                    ($codeCoverageConfiguration-&gt;pathCoverage() || (isset($arguments['pathCoverage']) &amp;&amp; $arguments['pathCoverage'] === true))) {
                    $codeCoverageDriver = (new Selector)-&gt;forLineAndPathCoverage($this-&gt;codeCoverageFilter);
                } else {
                    $codeCoverageDriver = (new Selector)-&gt;forLineCoverage($this-&gt;codeCoverageFilter);
                }

                $codeCoverage = new CodeCoverage(
                    $codeCoverageDriver,
                    $this-&gt;codeCoverageFilter,
                );

                if (isset($codeCoverageConfiguration) &amp;&amp; $codeCoverageConfiguration-&gt;hasCacheDirectory()) {
                    $codeCoverage-&gt;cacheStaticAnalysis($codeCoverageConfiguration-&gt;cacheDirectory()-&gt;path());
                }

                if (isset($arguments['coverageCacheDirectory'])) {
                    $codeCoverage-&gt;cacheStaticAnalysis($arguments['coverageCacheDirectory']);
                }

                $codeCoverage-&gt;excludeSubclassesOfThisClassFromUnintentionallyCoveredCodeCheck(Comparator::class);

                if ($arguments['strictCoverage']) {
                    $codeCoverage-&gt;enableCheckForUnintentionallyCoveredCode();
                }

                if (isset($arguments['ignoreDeprecatedCodeUnitsFromCodeCoverage'])) {
                    if ($arguments['ignoreDeprecatedCodeUnitsFromCodeCoverage']) {
                        $codeCoverage-&gt;ignoreDeprecatedCode();
                    } else {
                        $codeCoverage-&gt;doNotIgnoreDeprecatedCode();
                    }
                }

                if (isset($arguments['disableCodeCoverageIgnore'])) {
                    if ($arguments['disableCodeCoverageIgnore']) {
                        $codeCoverage-&gt;disableAnnotationsForIgnoringCode();
                    } else {
                        $codeCoverage-&gt;enableAnnotationsForIgnoringCode();
                    }
                }

                if (isset($arguments['configurationObject'])) {
                    $codeCoverageConfiguration = $arguments['configurationObject']-&gt;codeCoverage();

                    if ($codeCoverageConfiguration-&gt;hasNonEmptyListOfFilesToBeIncludedInCodeCoverageReport()) {
                        if ($codeCoverageConfiguration-&gt;includeUncoveredFiles()) {
                            $codeCoverage-&gt;includeUncoveredFiles();
                        } else {
                            $codeCoverage-&gt;excludeUncoveredFiles();
                        }

                        if ($codeCoverageConfiguration-&gt;processUncoveredFiles()) {
                            $codeCoverage-&gt;processUncoveredFiles();
                        } else {
                            $codeCoverage-&gt;doNotProcessUncoveredFiles();
                        }
                    }
                }

                if ($this-&gt;codeCoverageFilter-&gt;isEmpty()) {
                    if (!$coverageFilterFromConfigurationFile &amp;&amp; !$coverageFilterFromOption) {
                        $warnings[] = 'No filter is configured, code coverage will not be processed';
                    } else {
                        $warnings[] = 'Incorrect filter configuration, code coverage will not be processed';
                    }

                    unset($codeCoverage);
                }
            } catch (CodeCoverageException $e) {
                $warnings[] = $e-&gt;getMessage();
            }
        }

        if ($arguments['verbose']) {
            if (PHP_SAPI === 'phpdbg') {
                $this-&gt;writeMessage('Runtime', 'PHPDBG ' . PHP_VERSION);
            } else {
                $runtime = 'PHP ' . PHP_VERSION;

                if (isset($codeCoverageDriver)) {
                    $runtime .= ' with ' . $codeCoverageDriver-&gt;nameAndVersion();
                }

                $this-&gt;writeMessage('Runtime', $runtime);
            }

            if (isset($arguments['configurationObject'])) {
                assert($arguments['configurationObject'] instanceof Configuration);

                $this-&gt;writeMessage(
                    'Configuration',
                    $arguments['configurationObject']-&gt;filename(),
                );
            }

            foreach ($arguments['loadedExtensions'] as $extension) {
                $this-&gt;writeMessage(
                    'Extension',
                    $extension,
                );
            }

            foreach ($arguments['notLoadedExtensions'] as $extension) {
                $this-&gt;writeMessage(
                    'Extension',
                    $extension,
                );
            }
        }

        if ($arguments['executionOrder'] === TestSuiteSorter::ORDER_RANDOMIZED) {
            $this-&gt;writeMessage(
                'Random Seed',
                (string) $arguments['randomOrderSeed'],
            );
        }

        if (isset($tooFewColumnsRequested)) {
            $warnings[] = 'Less than 16 columns requested, number of columns set to 16';
        }

        if ((new Runtime)-&gt;discardsComments()) {
            $warnings[] = 'opcache.save_comments=0 set; annotations will not work';
        }

        if (isset($arguments['conflictBetweenPrinterClassAndTestdox'])) {
            $warnings[] = 'Directives printerClass and testdox are mutually exclusive';
        }

        $warnings = array_merge($warnings, $suite-&gt;warnings());
        sort($warnings);

        foreach ($warnings as $warning) {
            $this-&gt;writeMessage('Warning', $warning);
        }

        if (isset($arguments['configurationObject'])) {
            assert($arguments['configurationObject'] instanceof Configuration);

            if ($arguments['configurationObject']-&gt;hasValidationErrors()) {
                if ((new SchemaDetector)-&gt;detect($arguments['configurationObject']-&gt;filename())-&gt;detected()) {
                    $this-&gt;writeMessage('Warning', 'Your XML configuration validates against a deprecated schema.');
                    $this-&gt;writeMessage('Suggestion', 'Migrate your XML configuration using &quot;--migrate-configuration&quot;!');
                } else {
                    $this-&gt;write(
                        &quot;\n  Warning - The configuration file did not pass validation!\n  The following problems have been detected:\n&quot;,
                    );

                    $this-&gt;write($arguments['configurationObject']-&gt;validationErrors());

                    $this-&gt;write(&quot;\n  Test results may not be as expected.\n\n&quot;);
                }
            }
        }

        if (isset($arguments['xdebugFilterFile'], $codeCoverageConfiguration)) {
            $this-&gt;write(PHP_EOL . 'Please note that --dump-xdebug-filter and --prepend are deprecated and will be removed in PHPUnit 10.' . PHP_EOL);

            $script = (new XdebugFilterScriptGenerator)-&gt;generate($codeCoverageConfiguration);

            if ($arguments['xdebugFilterFile'] !== 'php://stdout' &amp;&amp; $arguments['xdebugFilterFile'] !== 'php://stderr' &amp;&amp; !Filesystem::createDirectory(dirname($arguments['xdebugFilterFile']))) {
                $this-&gt;write(sprintf('Cannot write Xdebug filter script to %s ' . PHP_EOL, $arguments['xdebugFilterFile']));

                exit(self::EXCEPTION_EXIT);
            }

            file_put_contents($arguments['xdebugFilterFile'], $script);

            $this-&gt;write(sprintf('Wrote Xdebug filter script to %s ' . PHP_EOL . PHP_EOL, $arguments['xdebugFilterFile']));

            exit(self::SUCCESS_EXIT);
        }

        $this-&gt;write(&quot;\n&quot;);

        if (isset($codeCoverage)) {
            $result-&gt;setCodeCoverage($codeCoverage);
        }

        $result-&gt;beStrictAboutTestsThatDoNotTestAnything($arguments['reportUselessTests']);
        $result-&gt;beStrictAboutOutputDuringTests($arguments['disallowTestOutput']);
        $result-&gt;beStrictAboutTodoAnnotatedTests($arguments['disallowTodoAnnotatedTests']);
        $result-&gt;beStrictAboutResourceUsageDuringSmallTests($arguments['beStrictAboutResourceUsageDuringSmallTests']);

        if ($arguments['enforceTimeLimit'] === true &amp;&amp; !(new Invoker)-&gt;canInvokeWithTimeout()) {
            $this-&gt;writeMessage('Error', 'PHP extension pcntl is required for enforcing time limits');
        }

        $result-&gt;enforceTimeLimit($arguments['enforceTimeLimit']);
        $result-&gt;setDefaultTimeLimit($arguments['defaultTimeLimit']);
        $result-&gt;setTimeoutForSmallTests($arguments['timeoutForSmallTests']);
        $result-&gt;setTimeoutForMediumTests($arguments['timeoutForMediumTests']);
        $result-&gt;setTimeoutForLargeTests($arguments['timeoutForLargeTests']);

        if (isset($arguments['forceCoversAnnotation']) &amp;&amp; $arguments['forceCoversAnnotation'] === true) {
            $result-&gt;forceCoversAnnotation();
        }

        $this-&gt;processSuiteFilters($suite, $arguments);
        $suite-&gt;setRunTestInSeparateProcess($arguments['processIsolation']);

        foreach ($this-&gt;extensions as $extension) {
            if ($extension instanceof BeforeFirstTestHook) {
                $extension-&gt;executeBeforeFirstTest();
            }
        }

        $suite-&gt;run($result);

        foreach ($this-&gt;extensions as $extension) {
            if ($extension instanceof AfterLastTestHook) {
                $extension-&gt;executeAfterLastTest();
            }
        }

        $result-&gt;flushListeners();
        $this-&gt;printer-&gt;printResult($result);

        if (isset($codeCoverage)) {
            if (isset($arguments['coveragePHP'])) {
                $this-&gt;codeCoverageGenerationStart('PHP');

                try {
                    $writer = new PhpReport;
                    $writer-&gt;process($codeCoverage, $arguments['coveragePHP']);

                    $this-&gt;codeCoverageGenerationSucceeded();

                    unset($writer);
                } catch (CodeCoverageException $e) {
                    $this-&gt;codeCoverageGenerationFailed($e);
                }
            }

            if (isset($arguments['coverageClover'])) {
                $this-&gt;codeCoverageGenerationStart('Clover XML');

                try {
                    $writer = new CloverReport;
                    $writer-&gt;process($codeCoverage, $arguments['coverageClover']);

                    $this-&gt;codeCoverageGenerationSucceeded();

                    unset($writer);
                } catch (CodeCoverageException $e) {
                    $this-&gt;codeCoverageGenerationFailed($e);
                }
            }

            if (isset($arguments['coverageCobertura'])) {
                $this-&gt;codeCoverageGenerationStart('Cobertura XML');

                try {
                    $writer = new CoberturaReport;
                    $writer-&gt;process($codeCoverage, $arguments['coverageCobertura']);

                    $this-&gt;codeCoverageGenerationSucceeded();

                    unset($writer);
                } catch (CodeCoverageException $e) {
                    $this-&gt;codeCoverageGenerationFailed($e);
                }
            }

            if (isset($arguments['coverageCrap4J'])) {
                $this-&gt;codeCoverageGenerationStart('Crap4J XML');

                try {
                    $writer = new Crap4jReport($arguments['crap4jThreshold']);
                    $writer-&gt;process($codeCoverage, $arguments['coverageCrap4J']);

                    $this-&gt;codeCoverageGenerationSucceeded();

                    unset($writer);
                } catch (CodeCoverageException $e) {
                    $this-&gt;codeCoverageGenerationFailed($e);
                }
            }

            if (isset($arguments['coverageHtml'])) {
                $this-&gt;codeCoverageGenerationStart('HTML');

                try {
                    $writer = new HtmlReport(
                        $arguments['reportLowUpperBound'],
                        $arguments['reportHighLowerBound'],
                        sprintf(
                            ' and &lt;a href=&quot;https://phpunit.de/&quot;&gt;PHPUnit %s&lt;/a&gt;',
                            Version::id(),
                        ),
                    );

                    $writer-&gt;process($codeCoverage, $arguments['coverageHtml']);

                    $this-&gt;codeCoverageGenerationSucceeded();

                    unset($writer);
                } catch (CodeCoverageException $e) {
                    $this-&gt;codeCoverageGenerationFailed($e);
                }
            }

            if (isset($arguments['coverageText'])) {
                if ($arguments['coverageText'] === 'php://stdout') {
                    $outputStream = $this-&gt;printer;
                    $colors       = $arguments['colors'] &amp;&amp; $arguments['colors'] !== DefaultResultPrinter::COLOR_NEVER;
                } else {
                    $outputStream = new Printer($arguments['coverageText']);
                    $colors       = false;
                }

                $processor = new TextReport(
                    $arguments['reportLowUpperBound'],
                    $arguments['reportHighLowerBound'],
                    $arguments['coverageTextShowUncoveredFiles'],
                    $arguments['coverageTextShowOnlySummary'],
                );

                $outputStream-&gt;write(
                    $processor-&gt;process($codeCoverage, $colors),
                );
            }

            if (isset($arguments['coverageXml'])) {
                $this-&gt;codeCoverageGenerationStart('PHPUnit XML');

                try {
                    $writer = new XmlReport(Version::id());
                    $writer-&gt;process($codeCoverage, $arguments['coverageXml']);

                    $this-&gt;codeCoverageGenerationSucceeded();

                    unset($writer);
                } catch (CodeCoverageException $e) {
                    $this-&gt;codeCoverageGenerationFailed($e);
                }
            }
        }

        if ($exit) {
            if (isset($arguments['failOnEmptyTestSuite']) &amp;&amp; $arguments['failOnEmptyTestSuite'] === true &amp;&amp; count($result) === 0) {
                exit(self::FAILURE_EXIT);
            }

            if ($result-&gt;wasSuccessfulIgnoringWarnings()) {
                if ($arguments['failOnRisky'] &amp;&amp; !$result-&gt;allHarmless()) {
                    exit(self::FAILURE_EXIT);
                }

                if ($arguments['failOnWarning'] &amp;&amp; $result-&gt;warningCount() &gt; 0) {
                    exit(self::FAILURE_EXIT);
                }

                if ($arguments['failOnIncomplete'] &amp;&amp; $result-&gt;notImplementedCount() &gt; 0) {
                    exit(self::FAILURE_EXIT);
                }

                if ($arguments['failOnSkipped'] &amp;&amp; $result-&gt;skippedCount() &gt; 0) {
                    exit(self::FAILURE_EXIT);
                }

                exit(self::SUCCESS_EXIT);
            }

            if ($result-&gt;errorCount() &gt; 0) {
                exit(self::EXCEPTION_EXIT);
            }

            if ($result-&gt;failureCount() &gt; 0) {
                exit(self::FAILURE_EXIT);
            }
        }

        return $result;
    }

    /**
     * Returns the loader to be used.
     */
    public function getLoader(): TestSuiteLoader
    {
        if ($this-&gt;loader === null) {
            $this-&gt;loader = new StandardTestSuiteLoader;
        }

        return $this-&gt;loader;
    }

    public function addExtension(Hook $extension): void
    {
        $this-&gt;extensions[] = $extension;
    }

    /**
     * Override to define how to handle a failed loading of
     * a test suite.
     */
    protected function runFailed(string $message): void
    {
        $this-&gt;write($message . PHP_EOL);

        exit(self::FAILURE_EXIT);
    }

    private function createTestResult(): TestResult
    {
        return new TestResult;
    }

    private function write(string $buffer): void
    {
        if (PHP_SAPI !== 'cli' &amp;&amp; PHP_SAPI !== 'phpdbg') {
            $buffer = htmlspecialchars($buffer);
        }

        if ($this-&gt;printer !== null) {
            $this-&gt;printer-&gt;write($buffer);
        } else {
            print $buffer;
        }
    }

    /**
     * @throws Exception
     * @throws XmlConfiguration\Exception
     */
    private function handleConfiguration(array &amp;$arguments): void
    {
        if (!isset($arguments['configurationObject']) &amp;&amp; isset($arguments['configuration'])) {
            $arguments['configurationObject'] = (new Loader)-&gt;load($arguments['configuration']);
        }

        if (!isset($arguments['warnings'])) {
            $arguments['warnings'] = [];
        }

        $arguments['debug']     = $arguments['debug'] ?? false;
        $arguments['filter']    = $arguments['filter'] ?? false;
        $arguments['listeners'] = $arguments['listeners'] ?? [];

        if (isset($arguments['configurationObject'])) {
            (new PhpHandler)-&gt;handle($arguments['configurationObject']-&gt;php());

            $codeCoverageConfiguration = $arguments['configurationObject']-&gt;codeCoverage();

            if (!isset($arguments['noCoverage'])) {
                if (!isset($arguments['coverageClover']) &amp;&amp; $codeCoverageConfiguration-&gt;hasClover()) {
                    $arguments['coverageClover'] = $codeCoverageConfiguration-&gt;clover()-&gt;target()-&gt;path();
                }

                if (!isset($arguments['coverageCobertura']) &amp;&amp; $codeCoverageConfiguration-&gt;hasCobertura()) {
                    $arguments['coverageCobertura'] = $codeCoverageConfiguration-&gt;cobertura()-&gt;target()-&gt;path();
                }

                if (!isset($arguments['coverageCrap4J']) &amp;&amp; $codeCoverageConfiguration-&gt;hasCrap4j()) {
                    $arguments['coverageCrap4J'] = $codeCoverageConfiguration-&gt;crap4j()-&gt;target()-&gt;path();

                    if (!isset($arguments['crap4jThreshold'])) {
                        $arguments['crap4jThreshold'] = $codeCoverageConfiguration-&gt;crap4j()-&gt;threshold();
                    }
                }

                if (!isset($arguments['coverageHtml']) &amp;&amp; $codeCoverageConfiguration-&gt;hasHtml()) {
                    $arguments['coverageHtml'] = $codeCoverageConfiguration-&gt;html()-&gt;target()-&gt;path();

                    if (!isset($arguments['reportLowUpperBound'])) {
                        $arguments['reportLowUpperBound'] = $codeCoverageConfiguration-&gt;html()-&gt;lowUpperBound();
                    }

                    if (!isset($arguments['reportHighLowerBound'])) {
                        $arguments['reportHighLowerBound'] = $codeCoverageConfiguration-&gt;html()-&gt;highLowerBound();
                    }
                }

                if (!isset($arguments['coveragePHP']) &amp;&amp; $codeCoverageConfiguration-&gt;hasPhp()) {
                    $arguments['coveragePHP'] = $codeCoverageConfiguration-&gt;php()-&gt;target()-&gt;path();
                }

                if (!isset($arguments['coverageText']) &amp;&amp; $codeCoverageConfiguration-&gt;hasText()) {
                    $arguments['coverageText']                   = $codeCoverageConfiguration-&gt;text()-&gt;target()-&gt;path();
                    $arguments['coverageTextShowUncoveredFiles'] = $codeCoverageConfiguration-&gt;text()-&gt;showUncoveredFiles();
                    $arguments['coverageTextShowOnlySummary']    = $codeCoverageConfiguration-&gt;text()-&gt;showOnlySummary();
                }

                if (!isset($arguments['coverageXml']) &amp;&amp; $codeCoverageConfiguration-&gt;hasXml()) {
                    $arguments['coverageXml'] = $codeCoverageConfiguration-&gt;xml()-&gt;target()-&gt;path();
                }
            }

            $phpunitConfiguration = $arguments['configurationObject']-&gt;phpunit();

            $arguments['backupGlobals']                                   = $arguments['backupGlobals'] ?? $phpunitConfiguration-&gt;backupGlobals();
            $arguments['backupStaticAttributes']                          = $arguments['backupStaticAttributes'] ?? $phpunitConfiguration-&gt;backupStaticAttributes();
            $arguments['beStrictAboutChangesToGlobalState']               = $arguments['beStrictAboutChangesToGlobalState'] ?? $phpunitConfiguration-&gt;beStrictAboutChangesToGlobalState();
            $arguments['cacheResult']                                     = $arguments['cacheResult'] ?? $phpunitConfiguration-&gt;cacheResult();
            $arguments['colors']                                          = $arguments['colors'] ?? $phpunitConfiguration-&gt;colors();
            $arguments['convertDeprecationsToExceptions']                 = $arguments['convertDeprecationsToExceptions'] ?? $phpunitConfiguration-&gt;convertDeprecationsToExceptions();
            $arguments['convertErrorsToExceptions']                       = $arguments['convertErrorsToExceptions'] ?? $phpunitConfiguration-&gt;convertErrorsToExceptions();
            $arguments['convertNoticesToExceptions']                      = $arguments['convertNoticesToExceptions'] ?? $phpunitConfiguration-&gt;convertNoticesToExceptions();
            $arguments['convertWarningsToExceptions']                     = $arguments['convertWarningsToExceptions'] ?? $phpunitConfiguration-&gt;convertWarningsToExceptions();
            $arguments['processIsolation']                                = $arguments['processIsolation'] ?? $phpunitConfiguration-&gt;processIsolation();
            $arguments['stopOnDefect']                                    = $arguments['stopOnDefect'] ?? $phpunitConfiguration-&gt;stopOnDefect();
            $arguments['stopOnError']                                     = $arguments['stopOnError'] ?? $phpunitConfiguration-&gt;stopOnError();
            $arguments['stopOnFailure']                                   = $arguments['stopOnFailure'] ?? $phpunitConfiguration-&gt;stopOnFailure();
            $arguments['stopOnWarning']                                   = $arguments['stopOnWarning'] ?? $phpunitConfiguration-&gt;stopOnWarning();
            $arguments['stopOnIncomplete']                                = $arguments['stopOnIncomplete'] ?? $phpunitConfiguration-&gt;stopOnIncomplete();
            $arguments['stopOnRisky']                                     = $arguments['stopOnRisky'] ?? $phpunitConfiguration-&gt;stopOnRisky();
            $arguments['stopOnSkipped']                                   = $arguments['stopOnSkipped'] ?? $phpunitConfiguration-&gt;stopOnSkipped();
            $arguments['failOnEmptyTestSuite']                            = $arguments['failOnEmptyTestSuite'] ?? $phpunitConfiguration-&gt;failOnEmptyTestSuite();
            $arguments['failOnIncomplete']                                = $arguments['failOnIncomplete'] ?? $phpunitConfiguration-&gt;failOnIncomplete();
            $arguments['failOnRisky']                                     = $arguments['failOnRisky'] ?? $phpunitConfiguration-&gt;failOnRisky();
            $arguments['failOnSkipped']                                   = $arguments['failOnSkipped'] ?? $phpunitConfiguration-&gt;failOnSkipped();
            $arguments['failOnWarning']                                   = $arguments['failOnWarning'] ?? $phpunitConfiguration-&gt;failOnWarning();
            $arguments['enforceTimeLimit']                                = $arguments['enforceTimeLimit'] ?? $phpunitConfiguration-&gt;enforceTimeLimit();
            $arguments['defaultTimeLimit']                                = $arguments['defaultTimeLimit'] ?? $phpunitConfiguration-&gt;defaultTimeLimit();
            $arguments['timeoutForSmallTests']                            = $arguments['timeoutForSmallTests'] ?? $phpunitConfiguration-&gt;timeoutForSmallTests();
            $arguments['timeoutForMediumTests']                           = $arguments['timeoutForMediumTests'] ?? $phpunitConfiguration-&gt;timeoutForMediumTests();
            $arguments['timeoutForLargeTests']                            = $arguments['timeoutForLargeTests'] ?? $phpunitConfiguration-&gt;timeoutForLargeTests();
            $arguments['reportUselessTests']                              = $arguments['reportUselessTests'] ?? $phpunitConfiguration-&gt;beStrictAboutTestsThatDoNotTestAnything();
            $arguments['strictCoverage']                                  = $arguments['strictCoverage'] ?? $phpunitConfiguration-&gt;beStrictAboutCoversAnnotation();
            $arguments['ignoreDeprecatedCodeUnitsFromCodeCoverage']       = $arguments['ignoreDeprecatedCodeUnitsFromCodeCoverage'] ?? $codeCoverageConfiguration-&gt;ignoreDeprecatedCodeUnits();
            $arguments['disallowTestOutput']                              = $arguments['disallowTestOutput'] ?? $phpunitConfiguration-&gt;beStrictAboutOutputDuringTests();
            $arguments['disallowTodoAnnotatedTests']                      = $arguments['disallowTodoAnnotatedTests'] ?? $phpunitConfiguration-&gt;beStrictAboutTodoAnnotatedTests();
            $arguments['beStrictAboutResourceUsageDuringSmallTests']      = $arguments['beStrictAboutResourceUsageDuringSmallTests'] ?? $phpunitConfiguration-&gt;beStrictAboutResourceUsageDuringSmallTests();
            $arguments['verbose']                                         = $arguments['verbose'] ?? $phpunitConfiguration-&gt;verbose();
            $arguments['reverseDefectList']                               = $arguments['reverseDefectList'] ?? $phpunitConfiguration-&gt;reverseDefectList();
            $arguments['forceCoversAnnotation']                           = $arguments['forceCoversAnnotation'] ?? $phpunitConfiguration-&gt;forceCoversAnnotation();
            $arguments['disableCodeCoverageIgnore']                       = $arguments['disableCodeCoverageIgnore'] ?? $codeCoverageConfiguration-&gt;disableCodeCoverageIgnore();
            $arguments['registerMockObjectsFromTestArgumentsRecursively'] = $arguments['registerMockObjectsFromTestArgumentsRecursively'] ?? $phpunitConfiguration-&gt;registerMockObjectsFromTestArgumentsRecursively();
            $arguments['noInteraction']                                   = $arguments['noInteraction'] ?? $phpunitConfiguration-&gt;noInteraction();
            $arguments['executionOrder']                                  = $arguments['executionOrder'] ?? $phpunitConfiguration-&gt;executionOrder();
            $arguments['resolveDependencies']                             = $arguments['resolveDependencies'] ?? $phpunitConfiguration-&gt;resolveDependencies();

            if (!isset($arguments['bootstrap']) &amp;&amp; $phpunitConfiguration-&gt;hasBootstrap()) {
                $arguments['bootstrap'] = $phpunitConfiguration-&gt;bootstrap();
            }

            if (!isset($arguments['cacheResultFile']) &amp;&amp; $phpunitConfiguration-&gt;hasCacheResultFile()) {
                $arguments['cacheResultFile'] = $phpunitConfiguration-&gt;cacheResultFile();
            }

            if (!isset($arguments['executionOrderDefects'])) {
                $arguments['executionOrderDefects'] = $phpunitConfiguration-&gt;defectsFirst() ? TestSuiteSorter::ORDER_DEFECTS_FIRST : TestSuiteSorter::ORDER_DEFAULT;
            }

            if ($phpunitConfiguration-&gt;conflictBetweenPrinterClassAndTestdox()) {
                $arguments['conflictBetweenPrinterClassAndTestdox'] = true;
            }

            $groupCliArgs = [];

            if (!empty($arguments['groups'])) {
                $groupCliArgs = $arguments['groups'];
            }

            $groupConfiguration = $arguments['configurationObject']-&gt;groups();

            if (!isset($arguments['groups']) &amp;&amp; $groupConfiguration-&gt;hasInclude()) {
                $arguments['groups'] = $groupConfiguration-&gt;include()-&gt;asArrayOfStrings();
            }

            if (!isset($arguments['excludeGroups']) &amp;&amp; $groupConfiguration-&gt;hasExclude()) {
                $arguments['excludeGroups'] = array_diff($groupConfiguration-&gt;exclude()-&gt;asArrayOfStrings(), $groupCliArgs);
            }

            if (!isset($arguments['noExtensions'])) {
                $extensionHandler = new ExtensionHandler;

                foreach ($arguments['configurationObject']-&gt;extensions() as $extension) {
                    $extensionHandler-&gt;registerExtension($extension, $this);
                }

                foreach ($arguments['configurationObject']-&gt;listeners() as $listener) {
                    $arguments['listeners'][] = $extensionHandler-&gt;createTestListenerInstance($listener);
                }

                unset($extensionHandler);
            }

            foreach ($arguments['unavailableExtensions'] as $extension) {
                $arguments['warnings'][] = sprintf(
                    'Extension &quot;%s&quot; is not available',
                    $extension,
                );
            }

            $loggingConfiguration = $arguments['configurationObject']-&gt;logging();

            if (!isset($arguments['noLogging'])) {
                if ($loggingConfiguration-&gt;hasText()) {
                    $arguments['listeners'][] = new DefaultResultPrinter(
                        $loggingConfiguration-&gt;text()-&gt;target()-&gt;path(),
                        true,
                    );
                }

                if (!isset($arguments['teamcityLogfile']) &amp;&amp; $loggingConfiguration-&gt;hasTeamCity()) {
                    $arguments['teamcityLogfile'] = $loggingConfiguration-&gt;teamCity()-&gt;target()-&gt;path();
                }

                if (!isset($arguments['junitLogfile']) &amp;&amp; $loggingConfiguration-&gt;hasJunit()) {
                    $arguments['junitLogfile'] = $loggingConfiguration-&gt;junit()-&gt;target()-&gt;path();
                }

                if (!isset($arguments['testdoxHTMLFile']) &amp;&amp; $loggingConfiguration-&gt;hasTestDoxHtml()) {
                    $arguments['testdoxHTMLFile'] = $loggingConfiguration-&gt;testDoxHtml()-&gt;target()-&gt;path();
                }

                if (!isset($arguments['testdoxTextFile']) &amp;&amp; $loggingConfiguration-&gt;hasTestDoxText()) {
                    $arguments['testdoxTextFile'] = $loggingConfiguration-&gt;testDoxText()-&gt;target()-&gt;path();
                }

                if (!isset($arguments['testdoxXMLFile']) &amp;&amp; $loggingConfiguration-&gt;hasTestDoxXml()) {
                    $arguments['testdoxXMLFile'] = $loggingConfiguration-&gt;testDoxXml()-&gt;target()-&gt;path();
                }
            }

            $testdoxGroupConfiguration = $arguments['configurationObject']-&gt;testdoxGroups();

            if (!isset($arguments['testdoxGroups']) &amp;&amp; $testdoxGroupConfiguration-&gt;hasInclude()) {
                $arguments['testdoxGroups'] = $testdoxGroupConfiguration-&gt;include()-&gt;asArrayOfStrings();
            }

            if (!isset($arguments['testdoxExcludeGroups']) &amp;&amp; $testdoxGroupConfiguration-&gt;hasExclude()) {
                $arguments['testdoxExcludeGroups'] = $testdoxGroupConfiguration-&gt;exclude()-&gt;asArrayOfStrings();
            }
        }

        $extensionHandler = new ExtensionHandler;

        foreach ($arguments['extensions'] as $extension) {
            $extensionHandler-&gt;registerExtension($extension, $this);
        }

        unset($extensionHandler);

        $arguments['backupGlobals']                                   = $arguments['backupGlobals'] ?? null;
        $arguments['backupStaticAttributes']                          = $arguments['backupStaticAttributes'] ?? null;
        $arguments['beStrictAboutChangesToGlobalState']               = $arguments['beStrictAboutChangesToGlobalState'] ?? null;
        $arguments['beStrictAboutResourceUsageDuringSmallTests']      = $arguments['beStrictAboutResourceUsageDuringSmallTests'] ?? false;
        $arguments['cacheResult']                                     = $arguments['cacheResult'] ?? true;
        $arguments['colors']                                          = $arguments['colors'] ?? DefaultResultPrinter::COLOR_DEFAULT;
        $arguments['columns']                                         = $arguments['columns'] ?? 80;
        $arguments['convertDeprecationsToExceptions']                 = $arguments['convertDeprecationsToExceptions'] ?? false;
        $arguments['convertErrorsToExceptions']                       = $arguments['convertErrorsToExceptions'] ?? true;
        $arguments['convertNoticesToExceptions']                      = $arguments['convertNoticesToExceptions'] ?? true;
        $arguments['convertWarningsToExceptions']                     = $arguments['convertWarningsToExceptions'] ?? true;
        $arguments['crap4jThreshold']                                 = $arguments['crap4jThreshold'] ?? 30;
        $arguments['disallowTestOutput']                              = $arguments['disallowTestOutput'] ?? false;
        $arguments['disallowTodoAnnotatedTests']                      = $arguments['disallowTodoAnnotatedTests'] ?? false;
        $arguments['defaultTimeLimit']                                = $arguments['defaultTimeLimit'] ?? 0;
        $arguments['enforceTimeLimit']                                = $arguments['enforceTimeLimit'] ?? false;
        $arguments['excludeGroups']                                   = $arguments['excludeGroups'] ?? [];
        $arguments['executionOrder']                                  = $arguments['executionOrder'] ?? TestSuiteSorter::ORDER_DEFAULT;
        $arguments['executionOrderDefects']                           = $arguments['executionOrderDefects'] ?? TestSuiteSorter::ORDER_DEFAULT;
        $arguments['failOnIncomplete']                                = $arguments['failOnIncomplete'] ?? false;
        $arguments['failOnRisky']                                     = $arguments['failOnRisky'] ?? false;
        $arguments['failOnSkipped']                                   = $arguments['failOnSkipped'] ?? false;
        $arguments['failOnWarning']                                   = $arguments['failOnWarning'] ?? false;
        $arguments['groups']                                          = $arguments['groups'] ?? [];
        $arguments['noInteraction']                                   = $arguments['noInteraction'] ?? false;
        $arguments['processIsolation']                                = $arguments['processIsolation'] ?? false;
        $arguments['randomOrderSeed']                                 = $arguments['randomOrderSeed'] ?? time();
        $arguments['registerMockObjectsFromTestArgumentsRecursively'] = $arguments['registerMockObjectsFromTestArgumentsRecursively'] ?? false;
        $arguments['repeat']                                          = $arguments['repeat'] ?? false;
        $arguments['reportHighLowerBound']                            = $arguments['reportHighLowerBound'] ?? 90;
        $arguments['reportLowUpperBound']                             = $arguments['reportLowUpperBound'] ?? 50;
        $arguments['reportUselessTests']                              = $arguments['reportUselessTests'] ?? true;
        $arguments['reverseList']                                     = $arguments['reverseList'] ?? false;
        $arguments['resolveDependencies']                             = $arguments['resolveDependencies'] ?? true;
        $arguments['stopOnError']                                     = $arguments['stopOnError'] ?? false;
        $arguments['stopOnFailure']                                   = $arguments['stopOnFailure'] ?? false;
        $arguments['stopOnIncomplete']                                = $arguments['stopOnIncomplete'] ?? false;
        $arguments['stopOnRisky']                                     = $arguments['stopOnRisky'] ?? false;
        $arguments['stopOnSkipped']                                   = $arguments['stopOnSkipped'] ?? false;
        $arguments['stopOnWarning']                                   = $arguments['stopOnWarning'] ?? false;
        $arguments['stopOnDefect']                                    = $arguments['stopOnDefect'] ?? false;
        $arguments['strictCoverage']                                  = $arguments['strictCoverage'] ?? false;
        $arguments['testdoxExcludeGroups']                            = $arguments['testdoxExcludeGroups'] ?? [];
        $arguments['testdoxGroups']                                   = $arguments['testdoxGroups'] ?? [];
        $arguments['timeoutForLargeTests']                            = $arguments['timeoutForLargeTests'] ?? 60;
        $arguments['timeoutForMediumTests']                           = $arguments['timeoutForMediumTests'] ?? 10;
        $arguments['timeoutForSmallTests']                            = $arguments['timeoutForSmallTests'] ?? 1;
        $arguments['verbose']                                         = $arguments['verbose'] ?? false;

        if ($arguments['reportLowUpperBound'] &gt; $arguments['reportHighLowerBound']) {
            $arguments['reportLowUpperBound']  = 50;
            $arguments['reportHighLowerBound'] = 90;
        }
    }

    private function processSuiteFilters(TestSuite $suite, array $arguments): void
    {
        if (!$arguments['filter'] &amp;&amp;
            empty($arguments['groups']) &amp;&amp;
            empty($arguments['excludeGroups']) &amp;&amp;
            empty($arguments['testsCovering']) &amp;&amp;
            empty($arguments['testsUsing'])) {
            return;
        }

        $filterFactory = new Factory;

        if (!empty($arguments['excludeGroups'])) {
            $filterFactory-&gt;addFilter(
                new ReflectionClass(ExcludeGroupFilterIterator::class),
                $arguments['excludeGroups'],
            );
        }

        if (!empty($arguments['groups'])) {
            $filterFactory-&gt;addFilter(
                new ReflectionClass(IncludeGroupFilterIterator::class),
                $arguments['groups'],
            );
        }

        if (!empty($arguments['testsCovering'])) {
            $filterFactory-&gt;addFilter(
                new ReflectionClass(IncludeGroupFilterIterator::class),
                array_map(
                    static function (string $name): string
                    {
                        return '__phpunit_covers_' . $name;
                    },
                    $arguments['testsCovering'],
                ),
            );
        }

        if (!empty($arguments['testsUsing'])) {
            $filterFactory-&gt;addFilter(
                new ReflectionClass(IncludeGroupFilterIterator::class),
                array_map(
                    static function (string $name): string
                    {
                        return '__phpunit_uses_' . $name;
                    },
                    $arguments['testsUsing'],
                ),
            );
        }

        if ($arguments['filter']) {
            $filterFactory-&gt;addFilter(
                new ReflectionClass(NameFilterIterator::class),
                $arguments['filter'],
            );
        }

        $suite-&gt;injectFilter($filterFactory);
    }

    private function writeMessage(string $type, string $message): void
    {
        if (!$this-&gt;messagePrinted) {
            $this-&gt;write(&quot;\n&quot;);
        }

        $this-&gt;write(
            sprintf(
                &quot;%-15s%s\n&quot;,
                $type . ':',
                $message,
            ),
        );

        $this-&gt;messagePrinted = true;
    }

    private function createPrinter(string $class, array $arguments): ResultPrinter
    {
        $object = new $class(
            (isset($arguments['stderr']) &amp;&amp; $arguments['stderr'] === true) ? 'php://stderr' : null,
            $arguments['verbose'],
            $arguments['colors'],
            $arguments['debug'],
            $arguments['columns'],
            $arguments['reverseList'],
        );

        assert($object instanceof ResultPrinter);

        return $object;
    }

    private function codeCoverageGenerationStart(string $format): void
    {
        $this-&gt;write(
            sprintf(
                &quot;\nGenerating code coverage report in %s format ... &quot;,
                $format,
            ),
        );

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

    private function codeCoverageGenerationSucceeded(): void
    {
        $this-&gt;write(
            sprintf(
                &quot;done [%s]\n&quot;,
                $this-&gt;timer-&gt;stop()-&gt;asString(),
            ),
        );
    }

    private function codeCoverageGenerationFailed(\Exception $e): void
    {
        $this-&gt;write(
            sprintf(
                &quot;failed [%s]\n%s\n&quot;,
                $this-&gt;timer-&gt;stop()-&gt;asString(),
                $e-&gt;getMessage(),
            ),
        );
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>