PHP PHPUnit_Framework_ComparisonFailure类代码示例

 /**
  * Send a command to the Selenium RC server (via curl).
  *
  * @param  string $command
  * @param  array  $arguments
  * @return string
  * @author Seth Casana <totallymeat@gmail.org>
  */
 protected function doCommand($command, array $arguments = array())
 {
     $url = sprintf('http://%s:%s/selenium-server/driver/?cmd=%s', $this->host, $this->port, urlencode($command));
     $numArguments = count($arguments);
     for ($i = 0; $i < $numArguments; $i++) {
         $argNum = strval($i + 1);
         $url .= sprintf('&%s=%s', $argNum, urlencode(trim($arguments[$i])));
     }
     if (isset($this->sessionId)) {
         $url .= sprintf('&%s=%s', 'sessionId', $this->sessionId);
     }
     $curl = curl_init();
     curl_setopt($curl, CURLOPT_URL, $url);
     curl_setopt($curl, CURLOPT_HEADER, 0);
     curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
     curl_setopt($curl, CURLOPT_CONNECTTIMEOUT, 60);
     $response = curl_exec($curl);
     $info = curl_getinfo($curl);
     if (!$response) {
         throw new RuntimeException(curl_error($curl));
     }
     curl_close($curl);
     if ($info['http_code'] != 200) {
         $this->stop();
         throw new RuntimeException('The response from the Selenium RC server is invalid: ' . $response);
     }
     if (!preg_match('/^OK/', $response)) {
         throw new PHPUnit_Framework_ExpectationFailedException('Non-Ok response from Selenium RC server was received', PHPUnit_Framework_ComparisonFailure::diffEqual('OK', $response), sprintf("Response from Selenium RC server for %s(%s).\n%s.\n", $command, implode(', ', $arguments), $response));
     }
     return $response;
 }

 /**
  * @param   mixed   $other The value passed to evaluate() which failed the
  *                         constraint check.
  * @param   string  $description A string with extra description of what was
  *                               going on while the evaluation failed.
  * @param   boolean $not Flag to indicate negation.
  * @throws  PHPUnit_Framework_ExpectationFailedException
  */
 public function fail($other, $description, $not = FALSE)
 {
     $failureDescription = $this->failureDescription($other, $description, $not);
     if (!$not) {
         if ($this->value instanceof DOMDocument) {
             $value = $this->domToText($this->value);
         } else {
             $value = $this->value;
         }
         if ($other instanceof DOMDocument) {
             $other = $this->domToText($other);
         }
         throw new PHPUnit_Framework_ExpectationFailedException($failureDescription, PHPUnit_Framework_ComparisonFailure::diffEqual($value, $other), $description);
     } else {
         throw new PHPUnit_Framework_ExpectationFailedException($failureDescription, NULL);
     }
 }

 /**
  * Returns a string describing the difference between the expected and the
  * actual object.
  *
  * @return string
  */
 public function toString()
 {
     $diff = PHPUnit_Util_Diff::diff(print_r($this->expected, TRUE), print_r($this->actual, TRUE));
     if ($diff !== FALSE) {
         return trim($diff);
     }
     // Fallback: Either diff is not available or the print_r() output for
     // the expected and the actual object are equal (but the objects are
     // not).
     $expectedClass = get_class($this->expected);
     $actualClass = get_class($this->actual);
     if ($expectedClass !== $actualClass) {
         return sprintf("%s%sexpected class <%s>\n" . '%sgot class      <%s>', $this->message, $this->message != '' ? ' ' : '', $expectedClass, $this->message != '' ? str_repeat(' ', strlen($this->message) + 1) : '', $actualClass);
     } else {
         $expectedReflection = new ReflectionClass($expectedClass);
         $actualReflection = new ReflectionClass($actualClass);
         $diff = "in object of class <{$expectedClass}>:\n";
         $i = 0;
         foreach ($expectedReflection->getProperties() as $expectedAttribute) {
             if ($expectedAttribute->isPrivate() || $expectedAttribute->isProtected()) {
                 continue;
             }
             $actualAttribute = $actualReflection->getProperty($expectedAttribute->getName());
             $expectedValue = $expectedAttribute->getValue($this->expected);
             $actualValue = $actualAttribute->getValue($this->actual);
             if ($expectedValue !== $actualValue) {
                 if ($i > 0) {
                     $diff .= "\n";
                 }
                 ++$i;
                 $expectedType = gettype($expectedValue);
                 $actualType = gettype($actualValue);
                 if ($expectedType !== $actualType) {
                     $diffObject = new PHPUnit_Framework_ComparisonFailure_Type($expectedValue, $actualValue, $this->message . 'attribute <' . $expectedAttribute->getName() . '>: ');
                     $diff .= $diffObject->toString();
                 } elseif (is_object($expectedValue)) {
                     if (get_class($expectedValue) !== get_class($actualValue)) {
                         $diffObject = new PHPUnit_Framework_ComparisonFailure_Type($expectedValue, $actualValue, $this->message . 'attribute <' . $expectedAttribute->getName() . '>: ');
                         $diff .= $diffObject->toString();
                     } else {
                         $diff .= 'attribute <' . $expectedAttribute->getName() . '> contains object <' . get_class($expectedValue) . '> with different attributes';
                     }
                 } else {
                     $diffObject = PHPUnit_Framework_ComparisonFailure::diffIdentical($expectedValue, $actualValue, $this->message . 'attribute <' . $expectedAttribute->getName() . '>: ');
                     $diff .= $diffObject->toString();
                 }
             }
         }
         return $diff;
     }
 }

 /**
  * @param   mixed   $other The value passed to evaluate() which failed the
  *                         constraint check.
  * @param   string  $description A string with extra description of what was
  *                               going on while the evaluation failed.
  * @param   boolean $not Flag to indicate negation.
  * @throws  PHPUnit_Framework_ExpectationFailedException
  */
 public function fail($other, $description, $not = FALSE)
 {
     $failureDescription = $this->failureDescription($other, $description, $not);
     if (!$not) {
         throw new PHPUnit_Framework_ExpectationFailedException($failureDescription, PHPUnit_Framework_ComparisonFailure::diffIdentical($this->value, $other), $description);
     } else {
         throw new PHPUnit_Framework_ExpectationFailedException($failureDescription, NULL);
     }
 }

 /**
  * Returns a string describing the difference between the expected and the
  * actual array.
  *
  * @return string
  */
 public function toString()
 {
     if (!$this->identical) {
         ksort($this->expected);
         ksort($this->actual);
     }
     $diff = PHPUnit_Util_Diff::diff(print_r($this->expected, TRUE), print_r($this->actual, TRUE));
     if ($diff !== FALSE) {
         return trim($diff);
     }
     // Fallback: Either diff is not available or the print_r() output for
     // the expected and the actual array are equal (but the arrays are not).
     $expectedOnly = array();
     $actualOnly = array();
     $diff = '';
     foreach ($this->expected as $expectedKey => $expectedValue) {
         if (!array_key_exists($expectedKey, $this->actual)) {
             $expectedOnly[] = $expectedKey;
             continue;
         }
         if ($expectedValue === $this->actual[$expectedKey]) {
             continue;
         }
         $diffObject = PHPUnit_Framework_ComparisonFailure::diffIdentical($expectedValue, $this->actual[$expectedKey], sprintf('%sarray key %s: ', $this->message, PHPUnit_Util_Type::toString($expectedKey)));
         $diff .= $diffObject->toString() . "\n";
     }
     foreach ($this->actual as $actualKey => $actualValue) {
         if (!array_key_exists($actualKey, $this->expected)) {
             $actualOnly[] = $actualKey;
             continue;
         }
     }
     foreach ($expectedOnly as $expectedKey) {
         $diff .= sprintf("array key %s: only in expected %s\n", PHPUnit_Util_Type::toString($expectedKey), PHPUnit_Util_Type::toString($this->expected[$expectedKey]));
     }
     foreach ($actualOnly as $actualKey) {
         $diff .= sprintf("array key %s: only in actual %s\n", PHPUnit_Util_Type::toString($actualKey), PHPUnit_Util_Type::toString($this->actual[$actualKey]));
     }
     return $diff;
 }

 /**
  * @param  PHPUnit_Framework_TestFailure $defect
  * @access protected
  */
 protected function printDefectTrace(PHPUnit_Framework_TestFailure $defect)
 {
     $e = $defect->thrownException();
     if ($e instanceof PHPUnit_Framework_SelfDescribing) {
         $buffer = $e->toString();
         if (!empty($buffer)) {
             $buffer .= "\n";
         }
         if ($e instanceof PHPUnit_Framework_ExpectationFailedException) {
             $comparisonFailure = $e->getComparisonFailure();
             if ($comparisonFailure !== NULL) {
                 if ($comparisonFailure instanceof PHPUnit_Framework_ComparisonFailure_Scalar) {
                     $buffer .= sprintf("Failed asserting that %s matches expected value %s.\n", PHPUnit_Util_Type::toString($comparisonFailure->getActual()), PHPUnit_Util_Type::toString($comparisonFailure->getExpected()));
                 } else {
                     if (PHPUnit_Framework_ComparisonFailure::hasDiff() && ($comparisonFailure instanceof PHPUnit_Framework_ComparisonFailure_Array || $comparisonFailure instanceof PHPUnit_Framework_ComparisonFailure_Object || $comparisonFailure instanceof PHPUnit_Framework_ComparisonFailure_String)) {
                         $buffer .= sprintf("Failed asserting that two %ss are equal.\n%s\n", strtolower(substr(get_class($comparisonFailure), 36)), $comparisonFailure->toString());
                     }
                 }
                 if ($this->verbose && !$comparisonFailure instanceof PHPUnit_Framework_ComparisonFailure_Array && !$comparisonFailure instanceof PHPUnit_Framework_ComparisonFailure_Object && !$comparisonFailure instanceof PHPUnit_Framework_ComparisonFailure_String) {
                     $buffer .= $comparisonFailure->toString() . "\n";
                 }
             } else {
                 $buffer .= $e->getDescription() . "\n";
             }
         }
     } else {
         if ($e instanceof PHPUnit_Framework_Error) {
             $buffer = $e->getMessage() . "\n";
         } else {
             $buffer = get_class($e) . ': ' . $e->getMessage() . "\n";
         }
     }
     $this->write($buffer . PHPUnit_Util_Filter::getFilteredStacktrace($defect->thrownException(), FALSE));
 }

 /**
  * Runs a test and collects its result in a TestResult instance.
  *
  * @param  PHPUnit_Framework_TestResult $result
  * @param  array $options Array with ini settings for the php instance run,
  *                        key being the name if the setting, value the ini value.
  * @return PHPUnit_Framework_TestResult
  * @access public
  */
 public function run(PHPUnit_Framework_TestResult $result = NULL, $options = array())
 {
     if (!class_exists('PEAR_RunTest', FALSE)) {
         throw new RuntimeException('Class PEAR_RunTest not found.');
     }
     if ($result === NULL) {
         $result = new PHPUnit_Framework_TestResult();
     }
     if (!is_array($options)) {
         throw new InvalidArgumentException();
     }
     $options = array_merge($options, $this->options);
     $coverage = $result->getCollectCodeCoverageInformation();
     if ($coverage) {
         $options = array('coverage' => TRUE);
     } else {
         $options = array();
     }
     $runner = new PEAR_RunTest(new PHPUnit_Extensions_PhptTestCase_Logger(), $options);
     if ($coverage) {
         $runner->xdebug_loaded = TRUE;
     } else {
         $runner->xdebug_loaded = FALSE;
     }
     $result->startTest($this);
     PHPUnit_Util_Timer::start();
     $buffer = $runner->run($this->filename, $options);
     $time = PHPUnit_Util_Timer::stop();
     $base = basename($this->filename);
     $path = dirname($this->filename);
     $coverageFile = $path . DIRECTORY_SEPARATOR . str_replace('.phpt', '.xdebug', $base);
     $diffFile = $path . DIRECTORY_SEPARATOR . str_replace('.phpt', '.diff', $base);
     $expFile = $path . DIRECTORY_SEPARATOR . str_replace('.phpt', '.exp', $base);
     $logFile = $path . DIRECTORY_SEPARATOR . str_replace('.phpt', '.log', $base);
     $outFile = $path . DIRECTORY_SEPARATOR . str_replace('.phpt', '.out', $base);
     $phpFile = $path . DIRECTORY_SEPARATOR . str_replace('.phpt', '.php', $base);
     if (is_object($buffer) && $buffer instanceof PEAR_Error) {
         $result->addError($this, new RuntimeException($buffer->getMessage()), $time);
     } else {
         if ($buffer == 'SKIPPED') {
             $result->addFailure($this, new PHPUnit_Framework_SkippedTestError(), 0);
         } else {
             if ($buffer != 'PASSED') {
                 $result->addFailure($this, PHPUnit_Framework_ComparisonFailure::diffEqual(file_get_contents($expFile), file_get_contents($outFile), FALSE, $this->getName()), $time);
             }
         }
     }
     foreach (array($diffFile, $expFile, $logFile, $phpFile, $outFile) as $file) {
         if (file_exists($file)) {
             unlink($file);
         }
     }
     if ($coverage) {
         eval('$coverageData = ' . file_get_contents($coverageFile) . ';');
         unset($coverageData[$phpFile]);
         $codeCoverageInformation = array('test' => $this, 'files' => $coverageData);
         $result->appendCodeCoverageInformation($this, $codeCoverageInformation);
         unlink($coverageFile);
     }
     $result->endTest($this, $time);
     return $result;
 }

 /**
  * Runs a test and collects its result in a TestResult instance.
  *
  * @param  PHPUnit_Framework_TestResult $result
  * @param  array                        $options
  * @return PHPUnit_Framework_TestResult
  */
 public function run(PHPUnit_Framework_TestResult $result = NULL, array $options = array())
 {
     if (!class_exists('PEAR_RunTest', FALSE)) {
         throw new PHPUnit_Framework_Exception('Class PEAR_RunTest not found.');
     }
     if (isset($GLOBALS['_PEAR_destructor_object_list']) && is_array($GLOBALS['_PEAR_destructor_object_list']) && !empty($GLOBALS['_PEAR_destructor_object_list'])) {
         $pearDestructorObjectListCount = count($GLOBALS['_PEAR_destructor_object_list']);
     } else {
         $pearDestructorObjectListCount = 0;
     }
     if ($result === NULL) {
         $result = new PHPUnit_Framework_TestResult();
     }
     $coverage = $result->getCollectCodeCoverageInformation();
     $options = array_merge($options, $this->options);
     if (!isset($options['include_path'])) {
         $options['include_path'] = get_include_path();
     }
     if ($coverage) {
         $options['coverage'] = TRUE;
     } else {
         $options['coverage'] = FALSE;
     }
     $currentErrorReporting = error_reporting(E_ERROR | E_WARNING | E_PARSE);
     $runner = new PEAR_RunTest(new PHPUnit_Extensions_PhptTestCase_Logger(), $options);
     if ($coverage) {
         $runner->xdebug_loaded = TRUE;
     } else {
         $runner->xdebug_loaded = FALSE;
     }
     $result->startTest($this);
     PHP_Timer::start();
     $buffer = $runner->run($this->filename, $options);
     $time = PHP_Timer::stop();
     error_reporting($currentErrorReporting);
     $base = basename($this->filename);
     $path = dirname($this->filename);
     $coverageFile = $path . DIRECTORY_SEPARATOR . str_replace('.phpt', '.xdebug', $base);
     $diffFile = $path . DIRECTORY_SEPARATOR . str_replace('.phpt', '.diff', $base);
     $expFile = $path . DIRECTORY_SEPARATOR . str_replace('.phpt', '.exp', $base);
     $logFile = $path . DIRECTORY_SEPARATOR . str_replace('.phpt', '.log', $base);
     $outFile = $path . DIRECTORY_SEPARATOR . str_replace('.phpt', '.out', $base);
     $phpFile = $path . DIRECTORY_SEPARATOR . str_replace('.phpt', '.php', $base);
     if (file_exists($phpFile)) {
         PHP_CodeCoverage_Filter::getInstance()->addFileToBlacklist($phpFile, 'TESTS');
     }
     if (is_object($buffer) && $buffer instanceof PEAR_Error) {
         $result->addError($this, new RuntimeException($buffer->getMessage()), $time);
     } else {
         if ($buffer == 'SKIPPED') {
             $result->addFailure($this, new PHPUnit_Framework_SkippedTestError(), 0);
         } else {
             if ($buffer != 'PASSED') {
                 $result->addFailure($this, PHPUnit_Framework_ComparisonFailure::diffEqual(file_get_contents($expFile), file_get_contents($outFile)), $time);
             }
         }
     }
     foreach (array($diffFile, $expFile, $logFile, $phpFile, $outFile) as $file) {
         if (file_exists($file)) {
             unlink($file);
         }
     }
     if ($coverage && file_exists($coverageFile)) {
         eval('$coverageData = ' . file_get_contents($coverageFile) . ';');
         unset($coverageData[$phpFile]);
         $result->getCodeCoverage()->append($coverageData, $this);
         unlink($coverageFile);
     }
     $result->endTest($this, $time);
     // Do not invoke PEAR's destructor mechanism for PHP 4
     // as it raises an E_STRICT.
     if ($pearDestructorObjectListCount == 0) {
         unset($GLOBALS['_PEAR_destructor_object_list']);
     } else {
         $count = count($GLOBALS['_PEAR_destructor_object_list']) - $pearDestructorObjectListCount;
         for ($i = 0; $i < $count; $i++) {
             array_pop($GLOBALS['_PEAR_destructor_object_list']);
         }
     }
     return $result;
 }

 /**
  * Creates the appropriate exception for the constraint which can be caught
  * by the unit test system. This can be called if a call to evaluate() fails.
  *
  * @param   mixed   $other The value passed to evaluate() which failed the
  *                         constraint check.
  * @param   string  $description A string with extra description of what was
  *                               going on while the evaluation failed.
  * @param   boolean $not Flag to indicate negation.
  * @throws  PHPUnit_Framework_ExpectationFailedException
  */
 public function fail($other, $description, $not = false)
 {
     $failureDescription = sprintf('Failed asserting that image "%s" is similar to image "%s".', $other, $this->filename);
     if ($not) {
         $failureDescription = self::negate($failureDescription);
     }
     if (!empty($description)) {
         $failureDescription = $description . "\n" . $failureDescription;
     }
     if (!$not) {
         throw new PHPUnit_Framework_ExpectationFailedException($failureDescription, PHPUnit_Framework_ComparisonFailure::diffEqual($this->delta, $this->difference));
     } else {
         throw new PHPUnit_Framework_ExpectationFailedException($failureDescription);
     }
 }

 public function testComparisonErrorOverlapingMatches2()
 {
     $failure = PHPUnit_Framework_ComparisonFailure::diffEqual('abcdde', 'abcde');
     $this->assertEquals("expected string <abcdde>\ndifference      <    x?>\ngot string      <abcde>", $failure->toString());
 }

 /**
  * Returns a string describing the difference between the expected and the
  * actual array.
  *
  * @note Diffing is only done for one level.
  */
 public function toString()
 {
     if ($this->hasDiff()) {
         return $this->diff(print_r($this->expected, TRUE), print_r($this->actual, TRUE));
     }
     $expectedOnly = array();
     $actualOnly = array();
     $diff = '';
     foreach ($this->expected as $expectedKey => $expectedValue) {
         if (!array_key_exists($expectedKey, $this->actual)) {
             $expectedOnly[] = $expectedKey;
             continue;
         }
         if ($expectedValue === $this->actual[$expectedKey]) {
             continue;
         }
         $diffObject = PHPUnit_Framework_ComparisonFailure::diffIdentical($expectedValue, $this->actual[$expectedKey], $this->message . "array key <{$expectedKey}>: ");
         $diff .= $diffObject->toString() . "\n";
     }
     foreach ($this->actual as $actualKey => $actualValue) {
         if (!array_key_exists($actualKey, $this->expected)) {
             $actualOnly[] = $actualKey;
             continue;
         }
     }
     foreach ($expectedOnly as $expectedKey) {
         $expectedValue = $this->expected[$expectedKey];
         $diff .= "array key <{$expectedKey}>: only in expected <{$expectedValue}>\n";
     }
     foreach ($actualOnly as $actualKey) {
         $actualValue = $this->actual[$actualKey];
         $diff .= "array key <{$actualKey}>: only in actual <{$actualValue}>\n";
     }
     return $diff;
 }

 /**
  * @covers PHPUnit_Framework_ComparisonFailure::diffEqual
  */
 public function testComparisonErrorOverlapingMatches2()
 {
     $failure = PHPUnit_Framework_ComparisonFailure::diffEqual('abcdde', 'abcde');
     $this->assertEquals("--- Expected\n+++ Actual\n@@ @@\n-abcdde\n+abcde", $failure->toString());
 }

 /**
  * Initialises with the expected value and the actual value.
  *
  * @param mixed $expected Expected value retrieved.
  * @param mixed $actual Actual value retrieved.
  * @param string $message A string which is prefixed on all returned lines
  *                       in the difference output.
  * @param boolean $expectedIsType
  */
 public function __construct($expected, $actual, $message = '', $expectedIsType = FALSE)
 {
     parent::__construct($expected, $actual, $message);
     $this->expectedIsType = $expectedIsType;
 }

 public static function hasDiff()
 {
     if (self::$hasDiff === NULL) {
         self::$hasDiff = FALSE;
         $binary = 'diff';
         if (substr(php_uname('s'), 0, 7) == 'Windows') {
             $binary .= '.exe';
         }
         if (isset($_ENV['PATH'])) {
             $paths = explode(PATH_SEPARATOR, $_ENV['PATH']);
         } else {
             if (isset($_SERVER['PATH'])) {
                 $paths = explode(PATH_SEPARATOR, $_SERVER['PATH']);
             } else {
                 $paths = array();
             }
         }
         foreach ($paths as $path) {
             if (file_exists($path . DIRECTORY_SEPARATOR . $binary) && is_executable($path . DIRECTORY_SEPARATOR . $binary)) {
                 self::$hasDiff = TRUE;
                 break;
             }
         }
     }
     return self::$hasDiff;
 }