/**
* {@inheritdoc}
*
* @todo Improve output using diff when expected and actual arguments of a
* command do not match.
*/
public function toString()
{
$string = 'is a Redis command';
if ($this->commandID) {
$string .= " with ID '{$this->commandID}'";
}
if ($this->arguments) {
$string .= " and the following arguments:\n\n";
$string .= PHPUnit_Util_Type::export($this->arguments);
}
return $string;
}
/**
* @param PHPUnit_Framework_MockObject_Invocation $invocation
* @return the invocation of the Entry with matching parameters.
*/
public function invoke(PHPUnit_Framework_MockObject_Invocation $invocation)
{
foreach ($this->return_map as $entry) {
if ($entry->matches($invocation)) {
return $entry->invoke($invocation);
}
}
if ($this->default != NULL) {
return $this->default->invoke($invocation);
}
PHPUnit_Framework_Assert::fail(sprintf('No return value defined for %s', PHPUnit_Util_Type::export($invocation->parameters)));
}
public static function assertArraySameValues($expected, $actual)
{
$extra = array_diff($expected, $actual);
$missing = array_diff($actual, $expected);
CakeTestCase::assertSame($extra, $missing, "Got extra elements " . PHPUnit_Util_Type::export($extra) . " and some are elements missing " . PHPUnit_Util_Type::export($missing));
}
/**
* Asserts that two values are equal.
*
* @param mixed $expected The first value to compare
* @param mixed $actual The second value to compare
* @param float $delta The allowed numerical distance between two values to
* consider them equal
* @param bool $canonicalize If set to TRUE, arrays are sorted before
* comparison
* @param bool $ignoreCase If set to TRUE, upper- and lowercasing is
* ignored when comparing string values
* @throws PHPUnit_Framework_ComparisonFailure Thrown when the comparison
* fails. Contains information about the
* specific errors that lead to the failure.
*/
public function assertEquals($expected, $actual, $delta = 0, $canonicalize = FALSE, $ignoreCase = FALSE)
{
if (is_infinite($actual) && is_infinite($expected)) {
return;
}
if ((is_infinite($actual) xor is_infinite($expected)) || (is_nan($actual) or is_nan($expected)) || abs($actual - $expected) > $delta) {
throw new PHPUnit_Framework_ComparisonFailure($expected, $actual, '', '', FALSE, sprintf('Failed asserting that %s matches expected %s.', PHPUnit_Util_Type::export($actual), PHPUnit_Util_Type::export($expected)));
}
}
/**
* Asserts that two values are equal.
*
* @param mixed $expected The first value to compare
* @param mixed $actual The second value to compare
* @param float $delta The allowed numerical distance between two values to
* consider them equal
* @param bool $canonicalize If set to TRUE, arrays are sorted before
* comparison
* @param bool $ignoreCase If set to TRUE, upper- and lowercasing is
* ignored when comparing string values
* @throws PHPUnit_Framework_ComparisonFailure Thrown when the comparison
* fails. Contains information about the
* specific errors that lead to the failure.
*/
public function assertEquals($expected, $actual, $delta = 0, $canonicalize = FALSE, $ignoreCase = FALSE)
{
if ($actual != $expected) {
throw new PHPUnit_Framework_ComparisonFailure($expected, $actual, PHPUnit_Util_Type::export($expected), PHPUnit_Util_Type::export($actual));
}
}
/**
* Returns a string representation of the constraint.
*
* @return string
*/
public function toString()
{
if (is_string($this->value) && strpos($this->value, "\n") !== FALSE) {
return 'contains "' . $this->value . '"';
} else {
return 'contains ' . PHPUnit_Util_Type::export($this->value);
}
}
public function toString()
{
return sprintf('has items %s', PHPUnit_Util_Type::export($this->expected));
}
/**
* Send a command to the Selenium RC server and treat the result
* as a number.
*
* @param string $command
* @param array $arguments
* @return numeric
* @author Shin Ohno <*****@*****.**>
* @author Bjoern Schotte <*****@*****.**>
*/
protected function getNumber($command, array $arguments)
{
$result = $this->getString($command, $arguments);
if (!is_numeric($result)) {
throw new PHPUnit_Framework_Exception('Result is not numeric: ' . PHPUnit_Util_Type::export($result));
}
return $result;
}
/**
* Asserts that two values are equal.
*
* @param mixed $expected The first value to compare
* @param mixed $actual The second value to compare
* @param float $delta The allowed numerical distance between two values to
* consider them equal
* @param bool $canonicalize If set to TRUE, arrays are sorted before
* comparison
* @param bool $ignoreCase If set to TRUE, upper- and lowercasing is
* ignored when comparing string values
* @throws PHPUnit_Framework_ComparisonFailure Thrown when the comparison
* fails. Contains information about the
* specific errors that lead to the failure.
*/
public function assertEquals($expected, $actual, $delta = 0, $canonicalize = FALSE, $ignoreCase = FALSE)
{
$expectedToCompare = $expected;
$actualToCompare = $actual;
// always compare as strings to avoid strange behaviour
// otherwise 0 == 'Foobar'
if (is_string($expected) || is_string($actual)) {
$expectedToCompare = (string) $expectedToCompare;
$actualToCompare = (string) $actualToCompare;
if ($ignoreCase) {
$expectedToCompare = strtolower($expectedToCompare);
$actualToCompare = strtolower($actualToCompare);
}
}
if ($expectedToCompare != $actualToCompare) {
if (is_string($expected) && is_string($actual)) {
throw new PHPUnit_Framework_ComparisonFailure($expected, $actual, PHPUnit_Util_Type::export($expected), PHPUnit_Util_Type::export($actual), FALSE, 'Failed asserting that two strings are equal.');
}
throw new PHPUnit_Framework_ComparisonFailure($expected, $actual, '', '', FALSE, sprintf('Failed asserting that %s matches expected %s.', PHPUnit_Util_Type::export($actual), PHPUnit_Util_Type::export($expected)));
}
}
/**
* Asserts that two values are equal.
*
* @param mixed $expected The first value to compare
* @param mixed $actual The second value to compare
* @param float $delta The allowed numerical distance between two values to
* consider them equal
* @param bool $canonicalize If set to TRUE, arrays are sorted before
* comparison
* @param bool $ignoreCase If set to TRUE, upper- and lowercasing is
* ignored when comparing string values
*
* @throws PHPUnit_Framework_ComparisonFailure Thrown when the comparison
* fails. Contains information about the
* specific errors that lead to the failure.
*/
public function assertEquals($expected, $actual, $delta = 0, $canonicalize = false, $ignoreCase = false)
{
foreach ($actual as $object) {
if (!$expected->contains($object)) {
throw new PHPUnit_Framework_ComparisonFailure($expected, $actual, PHPUnit_Util_Type::export($expected), PHPUnit_Util_Type::export($actual), false, 'Failed asserting that two objects are equal.');
}
}
foreach ($expected as $object) {
if (!$actual->contains($object)) {
throw new PHPUnit_Framework_ComparisonFailure($expected, $actual, PHPUnit_Util_Type::export($expected), PHPUnit_Util_Type::export($actual), false, 'Failed asserting that two objects are equal.');
}
}
}
/**
* Returns a string representation of the constraint.
*
* @return string
*/
public function toString()
{
return 'has the same values with ' . PHPUnit_Util_Type::export($this->value);
}
/**
* Returns a string representation of the constraint.
*
* @return string
*/
public function toString()
{
return sprintf('%s Reason: %s', PHPUnit_Util_Type::export($this->value), $this->failure_reason);
}
public function toString()
{
return sprintf('equals ignoring whitespace %s', PHPUnit_Util_Type::export($this->normalize($this->expected)));
}
/**
* Asserts that two values are equal.
*
* @param mixed $expected The first value to compare
* @param mixed $actual The second value to compare
* @param float $delta The allowed numerical distance between two values to
* consider them equal
* @param bool $canonicalize If set to TRUE, arrays are sorted before
* comparison
* @param bool $ignoreCase If set to TRUE, upper- and lowercasing is
* ignored when comparing string values
* @throws PHPUnit_Framework_ComparisonFailure Thrown when the comparison
* fails. Contains information about the
* specific errors that lead to the failure.
*/
public function assertEquals($expected, $actual, $delta = 0, $canonicalize = FALSE, $ignoreCase = FALSE, array &$processed = array())
{
if ($canonicalize) {
sort($expected);
sort($actual);
}
$remaining = $actual;
$expString = $actString = "Array (\n";
$equal = TRUE;
foreach ($expected as $key => $value) {
unset($remaining[$key]);
if (!array_key_exists($key, $actual)) {
$expString .= sprintf(" %s => %s\n", PHPUnit_Util_Type::export($key), PHPUnit_Util_Type::shortenedExport($value));
$equal = FALSE;
continue;
}
try {
$this->factory->getComparatorFor($value, $actual[$key])->assertEquals($value, $actual[$key], $delta, $canonicalize, $ignoreCase, $processed);
$expString .= sprintf(" %s => %s\n", PHPUnit_Util_Type::export($key), PHPUnit_Util_Type::shortenedExport($value));
$actString .= sprintf(" %s => %s\n", PHPUnit_Util_Type::export($key), PHPUnit_Util_Type::shortenedExport($actual[$key]));
} catch (PHPUnit_Framework_ComparisonFailure $e) {
$expString .= sprintf(" %s => %s\n", PHPUnit_Util_Type::export($key), $e->getExpectedAsString() ? $this->indent($e->getExpectedAsString()) : PHPUnit_Util_Type::shortenedExport($e->getExpected()));
$actString .= sprintf(" %s => %s\n", PHPUnit_Util_Type::export($key), $e->getActualAsString() ? $this->indent($e->getActualAsString()) : PHPUnit_Util_Type::shortenedExport($e->getActual()));
$equal = FALSE;
}
}
foreach ($remaining as $key => $value) {
$actString .= sprintf(" %s => %s\n", PHPUnit_Util_Type::export($key), PHPUnit_Util_Type::shortenedExport($value));
$equal = FALSE;
}
$expString .= ')';
$actString .= ')';
if (!$equal) {
throw new PHPUnit_Framework_ComparisonFailure($expected, $actual, $expString, $actString, FALSE, 'Failed asserting that two arrays are equal.');
}
}
/**
* Returns a string representation of the constraint.
*
* @return string
*/
public function toString()
{
return 'has the key ' . PHPUnit_Util_Type::export($this->key);
}
/**
* @see \PHPUnit_Framework_Constraint::toString()
*/
public function toString()
{
return sprintf('has the key %s and its value %s', \PHPUnit_Util_Type::export($this->key), $this->constraint->toString());
}
/**
* Returns a string representation of the constraint.
*
* @return string
*/
public function toString()
{
if (is_object($this->value)) {
return 'is identical to an object of class "' . get_class($this->value) . '"';
} else {
return 'is identical to ' . PHPUnit_Util_Type::export($this->value);
}
}
public function toString()
{
return sprintf('raise user-specified exception %s', PHPUnit_Util_Type::export($this->exception));
}
/**
* Returns a string representation of the constraint.
*
* @return string
*/
public function toString()
{
$delta = '';
if (is_string($this->value)) {
if (strpos($this->value, "\n") !== FALSE) {
return 'is equal to <text>';
} else {
return sprintf('is equal to <string:%s>', $this->value);
}
} else {
if ($this->delta != 0) {
$delta = sprintf(' with delta <%F>', $this->delta);
}
return sprintf('is equal to %s%s', PHPUnit_Util_Type::export($this->value), $delta);
}
}
/**
* Asserts that two values are equal.
*
* @param mixed $expected The first value to compare
* @param mixed $actual The second value to compare
* @param float $delta The allowed numerical distance between two values to
* consider them equal
* @param bool $canonicalize If set to TRUE, arrays are sorted before
* comparison
* @param bool $ignoreCase If set to TRUE, upper- and lowercasing is
* ignored when comparing string values
* @throws PHPUnit_Framework_ComparisonFailure Thrown when the comparison
* fails. Contains information about the
* specific errors that lead to the failure.
*/
public function assertEquals($expected, $actual, $delta = 0, $canonicalize = FALSE, $ignoreCase = FALSE, array &$processed = array())
{
if (get_class($actual) !== get_class($expected)) {
throw new PHPUnit_Framework_ComparisonFailure(
$expected,
$actual,
PHPUnit_Util_Type::export($expected),
PHPUnit_Util_Type::export($actual),
FALSE,
sprintf(
'%s is not instance of expected class "%s".',
PHPUnit_Util_Type::export($actual),
get_class($expected)
)
);
}
// don't compare twice to allow for cyclic dependencies
if (in_array(array($actual, $expected), $processed, TRUE) ||
in_array(array($expected, $actual), $processed, TRUE)) {
return;
}
$processed[] = array($actual, $expected);
// don't compare objects if they are identical
// this helps to avoid the error "maximum function nesting level reached"
// CAUTION: this conditional clause is not tested
if ($actual !== $expected) {
try {
parent::assertEquals($this->toArray($expected), $this->toArray($actual), $delta, $canonicalize, $ignoreCase, $processed);
}
catch (PHPUnit_Framework_ComparisonFailure $e) {
throw new PHPUnit_Framework_ComparisonFailure(
$expected,
$actual,
// replace "Array" with "MyClass object"
substr_replace($e->getExpectedAsString(), get_class($expected).' Object', 0, 5),
substr_replace($e->getActualAsString(), get_class($actual).' Object', 0, 5),
FALSE,
'Failed asserting that two objects are equal.'
);
}
}
}
/**
* Returns the description of the failure
*
* The beginning of failure messages is "Failed asserting that" in most
* cases. This method should return the second part of that sentence.
*
* To provide additional failure information additionalFailureDescription
* can be used.
*
* @param mixed $other Evaluated value or object.
* @return string
*/
protected function failureDescription($other)
{
return PHPUnit_Util_Type::export($other) . ' ' . $this->toString();
}
/**
* Returns the description of the failure
*
* The beginning of failure messages is "Failed asserting that" in most
* cases. This method should return the second part of that sentence.
*
* @param mixed $other Evaluated value or object.
* @return string
*/
protected function failureDescription($other)
{
$code = method_exists($other, 'getMessageCode') ? $other->getMessageCode() : $other->getCode();
return sprintf('%s is equal to expected exception code %s', PHPUnit_Util_Type::export($code), PHPUnit_Util_Type::export($this->expectedCode));
}
public function toString()
{
return sprintf('return user-specified value %s', PHPUnit_Util_Type::export($this->value));
}
public function toString()
{
return sprintf('is equal to %s', PHPUnit_Util_Type::export($this->expected));
}
/**
* Returns the description of the failure
*
* The beginning of failure messages is "Failed asserting that" in most
* cases. This method should return the second part of that sentence.
*
* @param mixed $other Evaluated value or object.
* @return string
*/
protected function failureDescription($other)
{
return sprintf('%s is equal to expected exception code %s', PHPUnit_Util_Type::export($other->getCode()), PHPUnit_Util_Type::export($this->expectedCode));
}
/**
* @dataProvider provideNonBinaryMultibyteStrings
*/
public function testNonBinaryStringExport($value, $expectedLength)
{
$this->assertRegExp("~'.{{$expectedLength}}'\$~s", PHPUnit_Util_Type::export($value));
}
/**
* @dataProvider exportProvider
*/
public function testExport($value, $expected)
{
$this->assertSame($expected, self::trimnl(PHPUnit_Util_Type::export($value)));
}
/**
* Returns a string representation of the constraint.
*
* @return string
*/
public function toString()
{
return 'is greater than ' . PHPUnit_Util_Type::export($this->value);
}
/**
* Returns a string representation of the constraint.
*
* @return string
*/
public function toString()
{
return 'has the key ' . PHPUnit_Util_Type::export($this->key) . ' with the value ' . PHPUnit_Util_Type::export($this->value);
}