Subversion-Projekte lars-tiefland.laravel_shop

<?php declare(strict_types=1);

/*

 * This file is part of PHPUnit.

 *

 * (c) Sebastian Bergmann <sebastian@phpunit.de>

 *

 * 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\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<string>

     */

    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->listeners[] = $listener;

    }

    /**

     * @deprecated Use the `TestHook` interfaces instead

     *

     * @codeCoverageIgnore

     *

     * Unregisters a TestListener.

     */

    public function removeListener(TestListener $listener): void

    {

        foreach ($this->listeners as $key => $_listener) {

            if ($listener === $_listener) {

                unset($this->listeners[$key]);

            }

        }

    }

    /**

     * @deprecated Use the `TestHook` interfaces instead

     *

     * @codeCoverageIgnore

     *

     * Flushes all flushable TestListeners.

     */

    public function flushListeners(): void

    {

        foreach ($this->listeners as $listener) {

            if ($listener instanceof Printer) {

                $listener->flush();

            }

        }

    }

    /**

     * Adds an error to the list of errors.

     */

    public function addError(Test $test, Throwable $t, float $time): void

    {

        if ($t instanceof RiskyTestError) {

            $this->recordRisky($test, $t);

            $notifyMethod = 'addRiskyTest';

            if ($test instanceof TestCase) {

                $test->markAsRisky();

            }

            if ($this->stopOnRisky || $this->stopOnDefect) {

                $this->stop();

            }

        } elseif ($t instanceof IncompleteTest) {

            $this->recordNotImplemented($test, $t);

            $notifyMethod = 'addIncompleteTest';

            if ($this->stopOnIncomplete) {

                $this->stop();

            }

        } elseif ($t instanceof SkippedTest) {

            $this->recordSkipped($test, $t);

            $notifyMethod = 'addSkippedTest';

            if ($this->stopOnSkipped) {

                $this->stop();

            }

        } else {

            $this->recordError($test, $t);

            $notifyMethod = 'addError';

            if ($this->stopOnError || $this->stopOnFailure) {

                $this->stop();

            }

        }

        // @see https://github.com/sebastianbergmann/phpunit/issues/1953

        if ($t instanceof Error) {

            $t = new ExceptionWrapper($t);

        }

        foreach ($this->listeners as $listener) {

            $listener->{$notifyMethod}($test, $t, $time);

        }

        $this->lastTestFailed = true;

        $this->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->stopOnWarning || $this->stopOnDefect) {

            $this->stop();

        }

        $this->recordWarning($test, $e);

        foreach ($this->listeners as $listener) {

            $listener->addWarning($test, $e, $time);

        }

        $this->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->recordRisky($test, $e);

            $notifyMethod = 'addRiskyTest';

            if ($test instanceof TestCase) {

                $test->markAsRisky();

            }

            if ($this->stopOnRisky || $this->stopOnDefect) {

                $this->stop();

            }

        } elseif ($e instanceof IncompleteTest) {

            $this->recordNotImplemented($test, $e);

            $notifyMethod = 'addIncompleteTest';

            if ($this->stopOnIncomplete) {

                $this->stop();

            }

        } elseif ($e instanceof SkippedTest) {

            $this->recordSkipped($test, $e);

            $notifyMethod = 'addSkippedTest';

            if ($this->stopOnSkipped) {

                $this->stop();

            }

        } else {

            $this->failures[] = new TestFailure($test, $e);

            $notifyMethod     = 'addFailure';

            if ($this->stopOnFailure || $this->stopOnDefect) {

                $this->stop();

            }

        }

        foreach ($this->listeners as $listener) {

            $listener->{$notifyMethod}($test, $e, $time);

        }

        $this->lastTestFailed = true;

        $this->time += $time;

    }

    /**

     * Informs the result that a test suite will be started.

     */

    public function startTestSuite(TestSuite $suite): void

    {

        $this->currentTestSuiteFailed = false;

        foreach ($this->listeners as $listener) {

            $listener->startTestSuite($suite);

        }

    }

    /**

     * Informs the result that a test suite was completed.

     */

    public function endTestSuite(TestSuite $suite): void

    {

        if (!$this->currentTestSuiteFailed) {

            $this->passedTestClasses[] = $suite->getName();

        }

        foreach ($this->listeners as $listener) {

            $listener->endTestSuite($suite);

        }

    }

    /**

     * Informs the result that a test will be started.

     */

    public function startTest(Test $test): void

    {

        $this->lastTestFailed = false;

        $this->runTests += count($test);

        foreach ($this->listeners as $listener) {

            $listener->startTest($test);

        }

    }

    /**

     * Informs the result that a test was completed.

     *

     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

     */

    public function endTest(Test $test, float $time): void

    {

        foreach ($this->listeners as $listener) {

            $listener->endTest($test, $time);

        }

        if (!$this->lastTestFailed && $test instanceof TestCase) {

            $class = get_class($test);

            $key   = $class . '::' . $test->getName();

            $this->passed[$key] = [

                'result' => $test->getResult(),

                'size'   => TestUtil::getSize(

                    $class,

                    $test->getName(false)

                ),

            ];

            $this->time += $time;

        }

        if ($this->lastTestFailed && $test instanceof TestCase) {

            $this->currentTestSuiteFailed = true;

        }

    }

    /**

     * Returns true if no risky test occurred.

     */

    public function allHarmless(): bool

    {

        return $this->riskyCount() === 0;

    }

    /**

     * Gets the number of risky tests.

     */

    public function riskyCount(): int

    {

        return count($this->risky);

    }

    /**

     * Returns true if no incomplete test occurred.

     */

    public function allCompletelyImplemented(): bool

    {

        return $this->notImplementedCount() === 0;

    }

    /**

     * Gets the number of incomplete tests.

     */

    public function notImplementedCount(): int

    {

        return count($this->notImplemented);

    }

    /**

     * Returns an array of TestFailure objects for the risky tests.

     *

     * @return TestFailure[]

     */

    public function risky(): array

    {

        return $this->risky;

    }

    /**

     * Returns an array of TestFailure objects for the incomplete tests.

     *

     * @return TestFailure[]

     */

    public function notImplemented(): array

    {

        return $this->notImplemented;

    }

    /**

     * Returns true if no test has been skipped.

     */

    public function noneSkipped(): bool

    {

        return $this->skippedCount() === 0;

    }

    /**

     * Gets the number of skipped tests.

     */

    public function skippedCount(): int

    {

        return count($this->skipped);

    }

    /**

     * Returns an array of TestFailure objects for the skipped tests.

     *

     * @return TestFailure[]

     */

    public function skipped(): array

    {

        return $this->skipped;

    }

    /**

     * Gets the number of detected errors.

     */

    public function errorCount(): int

    {

        return count($this->errors);

    }

    /**

     * Returns an array of TestFailure objects for the errors.

     *

     * @return TestFailure[]

     */

    public function errors(): array

    {

        return $this->errors;

    }

    /**

     * Gets the number of detected failures.

     */

    public function failureCount(): int

    {

        return count($this->failures);

    }

    /**

     * Returns an array of TestFailure objects for the failures.

     *

     * @return TestFailure[]

     */

    public function failures(): array

    {

        return $this->failures;

    }

    /**

     * Gets the number of detected warnings.

     */

    public function warningCount(): int

    {

        return count($this->warnings);

    }

    /**

     * Returns an array of TestFailure objects for the warnings.

     *

     * @return TestFailure[]

     */

    public function warnings(): array

    {

        return $this->warnings;

    }

    /**

     * Returns the names of the tests that have passed.

     */

    public function passed(): array

    {

        return $this->passed;

    }

    /**

     * Returns the names of the TestSuites that have passed.

     *

     * This enables @depends-annotations for TestClassName::class

     */

    public function passedClasses(): array

    {

        return $this->passedTestClasses;

    }

    /**

     * Returns whether code coverage information should be collected.

     */

    public function getCollectCodeCoverageInformation(): bool

    {

        return $this->codeCoverage !== null;

    }

    /**

     * Runs a TestCase.

     *

     * @throws \SebastianBergmann\CodeCoverage\InvalidArgumentException

     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

     * @throws CodeCoverageException

     * @throws UnintentionallyCoveredCodeException

     */

    public function run(Test $test): void

    {

        Assert::resetCount();

        $size = TestUtil::UNKNOWN;

        if ($test instanceof TestCase) {

            $test->setRegisterMockObjectsFromTestArgumentsRecursively(

                $this->registerMockObjectsFromTestArgumentsRecursively

            );

            $isAnyCoverageRequired = TestUtil::requiresCodeCoverageDataCollection($test);

            $size                  = $test->getSize();

        }

        $error      = false;

        $failure    = false;

        $warning    = false;

        $incomplete = false;

        $risky      = false;

        $skipped    = false;

        $this->startTest($test);

        if ($this->convertDeprecationsToExceptions || $this->convertErrorsToExceptions || $this->convertNoticesToExceptions || $this->convertWarningsToExceptions) {

            $errorHandler = new ErrorHandler(

                $this->convertDeprecationsToExceptions,

                $this->convertErrorsToExceptions,

                $this->convertNoticesToExceptions,

                $this->convertWarningsToExceptions

            );

            $errorHandler->register();

        }

        $collectCodeCoverage = $this->codeCoverage !== null &&

                               !$test instanceof ErrorTestCase &&

                               !$test instanceof WarningTestCase &&

                               $isAnyCoverageRequired;

        if ($collectCodeCoverage) {

            $this->codeCoverage->start($test);

        }

        $monitorFunctions = $this->beStrictAboutResourceUsageDuringSmallTests &&

                            !$test instanceof ErrorTestCase &&

                            !$test instanceof WarningTestCase &&

                            $size === TestUtil::SMALL &&

                            function_exists('xdebug_start_function_monitor');

        if ($monitorFunctions) {

            /* @noinspection ForgottenDebugOutputInspection */

            xdebug_start_function_monitor(ResourceOperations::getFunctions());

        }

        $timer = new Timer;

        $timer->start();

        try {

            $invoker = new Invoker;

            if (!$test instanceof ErrorTestCase &&

                !$test instanceof WarningTestCase &&

                $this->shouldTimeLimitBeEnforced($size) &&

                $invoker->canInvokeWithTimeout()) {

                switch ($size) {

                    case TestUtil::SMALL:

                        $_timeout = $this->timeoutForSmallTests;

                        break;

                    case TestUtil::MEDIUM:

                        $_timeout = $this->timeoutForMediumTests;

                        break;

                    case TestUtil::LARGE:

                        $_timeout = $this->timeoutForLargeTests;

                        break;

                    default:

                        $_timeout = $this->defaultTimeLimit;

                }

                $invoker->invoke([$test, 'runBare'], [], $_timeout);

            } else {

                $test->runBare();

            }

        } catch (TimeoutException $e) {

            $this->addFailure(

                $test,

                new RiskyTestError(

                    $e->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->addToAssertionCount(1);

            $failure = true;

            $frame   = $e->getTrace()[0];

            $e = new AssertionFailedError(

                sprintf(

                    '%s in %s:%s',

                    $e->getMessage(),

                    $frame['file'] ?? $e->getFile(),

                    $frame['line'] ?? $e->getLine()

                ),

                0,

                $e

            );

        } catch (Warning $e) {

            $warning = true;

        } catch (Exception $e) {

            $error = true;

        } catch (Throwable $e) {

            $e     = new ExceptionWrapper($e);

            $error = true;

        }

        $time = $timer->stop()->asSeconds();

        $test->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->isExcluded($function['filename'])) {

                    $this->addFailure(

                        $test,

                        new RiskyTestError(

                            sprintf(

                                '%s() used in %s:%s',

                                $function['function'],

                                $function['filename'],

                                $function['lineno']

                            )

                        ),

                        $time

                    );

                }

            }

        }

        if ($this->beStrictAboutTestsThatDoNotTestAnything &&

            !$test->doesNotPerformAssertions() &&

            $test->getNumAssertions() === 0) {

            $risky = true;

        }

        if ($this->forceCoversAnnotation && !$error && !$failure && !$warning && !$incomplete && !$skipped && !$risky) {

            $annotations = TestUtil::parseTestMethodAnnotations(

                get_class($test),

                $test->getName(false)

            );

            if (!isset($annotations['class']['covers']) &&

                !isset($annotations['method']['covers']) &&

                !isset($annotations['class']['coversNothing']) &&

                !isset($annotations['method']['coversNothing'])) {

                $this->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 && !$incomplete && !$skipped;

            $linesToBeCovered = [];

            $linesToBeUsed    = [];

            if ($append && $test instanceof TestCase) {

                try {

                    $linesToBeCovered = TestUtil::getLinesToBeCovered(

                        get_class($test),

                        $test->getName(false)

                    );

                    $linesToBeUsed = TestUtil::getLinesToBeUsed(

                        get_class($test),

                        $test->getName(false)

                    );

                } catch (InvalidCoversTargetException $cce) {

                    $this->addWarning(

                        $test,

                        new Warning(

                            $cce->getMessage()

                        ),

                        $time

                    );

                }

            }

            try {

                $this->codeCoverage->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->getMessage()

                );

            } catch (OriginalCodeCoverageException $cce) {

                $error = true;

                $e = $e ?? $cce;

            }

        }

        if (isset($errorHandler)) {

            $errorHandler->unregister();

            unset($errorHandler);

        }

        if ($error) {

            $this->addError($test, $e, $time);

        } elseif ($failure) {

            $this->addFailure($test, $e, $time);

        } elseif ($warning) {

            $this->addWarning($test, $e, $time);

        } elseif (isset($unintentionallyCoveredCodeError)) {

            $this->addFailure(

                $test,

                $unintentionallyCoveredCodeError,

                $time

            );

        } elseif ($this->beStrictAboutTestsThatDoNotTestAnything &&

            !$test->doesNotPerformAssertions() &&

            $test->getNumAssertions() === 0) {

            try {

                $reflected = new ReflectionClass($test);

                // @codeCoverageIgnoreStart

            } catch (ReflectionException $e) {

                throw new Exception(

                    $e->getMessage(),

                    $e->getCode(),

                    $e

                );

            }

            // @codeCoverageIgnoreEnd

            $name = $test->getName(false);

            if ($name && $reflected->hasMethod($name)) {

                try {

                    $reflected = $reflected->getMethod($name);

                    // @codeCoverageIgnoreStart

                } catch (ReflectionException $e) {

                    throw new Exception(

                        $e->getMessage(),

                        $e->getCode(),

                        $e

                    );

                }

                // @codeCoverageIgnoreEnd

            }

            $this->addFailure(

                $test,

                new RiskyTestError(

                    sprintf(

                        "This test did not perform any assertions\n\n%s:%d",

                        $reflected->getFileName(),

                        $reflected->getStartLine()

                    )

                ),

                $time

            );

        } elseif ($this->beStrictAboutTestsThatDoNotTestAnything &&

            $test->doesNotPerformAssertions() &&

            $test->getNumAssertions() > 0) {

            $this->addFailure(

                $test,

                new RiskyTestError(

                    sprintf(

                        'This test is annotated with "@doesNotPerformAssertions" but performed %d assertions',

                        $test->getNumAssertions()

                    )

                ),

                $time

            );

        } elseif ($this->beStrictAboutOutputDuringTests && $test->hasOutput()) {

            $this->addFailure(

                $test,

                new OutputError(

                    sprintf(

                        'This test printed output: %s',

                        $test->getActualOutput()

                    )

                ),

                $time

            );

        } elseif ($this->beStrictAboutTodoAnnotatedTests && $test instanceof TestCase) {

            $annotations = TestUtil::parseTestMethodAnnotations(

                get_class($test),

                $test->getName(false)

            );

            if (isset($annotations['method']['todo'])) {

                $this->addFailure(

                    $test,

                    new RiskyTestError(

                        'Test method is annotated with @todo'

                    ),

                    $time

                );

            }

        }

        $this->endTest($test, $time);

    }

    /**

     * Gets the number of run tests.

     */

    public function count(): int

    {

        return $this->runTests;

    }

    /**

     * Checks whether the test run should stop.

     */

    public function shouldStop(): bool

    {

        return $this->stop;

    }

    /**

     * Marks that the test run should stop.

     */

    public function stop(): void

    {