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

use const PHP_EOL;
use function class_exists;
use function count;
use function extension_loaded;
use function function_exists;
use function get_class;
use function sprintf;
use function xdebug_get_monitored_functions;
use function xdebug_is_debugger_active;
use function xdebug_start_function_monitor;
use function xdebug_stop_function_monitor;
use AssertionError;
use Countable;
use Error;
use PHPUnit\Util\ErrorHandler;
use PHPUnit\Util\ExcludeList;
use PHPUnit\Util\Printer;
use PHPUnit\Util\Test as TestUtil;
use ReflectionClass;
use ReflectionException;
use SebastianBergmann\CodeCoverage\CodeCoverage;
use SebastianBergmann\CodeCoverage\Exception as OriginalCodeCoverageException;
use SebastianBergmann\CodeCoverage\UnintentionallyCoveredCodeException;
use SebastianBergmann\Invoker\Invoker;
use SebastianBergmann\Invoker\TimeoutException;
use SebastianBergmann\RecursionContext\InvalidArgumentException;
use SebastianBergmann\ResourceOperations\ResourceOperations;
use SebastianBergmann\Timer\Timer;
use Throwable;

/**
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
 */
final class TestResult implements Countable
{
    /**
     * @var array
     */
    private $passed = [];

    /**
     * @var array&lt;string&gt;
     */
    private $passedTestClasses = [];

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

    /**
     * @var TestFailure[]
     */
    private $errors = [];

    /**
     * @var TestFailure[]
     */
    private $failures = [];

    /**
     * @var TestFailure[]
     */
    private $warnings = [];

    /**
     * @var TestFailure[]
     */
    private $notImplemented = [];

    /**
     * @var TestFailure[]
     */
    private $risky = [];

    /**
     * @var TestFailure[]
     */
    private $skipped = [];

    /**
     * @deprecated Use the `TestHook` interfaces instead
     *
     * @var TestListener[]
     */
    private $listeners = [];

    /**
     * @var int
     */
    private $runTests = 0;

    /**
     * @var float
     */
    private $time = 0;

    /**
     * Code Coverage information.
     *
     * @var CodeCoverage
     */
    private $codeCoverage;

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

    /**
     * @var bool
     */
    private $convertErrorsToExceptions = true;

    /**
     * @var bool
     */
    private $convertNoticesToExceptions = true;

    /**
     * @var bool
     */
    private $convertWarningsToExceptions = true;

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

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

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

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

    /**
     * @var bool
     */
    private $beStrictAboutTestsThatDoNotTestAnything = true;

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

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

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

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

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

    /**
     * @var int
     */
    private $timeoutForSmallTests = 1;

    /**
     * @var int
     */
    private $timeoutForMediumTests = 10;

    /**
     * @var int
     */
    private $timeoutForLargeTests = 60;

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

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

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

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

    /**
     * @var int
     */
    private $defaultTimeLimit = 0;

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

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

    /**
     * @deprecated Use the `TestHook` interfaces instead
     *
     * @codeCoverageIgnore
     *
     * Registers a TestListener.
     */
    public function addListener(TestListener $listener): void
    {
        $this-&gt;listeners[] = $listener;
    }

    /**
     * @deprecated Use the `TestHook` interfaces instead
     *
     * @codeCoverageIgnore
     *
     * Unregisters a TestListener.
     */
    public function removeListener(TestListener $listener): void
    {
        foreach ($this-&gt;listeners as $key =&gt; $_listener) {
            if ($listener === $_listener) {
                unset($this-&gt;listeners[$key]);
            }
        }
    }

    /**
     * @deprecated Use the `TestHook` interfaces instead
     *
     * @codeCoverageIgnore
     *
     * Flushes all flushable TestListeners.
     */
    public function flushListeners(): void
    {
        foreach ($this-&gt;listeners as $listener) {
            if ($listener instanceof Printer) {
                $listener-&gt;flush();
            }
        }
    }

    /**
     * Adds an error to the list of errors.
     */
    public function addError(Test $test, Throwable $t, float $time): void
    {
        if ($t instanceof RiskyTestError) {
            $this-&gt;recordRisky($test, $t);

            $notifyMethod = 'addRiskyTest';

            if ($test instanceof TestCase) {
                $test-&gt;markAsRisky();
            }

            if ($this-&gt;stopOnRisky || $this-&gt;stopOnDefect) {
                $this-&gt;stop();
            }
        } elseif ($t instanceof IncompleteTest) {
            $this-&gt;recordNotImplemented($test, $t);

            $notifyMethod = 'addIncompleteTest';

            if ($this-&gt;stopOnIncomplete) {
                $this-&gt;stop();
            }
        } elseif ($t instanceof SkippedTest) {
            $this-&gt;recordSkipped($test, $t);

            $notifyMethod = 'addSkippedTest';

            if ($this-&gt;stopOnSkipped) {
                $this-&gt;stop();
            }
        } else {
            $this-&gt;recordError($test, $t);

            $notifyMethod = 'addError';

            if ($this-&gt;stopOnError || $this-&gt;stopOnFailure) {
                $this-&gt;stop();
            }
        }

        // @see https://github.com/sebastianbergmann/phpunit/issues/1953
        if ($t instanceof Error) {
            $t = new ExceptionWrapper($t);
        }

        foreach ($this-&gt;listeners as $listener) {
            $listener-&gt;{$notifyMethod}($test, $t, $time);
        }

        $this-&gt;lastTestFailed = true;
        $this-&gt;time += $time;
    }

    /**
     * Adds a warning to the list of warnings.
     * The passed in exception caused the warning.
     */
    public function addWarning(Test $test, Warning $e, float $time): void
    {
        if ($this-&gt;stopOnWarning || $this-&gt;stopOnDefect) {
            $this-&gt;stop();
        }

        $this-&gt;recordWarning($test, $e);

        foreach ($this-&gt;listeners as $listener) {
            $listener-&gt;addWarning($test, $e, $time);
        }

        $this-&gt;time += $time;
    }

    /**
     * Adds a failure to the list of failures.
     * The passed in exception caused the failure.
     */
    public function addFailure(Test $test, AssertionFailedError $e, float $time): void
    {
        if ($e instanceof RiskyTestError || $e instanceof OutputError) {
            $this-&gt;recordRisky($test, $e);

            $notifyMethod = 'addRiskyTest';

            if ($test instanceof TestCase) {
                $test-&gt;markAsRisky();
            }

            if ($this-&gt;stopOnRisky || $this-&gt;stopOnDefect) {
                $this-&gt;stop();
            }
        } elseif ($e instanceof IncompleteTest) {
            $this-&gt;recordNotImplemented($test, $e);

            $notifyMethod = 'addIncompleteTest';

            if ($this-&gt;stopOnIncomplete) {
                $this-&gt;stop();
            }
        } elseif ($e instanceof SkippedTest) {
            $this-&gt;recordSkipped($test, $e);

            $notifyMethod = 'addSkippedTest';

            if ($this-&gt;stopOnSkipped) {
                $this-&gt;stop();
            }
        } else {
            $this-&gt;failures[] = new TestFailure($test, $e);
            $notifyMethod     = 'addFailure';

            if ($this-&gt;stopOnFailure || $this-&gt;stopOnDefect) {
                $this-&gt;stop();
            }
        }

        foreach ($this-&gt;listeners as $listener) {
            $listener-&gt;{$notifyMethod}($test, $e, $time);
        }

        $this-&gt;lastTestFailed = true;
        $this-&gt;time += $time;
    }

    /**
     * Informs the result that a test suite will be started.
     */
    public function startTestSuite(TestSuite $suite): void
    {
        $this-&gt;currentTestSuiteFailed = false;

        foreach ($this-&gt;listeners as $listener) {
            $listener-&gt;startTestSuite($suite);
        }
    }

    /**
     * Informs the result that a test suite was completed.
     */
    public function endTestSuite(TestSuite $suite): void
    {
        if (!$this-&gt;currentTestSuiteFailed) {
            $this-&gt;passedTestClasses[] = $suite-&gt;getName();
        }

        foreach ($this-&gt;listeners as $listener) {
            $listener-&gt;endTestSuite($suite);
        }
    }

    /**
     * Informs the result that a test will be started.
     */
    public function startTest(Test $test): void
    {
        $this-&gt;lastTestFailed = false;
        $this-&gt;runTests += count($test);

        foreach ($this-&gt;listeners as $listener) {
            $listener-&gt;startTest($test);
        }
    }

    /**
     * Informs the result that a test was completed.
     *
     * @throws InvalidArgumentException
     */
    public function endTest(Test $test, float $time): void
    {
        foreach ($this-&gt;listeners as $listener) {
            $listener-&gt;endTest($test, $time);
        }

        if (!$this-&gt;lastTestFailed &amp;&amp; $test instanceof TestCase) {
            $class = get_class($test);
            $key   = $class . '::' . $test-&gt;getName();

            $this-&gt;passed[$key] = [
                'result' =&gt; $test-&gt;getResult(),
                'size'   =&gt; TestUtil::getSize(
                    $class,
                    $test-&gt;getName(false),
                ),
            ];

            $this-&gt;time += $time;
        }

        if ($this-&gt;lastTestFailed &amp;&amp; $test instanceof TestCase) {
            $this-&gt;currentTestSuiteFailed = true;
        }
    }

    /**
     * Returns true if no risky test occurred.
     */
    public function allHarmless(): bool
    {
        return $this-&gt;riskyCount() === 0;
    }

    /**
     * Gets the number of risky tests.
     */
    public function riskyCount(): int
    {
        return count($this-&gt;risky);
    }

    /**
     * Returns true if no incomplete test occurred.
     */
    public function allCompletelyImplemented(): bool
    {
        return $this-&gt;notImplementedCount() === 0;
    }

    /**
     * Gets the number of incomplete tests.
     */
    public function notImplementedCount(): int
    {
        return count($this-&gt;notImplemented);
    }

    /**
     * Returns an array of TestFailure objects for the risky tests.
     *
     * @return TestFailure[]
     */
    public function risky(): array
    {
        return $this-&gt;risky;
    }

    /**
     * Returns an array of TestFailure objects for the incomplete tests.
     *
     * @return TestFailure[]
     */
    public function notImplemented(): array
    {
        return $this-&gt;notImplemented;
    }

    /**
     * Returns true if no test has been skipped.
     */
    public function noneSkipped(): bool
    {
        return $this-&gt;skippedCount() === 0;
    }

    /**
     * Gets the number of skipped tests.
     */
    public function skippedCount(): int
    {
        return count($this-&gt;skipped);
    }

    /**
     * Returns an array of TestFailure objects for the skipped tests.
     *
     * @return TestFailure[]
     */
    public function skipped(): array
    {
        return $this-&gt;skipped;
    }

    /**
     * Gets the number of detected errors.
     */
    public function errorCount(): int
    {
        return count($this-&gt;errors);
    }

    /**
     * Returns an array of TestFailure objects for the errors.
     *
     * @return TestFailure[]
     */
    public function errors(): array
    {
        return $this-&gt;errors;
    }

    /**
     * Gets the number of detected failures.
     */
    public function failureCount(): int
    {
        return count($this-&gt;failures);
    }

    /**
     * Returns an array of TestFailure objects for the failures.
     *
     * @return TestFailure[]
     */
    public function failures(): array
    {
        return $this-&gt;failures;
    }

    /**
     * Gets the number of detected warnings.
     */
    public function warningCount(): int
    {
        return count($this-&gt;warnings);
    }

    /**
     * Returns an array of TestFailure objects for the warnings.
     *
     * @return TestFailure[]
     */
    public function warnings(): array
    {
        return $this-&gt;warnings;
    }

    /**
     * Returns the names of the tests that have passed.
     */
    public function passed(): array
    {
        return $this-&gt;passed;
    }

    /**
     * Returns the names of the TestSuites that have passed.
     *
     * This enables @depends-annotations for TestClassName::class
     */
    public function passedClasses(): array
    {
        return $this-&gt;passedTestClasses;
    }

    /**
     * Returns whether code coverage information should be collected.
     */
    public function getCollectCodeCoverageInformation(): bool
    {
        return $this-&gt;codeCoverage !== null;
    }

    /**
     * Runs a TestCase.
     *
     * @throws \SebastianBergmann\CodeCoverage\InvalidArgumentException
     * @throws CodeCoverageException
     * @throws InvalidArgumentException
     * @throws UnintentionallyCoveredCodeException
     */
    public function run(Test $test): void
    {
        Assert::resetCount();

        $size = TestUtil::UNKNOWN;

        if ($test instanceof TestCase) {
            $test-&gt;setRegisterMockObjectsFromTestArgumentsRecursively(
                $this-&gt;registerMockObjectsFromTestArgumentsRecursively,
            );

            $isAnyCoverageRequired = TestUtil::requiresCodeCoverageDataCollection($test);
            $size                  = $test-&gt;getSize();
        }

        $error      = false;
        $failure    = false;
        $warning    = false;
        $incomplete = false;
        $risky      = false;
        $skipped    = false;

        $this-&gt;startTest($test);

        if ($this-&gt;convertDeprecationsToExceptions || $this-&gt;convertErrorsToExceptions || $this-&gt;convertNoticesToExceptions || $this-&gt;convertWarningsToExceptions) {
            $errorHandler = new ErrorHandler(
                $this-&gt;convertDeprecationsToExceptions,
                $this-&gt;convertErrorsToExceptions,
                $this-&gt;convertNoticesToExceptions,
                $this-&gt;convertWarningsToExceptions,
            );

            $errorHandler-&gt;register();
        }

        $collectCodeCoverage = $this-&gt;codeCoverage !== null &amp;&amp;
                               !$test instanceof ErrorTestCase &amp;&amp;
                               !$test instanceof WarningTestCase &amp;&amp;
                               $isAnyCoverageRequired;

        if ($collectCodeCoverage) {
            $this-&gt;codeCoverage-&gt;start($test);
        }

        $monitorFunctions = $this-&gt;beStrictAboutResourceUsageDuringSmallTests &amp;&amp;
                            !$test instanceof ErrorTestCase &amp;&amp;
                            !$test instanceof WarningTestCase &amp;&amp;
                            $size === TestUtil::SMALL &amp;&amp;
                            function_exists('xdebug_start_function_monitor');

        if ($monitorFunctions) {
            /* @noinspection ForgottenDebugOutputInspection */
            xdebug_start_function_monitor(ResourceOperations::getFunctions());
        }

        $timer = new Timer;
        $timer-&gt;start();

        try {
            $invoker = new Invoker;

            if (!$test instanceof ErrorTestCase &amp;&amp;
                !$test instanceof WarningTestCase &amp;&amp;
                $this-&gt;shouldTimeLimitBeEnforced($size) &amp;&amp;
                $invoker-&gt;canInvokeWithTimeout()) {
                switch ($size) {
                    case TestUtil::SMALL:
                        $_timeout = $this-&gt;timeoutForSmallTests;

                        break;

                    case TestUtil::MEDIUM:
                        $_timeout = $this-&gt;timeoutForMediumTests;

                        break;

                    case TestUtil::LARGE:
                        $_timeout = $this-&gt;timeoutForLargeTests;

                        break;

                    default:
                        $_timeout = $this-&gt;defaultTimeLimit;
                }

                $invoker-&gt;invoke([$test, 'runBare'], [], $_timeout);
            } else {
                $test-&gt;runBare();
            }
        } catch (TimeoutException $e) {
            $this-&gt;addFailure(
                $test,
                new RiskyTestError(
                    $e-&gt;getMessage(),
                ),
                $_timeout,
            );

            $risky = true;
        } catch (AssertionFailedError $e) {
            $failure = true;

            if ($e instanceof RiskyTestError) {
                $risky = true;
            } elseif ($e instanceof IncompleteTestError) {
                $incomplete = true;
            } elseif ($e instanceof SkippedTestError) {
                $skipped = true;
            }
        } catch (AssertionError $e) {
            $test-&gt;addToAssertionCount(1);

            $failure = true;
            $frame   = $e-&gt;getTrace()[0];

            $e = new AssertionFailedError(
                sprintf(
                    '%s in %s:%s',
                    $e-&gt;getMessage(),
                    $frame['file'] ?? $e-&gt;getFile(),
                    $frame['line'] ?? $e-&gt;getLine(),
                ),
                0,
                $e,
            );
        } catch (Warning $e) {
            $warning = true;
        } catch (Exception $e) {
            $error = true;
        } catch (Throwable $e) {
            $e     = new ExceptionWrapper($e);
            $error = true;
        }

        $time = $timer-&gt;stop()-&gt;asSeconds();

        $test-&gt;addToAssertionCount(Assert::getCount());

        if ($monitorFunctions) {
            $excludeList = new ExcludeList;

            /** @noinspection ForgottenDebugOutputInspection */
            $functions = xdebug_get_monitored_functions();

            /* @noinspection ForgottenDebugOutputInspection */
            xdebug_stop_function_monitor();

            foreach ($functions as $function) {
                if (!$excludeList-&gt;isExcluded($function['filename'])) {
                    $this-&gt;addFailure(
                        $test,
                        new RiskyTestError(
                            sprintf(
                                '%s() used in %s:%s',
                                $function['function'],
                                $function['filename'],
                                $function['lineno'],
                            ),
                        ),
                        $time,
                    );
                }
            }
        }

        if ($this-&gt;beStrictAboutTestsThatDoNotTestAnything &amp;&amp;
            !$test-&gt;doesNotPerformAssertions() &amp;&amp;
            $test-&gt;getNumAssertions() === 0) {
            $risky = true;
        }

        if ($this-&gt;forceCoversAnnotation &amp;&amp; !$error &amp;&amp; !$failure &amp;&amp; !$warning &amp;&amp; !$incomplete &amp;&amp; !$skipped &amp;&amp; !$risky) {
            $annotations = TestUtil::parseTestMethodAnnotations(
                get_class($test),
                $test-&gt;getName(false),
            );

            if (!isset($annotations['class']['covers']) &amp;&amp;
                !isset($annotations['method']['covers']) &amp;&amp;
                !isset($annotations['class']['coversNothing']) &amp;&amp;
                !isset($annotations['method']['coversNothing'])) {
                $this-&gt;addFailure(
                    $test,
                    new MissingCoversAnnotationException(
                        'This test does not have a @covers annotation but is expected to have one',
                    ),
                    $time,
                );

                $risky = true;
            }
        }

        if ($collectCodeCoverage) {
            $append           = !$risky &amp;&amp; !$incomplete &amp;&amp; !$skipped;
            $linesToBeCovered = [];
            $linesToBeUsed    = [];

            if ($append &amp;&amp; $test instanceof TestCase) {
                try {
                    $linesToBeCovered = TestUtil::getLinesToBeCovered(
                        get_class($test),
                        $test-&gt;getName(false),
                    );

                    $linesToBeUsed = TestUtil::getLinesToBeUsed(
                        get_class($test),
                        $test-&gt;getName(false),
                    );
                } catch (InvalidCoversTargetException $cce) {
                    $this-&gt;addWarning(
                        $test,
                        new Warning(
                            $cce-&gt;getMessage(),
                        ),
                        $time,
                    );
                }
            }

            try {
                $this-&gt;codeCoverage-&gt;stop(
                    $append,
                    $linesToBeCovered,
                    $linesToBeUsed,
                );
            } catch (UnintentionallyCoveredCodeException $cce) {
                $unintentionallyCoveredCodeError = new UnintentionallyCoveredCodeError(
                    'This test executed code that is not listed as code to be covered or used:' .
                    PHP_EOL . $cce-&gt;getMessage(),
                );
            } catch (OriginalCodeCoverageException $cce) {
                $error = true;

                $e = $e ?? $cce;
            }
        }

        if (isset($errorHandler)) {
            $errorHandler-&gt;unregister();

            unset($errorHandler);
        }

        if ($error) {
            $this-&gt;addError($test, $e, $time);
        } elseif ($failure) {
            $this-&gt;addFailure($test, $e, $time);
        } elseif ($warning) {
            $this-&gt;addWarning($test, $e, $time);
        } elseif (isset($unintentionallyCoveredCodeError)) {
            $this-&gt;addFailure(
                $test,
                $unintentionallyCoveredCodeError,
                $time,
            );
        } elseif ($this-&gt;beStrictAboutTestsThatDoNotTestAnything &amp;&amp;
            !$test-&gt;doesNotPerformAssertions() &amp;&amp;
            $test-&gt;getNumAssertions() === 0) {
            try {
                $reflected = new ReflectionClass($test);
                // @codeCoverageIgnoreStart
            } catch (ReflectionException $e) {
                throw new Exception(
                    $e-&gt;getMessage(),
                    $e-&gt;getCode(),
                    $e,
                );
            }
            // @codeCoverageIgnoreEnd

            $name = $test-&gt;getName(false);

            if ($name &amp;&amp; $reflected-&gt;hasMethod($name)) {
                try {
                    $reflected = $reflected-&gt;getMethod($name);
                    // @codeCoverageIgnoreStart
                } catch (ReflectionException $e) {
                    throw new Exception(
                        $e-&gt;getMessage(),
                        $e-&gt;getCode(),
                        $e,
                    );
                }
                // @codeCoverageIgnoreEnd
            }

            $this-&gt;addFailure(
                $test,
                new RiskyTestError(
                    sprintf(
                        &quot;This test did not perform any assertions\n\n%s:%d&quot;,
                        $reflected-&gt;getFileName(),
                        $reflected-&gt;getStartLine(),
                    ),
                ),
                $time,
            );
        } elseif ($this-&gt;beStrictAboutTestsThatDoNotTestAnything &amp;&amp;
            $test-&gt;doesNotPerformAssertions() &amp;&amp;
            $test-&gt;getNumAssertions() &gt; 0) {
            $this-&gt;addFailure(
                $test,
                new RiskyTestError(
                    sprintf(
                        'This test is annotated with &quot;@doesNotPerformAssertions&quot; but performed %d assertions',
                        $test-&gt;getNumAssertions(),
                    ),
                ),
                $time,
            );
        } elseif ($this-&gt;beStrictAboutOutputDuringTests &amp;&amp; $test-&gt;hasOutput()) {
            $this-&gt;addFailure(
                $test,
                new OutputError(
                    sprintf(
                        'This test printed output: %s',
                        $test-&gt;getActualOutput(),
                    ),
                ),
                $time,
            );
        } elseif ($this-&gt;beStrictAboutTodoAnnotatedTests &amp;&amp; $test instanceof TestCase) {
            $annotations = TestUtil::parseTestMethodAnnotations(
                get_class($test),
                $test-&gt;getName(false),
            );

            if (isset($annotations['method']['todo'])) {
                $this-&gt;addFailure(
                    $test,
                    new RiskyTestError(
                        'Test method is annotated with @todo',
                    ),
                    $time,
                );
            }
        }

        $this-&gt;endTest($test, $time);
    }

    /**
     * Gets the number of run tests.
     */
    public function count(): int
    {
        return $this-&gt;runTests;
    }

    /**
     * Checks whether the test run should stop.
     */
    public function shouldStop(): bool
    {
        return $this-&gt;stop;
    }

    /**
     * Marks that the test run should stop.
     */
    public function stop(): void
    {
        $this-&gt;stop = true;
    }

    /**
     * Returns the code coverage object.
     */
    public function getCodeCoverage(): ?CodeCoverage
    {
        return $this-&gt;codeCoverage;
    }

    /**
     * Sets the code coverage object.
     */
    public function setCodeCoverage(CodeCoverage $codeCoverage): void
    {
        $this-&gt;codeCoverage = $codeCoverage;
    }

    /**
     * Enables or disables the deprecation-to-exception conversion.
     */
    public function convertDeprecationsToExceptions(bool $flag): void
    {
        $this-&gt;convertDeprecationsToExceptions = $flag;
    }

    /**
     * Returns the deprecation-to-exception conversion setting.
     */
    public function getConvertDeprecationsToExceptions(): bool
    {
        return $this-&gt;convertDeprecationsToExceptions;
    }

    /**
     * Enables or disables the error-to-exception conversion.
     */
    public function convertErrorsToExceptions(bool $flag): void
    {
        $this-&gt;convertErrorsToExceptions = $flag;
    }

    /**
     * Returns the error-to-exception conversion setting.
     */
    public function getConvertErrorsToExceptions(): bool
    {
        return $this-&gt;convertErrorsToExceptions;
    }

    /**
     * Enables or disables the notice-to-exception conversion.
     */
    public function convertNoticesToExceptions(bool $flag): void
    {
        $this-&gt;convertNoticesToExceptions = $flag;
    }

    /**
     * Returns the notice-to-exception conversion setting.
     */
    public function getConvertNoticesToExceptions(): bool
    {
        return $this-&gt;convertNoticesToExceptions;
    }

    /**
     * Enables or disables the warning-to-exception conversion.
     */
    public function convertWarningsToExceptions(bool $flag): void
    {
        $this-&gt;convertWarningsToExceptions = $flag;
    }

    /**
     * Returns the warning-to-exception conversion setting.
     */
    public function getConvertWarningsToExceptions(): bool
    {
        return $this-&gt;convertWarningsToExceptions;
    }

    /**
     * Enables or disables the stopping when an error occurs.
     */
    public function stopOnError(bool $flag): void
    {
        $this-&gt;stopOnError = $flag;
    }

    /**
     * Enables or disables the stopping when a failure occurs.
     */
    public function stopOnFailure(bool $flag): void
    {
        $this-&gt;stopOnFailure = $flag;
    }

    /**
     * Enables or disables the stopping when a warning occurs.
     */
    public function stopOnWarning(bool $flag): void
    {
        $this-&gt;stopOnWarning = $flag;
    }

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

    public function isStrictAboutTestsThatDoNotTestAnything(): bool
    {
        return $this-&gt;beStrictAboutTestsThatDoNotTestAnything;
    }

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

    public function isStrictAboutOutputDuringTests(): bool
    {
        return $this-&gt;beStrictAboutOutputDuringTests;
    }

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

    public function isStrictAboutResourceUsageDuringSmallTests(): bool
    {
        return $this-&gt;beStrictAboutResourceUsageDuringSmallTests;
    }

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

    public function enforcesTimeLimit(): bool
    {
        return $this-&gt;enforceTimeLimit;
    }

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

    public function isStrictAboutTodoAnnotatedTests(): bool
    {
        return $this-&gt;beStrictAboutTodoAnnotatedTests;
    }

    public function forceCoversAnnotation(): void
    {
        $this-&gt;forceCoversAnnotation = true;
    }

    public function forcesCoversAnnotation(): bool
    {
        return $this-&gt;forceCoversAnnotation;
    }

    /**
     * Enables or disables the stopping for risky tests.
     */
    public function stopOnRisky(bool $flag): void
    {
        $this-&gt;stopOnRisky = $flag;
    }

    /**
     * Enables or disables the stopping for incomplete tests.
     */
    public function stopOnIncomplete(bool $flag): void
    {
        $this-&gt;stopOnIncomplete = $flag;
    }

    /**
     * Enables or disables the stopping for skipped tests.
     */
    public function stopOnSkipped(bool $flag): void
    {
        $this-&gt;stopOnSkipped = $flag;
    }

    /**
     * Enables or disables the stopping for defects: error, failure, warning.
     */
    public function stopOnDefect(bool $flag): void
    {
        $this-&gt;stopOnDefect = $flag;
    }

    /**
     * Returns the time spent running the tests.
     */
    public function time(): float
    {
        return $this-&gt;time;
    }

    /**
     * Returns whether the entire test was successful or not.
     */
    public function wasSuccessful(): bool
    {
        return $this-&gt;wasSuccessfulIgnoringWarnings() &amp;&amp; empty($this-&gt;warnings);
    }

    public function wasSuccessfulIgnoringWarnings(): bool
    {
        return empty($this-&gt;errors) &amp;&amp; empty($this-&gt;failures);
    }

    public function wasSuccessfulAndNoTestIsRiskyOrSkippedOrIncomplete(): bool
    {
        return $this-&gt;wasSuccessful() &amp;&amp; $this-&gt;allHarmless() &amp;&amp; $this-&gt;allCompletelyImplemented() &amp;&amp; $this-&gt;noneSkipped();
    }

    /**
     * Sets the default timeout for tests.
     */
    public function setDefaultTimeLimit(int $timeout): void
    {
        $this-&gt;defaultTimeLimit = $timeout;
    }

    /**
     * Sets the timeout for small tests.
     */
    public function setTimeoutForSmallTests(int $timeout): void
    {
        $this-&gt;timeoutForSmallTests = $timeout;
    }

    /**
     * Sets the timeout for medium tests.
     */
    public function setTimeoutForMediumTests(int $timeout): void
    {
        $this-&gt;timeoutForMediumTests = $timeout;
    }

    /**
     * Sets the timeout for large tests.
     */
    public function setTimeoutForLargeTests(int $timeout): void
    {
        $this-&gt;timeoutForLargeTests = $timeout;
    }

    /**
     * Returns the set timeout for large tests.
     */
    public function getTimeoutForLargeTests(): int
    {
        return $this-&gt;timeoutForLargeTests;
    }

    public function setRegisterMockObjectsFromTestArgumentsRecursively(bool $flag): void
    {
        $this-&gt;registerMockObjectsFromTestArgumentsRecursively = $flag;
    }

    private function recordError(Test $test, Throwable $t): void
    {
        $this-&gt;errors[] = new TestFailure($test, $t);
    }

    private function recordNotImplemented(Test $test, Throwable $t): void
    {
        $this-&gt;notImplemented[] = new TestFailure($test, $t);
    }

    private function recordRisky(Test $test, Throwable $t): void
    {
        $this-&gt;risky[] = new TestFailure($test, $t);
    }

    private function recordSkipped(Test $test, Throwable $t): void
    {
        $this-&gt;skipped[] = new TestFailure($test, $t);
    }

    private function recordWarning(Test $test, Throwable $t): void
    {
        $this-&gt;warnings[] = new TestFailure($test, $t);
    }

    private function shouldTimeLimitBeEnforced(int $size): bool
    {
        if (!$this-&gt;enforceTimeLimit) {
            return false;
        }

        if (!(($this-&gt;defaultTimeLimit || $size !== TestUtil::UNKNOWN))) {
            return false;
        }

        if (!extension_loaded('pcntl')) {
            return false;
        }

        if (!class_exists(Invoker::class)) {
            return false;
        }

        if (extension_loaded('xdebug') &amp;&amp; xdebug_is_debugger_active()) {
            return false;
        }

        return true;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>