PHPUnit_Framework_TestResult::run PHP Метод

    public function run(PHPUnit_Framework_Test $test)
    {
        PHPUnit_Framework_Assert::resetCount();
        if ($test instanceof PHPUnit_Framework_TestCase) {
            $test->setRegisterMockObjectsFromTestArgumentsRecursively($this->registerMockObjectsFromTestArgumentsRecursively);
        }
        $error = false;
        $failure = false;
        $warning = false;
        $incomplete = false;
        $risky = false;
        $skipped = false;
        $this->startTest($test);
        $errorHandlerSet = false;
        if ($this->convertErrorsToExceptions) {
            $oldErrorHandler = set_error_handler(['PHPUnit_Util_ErrorHandler', 'handleError'], E_ALL | E_STRICT);
            if ($oldErrorHandler === null) {
                $errorHandlerSet = true;
            } else {
                restore_error_handler();
            }
        }
        $collectCodeCoverage = $this->codeCoverage !== null && !$test instanceof PHPUnit_Framework_WarningTestCase;
        if ($collectCodeCoverage) {
            $this->codeCoverage->start($test);
        }
        $monitorFunctions = $this->beStrictAboutResourceUsageDuringSmallTests && !$test instanceof PHPUnit_Framework_WarningTestCase && $test->getSize() == PHPUnit_Util_Test::SMALL && function_exists('xdebug_start_function_monitor');
        if ($monitorFunctions) {
            xdebug_start_function_monitor(ResourceOperations::getFunctions());
        }
        PHP_Timer::start();
        try {
            if (!$test instanceof PHPUnit_Framework_WarningTestCase && $test->getSize() != PHPUnit_Util_Test::UNKNOWN && $this->enforceTimeLimit && extension_loaded('pcntl') && class_exists('PHP_Invoker')) {
                switch ($test->getSize()) {
                    case PHPUnit_Util_Test::SMALL:
                        $_timeout = $this->timeoutForSmallTests;
                        break;
                    case PHPUnit_Util_Test::MEDIUM:
                        $_timeout = $this->timeoutForMediumTests;
                        break;
                    case PHPUnit_Util_Test::LARGE:
                        $_timeout = $this->timeoutForLargeTests;
                        break;
                }
                $invoker = new PHP_Invoker();
                $invoker->invoke([$test, 'runBare'], [], $_timeout);
            } else {
                $test->runBare();
            }
        } catch (PHPUnit_Framework_MockObject_Exception $e) {
            $e = new PHPUnit_Framework_Warning($e->getMessage());
            $warning = true;
        } catch (PHPUnit_Framework_AssertionFailedError $e) {
            $failure = true;
            if ($e instanceof PHPUnit_Framework_RiskyTestError) {
                $risky = true;
            } elseif ($e instanceof PHPUnit_Framework_IncompleteTestError) {
                $incomplete = true;
            } elseif ($e instanceof PHPUnit_Framework_SkippedTestError) {
                $skipped = true;
            }
        } catch (AssertionError $e) {
            $test->addToAssertionCount(1);
            $failure = true;
            $frame = $e->getTrace()[0];
            $e = new PHPUnit_Framework_AssertionFailedError(sprintf('%s in %s:%s', $e->getMessage(), $frame['file'], $frame['line']));
        } catch (PHPUnit_Framework_Warning $e) {
            $warning = true;
        } catch (PHPUnit_Framework_Exception $e) {
            $error = true;
        } catch (Throwable $e) {
            $e = new PHPUnit_Framework_ExceptionWrapper($e);
            $error = true;
        }
        $time = PHP_Timer::stop();
        $test->addToAssertionCount(PHPUnit_Framework_Assert::getCount());
        if ($monitorFunctions) {
            $blacklist = new PHPUnit_Util_Blacklist();
            $functions = xdebug_get_monitored_functions();
            xdebug_stop_function_monitor();
            foreach ($functions as $function) {
                if (!$blacklist->isBlacklisted($function['filename'])) {
                    $this->addFailure($test, new PHPUnit_Framework_RiskyTestError(sprintf('%s() used in %s:%s', $function['function'], $function['filename'], $function['lineno'])), $time);
                }
            }
        }
        if ($this->beStrictAboutTestsThatDoNotTestAnything && $test->getNumAssertions() == 0) {
            $risky = true;
        }
        if ($collectCodeCoverage) {
            $append = !$risky && !$incomplete && !$skipped;
            $linesToBeCovered = [];
            $linesToBeUsed = [];
            if ($append && $test instanceof PHPUnit_Framework_TestCase) {
                try {
                    $linesToBeCovered = PHPUnit_Util_Test::getLinesToBeCovered(get_class($test), $test->getName(false));
                    $linesToBeUsed = PHPUnit_Util_Test::getLinesToBeUsed(get_class($test), $test->getName(false));
                } catch (PHPUnit_Framework_InvalidCoversTargetException $cce) {
                    $this->addWarning($test, new PHPUnit_Framework_Warning($cce->getMessage()), $time);
                }
            }
            try {
                $this->codeCoverage->stop($append, $linesToBeCovered, $linesToBeUsed);
            } catch (UnintentionallyCoveredCodeException $cce) {
                $this->addFailure($test, new PHPUnit_Framework_UnintentionallyCoveredCodeError('This test executed code that is not listed as code to be covered or used:' . PHP_EOL . $cce->getMessage()), $time);
            } catch (CoveredCodeNotExecutedException $cce) {
                $this->addFailure($test, new PHPUnit_Framework_CoveredCodeNotExecutedException('This test did not execute all the code that is listed as code to be covered:' . PHP_EOL . $cce->getMessage()), $time);
            } catch (MissingCoversAnnotationException $cce) {
                if ($linesToBeCovered !== false) {
                    $this->addFailure($test, new PHPUnit_Framework_MissingCoversAnnotationException('This test does not have a @covers annotation but is expected to have one'), $time);
                }
            } catch (CodeCoverageException $cce) {
                $error = true;
                if (!isset($e)) {
                    $e = $cce;
                }
            }
        }
        if ($errorHandlerSet === true) {
            restore_error_handler();
        }
        if ($error === true) {
            $this->addError($test, $e, $time);
        } elseif ($failure === true) {
            $this->addFailure($test, $e, $time);
        } elseif ($warning === true) {
            $this->addWarning($test, $e, $time);
        } elseif ($this->beStrictAboutTestsThatDoNotTestAnything && !$test->doesNotPerformAssertions() && $test->getNumAssertions() == 0) {
            $this->addFailure($test, new PHPUnit_Framework_RiskyTestError('This test did not perform any assertions'), $time);
        } elseif ($this->beStrictAboutOutputDuringTests && $test->hasOutput()) {
            $this->addFailure($test, new PHPUnit_Framework_OutputError(sprintf('This test printed output: %s', $test->getActualOutput())), $time);
        } elseif ($this->beStrictAboutTodoAnnotatedTests && $test instanceof PHPUnit_Framework_TestCase) {
            $annotations = $test->getAnnotations();
            if (isset($annotations['method']['todo'])) {
                $this->addFailure($test, new PHPUnit_Framework_RiskyTestError('Test method is annotated with @todo'), $time);
            }
        }
        $this->endTest($test, $time);
    }

 /**
  * Runs the test case and collects the results in a given TestResult object.
  *
  * @param  PHPUnit_Framework_TestResult $result
  * @return PHPUnit_Framework_TestResult
  * @access public
  */
 public function run(PHPUnit_Framework_TestResult $result)
 {
     $result->run($this);
 }