PHP PHPUnit_Framework_TestCase::getTestResultObject方法代码示例

 /**
  * Validate code examples in $file
  *
  * @param  \SplFileObject $file
  * @param  string         $formatIdentifier
  * @return void
  */
 public function assertFile(\SplFileObject $file, $formatIdentifier = '')
 {
     $format = $this->formatFactory->createFormat($formatIdentifier ?: $file->getExtension());
     $result = $this->testCase->getTestResultObject();
     foreach ($this->tester->test($file, $format) as $example => $returnObj) {
         $this->testCase->addToAssertionCount(1);
         if ($returnObj->isFailure()) {
             $result->addFailure($this->testCase, new \PHPUnit_Framework_AssertionFailedError("Example {$example}: {$returnObj->getMessage()}"), 0.0);
         }
     }
 }

 /**
  * This is the publically accessible API for notifying the system that a
  * deprecated feature has been used.
  *
  * If it is run via a TestRunner and the test extends
  * PHPUnit_Framework_TestCase, then this will inject the result into the
  * test runner for display, if not, it will throw the notice to STDERR.
  *
  * @param string $message
  * @param int|bool $backtraceDepth
  */
 public static function log($message, $backtraceDepth = 2)
 {
     if ($backtraceDepth !== FALSE) {
         $trace = debug_backtrace(FALSE);
         if (is_int($backtraceDepth)) {
             $traceItem = $trace[$backtraceDepth];
         }
         if (!isset($traceItem['file'])) {
             $reflectionClass = new ReflectionClass($traceItem['class']);
             $traceItem['file'] = $reflectionClass->getFileName();
         }
         if (!isset($traceItem['line']) && isset($traceItem['class']) && isset($traceItem['function'])) {
             if (!isset($reflectionClass)) {
                 $reflectionClass = new ReflectionClass($traceItem['class']);
             }
             $method = $reflectionClass->getMethod($traceItem['function']);
             $traceItem['line'] = '(between ' . $method->getStartLine() . ' and ' . $method->getEndLine() . ')';
         }
     }
     $deprecatedFeature = new PHPUnit_Util_DeprecatedFeature($message, $traceItem);
     if (self::$currentTest instanceof PHPUnit_Framework_TestCase) {
         $result = self::$currentTest->getTestResultObject();
         $result->addDeprecatedFeature($deprecatedFeature);
     } else {
         file_put_contents('php://stderr', $deprecatedFeature);
     }
 }

 /**
  * Check an individual test run for valid @covers annotation.
  *
  * This method is called from $this::endTest().
  *
  * @param \PHPUnit_Framework_TestCase $test
  *   The test to examine.
  */
 public function checkValidCoversForTest(\PHPUnit_Framework_TestCase $test)
 {
     // If we're generating a coverage report already, don't do anything here.
     if ($test->getTestResultObject() && $test->getTestResultObject()->getCollectCodeCoverageInformation()) {
         return;
     }
     // Gather our annotations.
     $annotations = $test->getAnnotations();
     // Glean the @coversDefaultClass annotation.
     $default_class = '';
     $valid_default_class = FALSE;
     if (isset($annotations['class']['coversDefaultClass'])) {
         if (count($annotations['class']['coversDefaultClass']) > 1) {
             $this->fail($test, '@coversDefaultClass has too many values');
         }
         // Grab the first one.
         $default_class = reset($annotations['class']['coversDefaultClass']);
         // Check whether the default class exists.
         $valid_default_class = $this->classExists($default_class);
         if (!$valid_default_class) {
             $this->fail($test, "@coversDefaultClass does not exist '{$default_class}'");
         }
     }
     // Glean @covers annotation.
     if (isset($annotations['method']['covers'])) {
         // Drupal allows multiple @covers per test method, so we have to check
         // them all.
         foreach ($annotations['method']['covers'] as $covers) {
             // Ensure the annotation isn't empty.
             if (trim($covers) === '') {
                 $this->fail($test, '@covers should not be empty');
                 // If @covers is empty, we can't proceed.
                 return;
             }
             // Ensure we don't have ().
             if (strpos($covers, '()') !== FALSE) {
                 $this->fail($test, "@covers invalid syntax: Do not use '()'");
             }
             // Glean the class and method from @covers.
             $class = $covers;
             $method = '';
             if (strpos($covers, '::') !== FALSE) {
                 list($class, $method) = explode('::', $covers);
             }
             // Check for the existence of the class if it's specified by @covers.
             if (!empty($class)) {
                 // If the class doesn't exist we have either a bad classname or
                 // are missing the :: for a method. Either way we can't proceed.
                 if (!$this->classExists($class)) {
                     if (empty($method)) {
                         $this->fail($test, "@covers invalid syntax: Needs '::' or class does not exist in {$covers}");
                         return;
                     } else {
                         $this->fail($test, '@covers class does not exist ' . $class);
                         return;
                     }
                 }
             } else {
                 // The class isn't specified and we have the ::, so therefore this
                 // test either covers a function, or relies on a default class.
                 if (empty($default_class)) {
                     // If there's no default class, then we need to check if the global
                     // function exists. Since this listener should always be listening
                     // for endTest(), the function should have already been loaded from
                     // its .module or .inc file.
                     if (!function_exists($method)) {
                         $this->fail($test, '@covers global method does not exist ' . $method);
                     }
                 } else {
                     // We have a default class and this annotation doesn't act like a
                     // global function, so we should use the default class if it's
                     // valid.
                     if ($valid_default_class) {
                         $class = $default_class;
                     }
                 }
             }
             // Finally, after all that, let's see if the method exists.
             if (!empty($class) && !empty($method)) {
                 $ref_class = new \ReflectionClass($class);
                 if (!$ref_class->hasMethod($method)) {
                     $this->fail($test, '@covers method does not exist ' . $class . '::' . $method);
                 }
             }
         }
     }
 }