function getMatchers() { $readProperty = function ($object, $propertyName) { return EditorBuilderSpec::readProperty($object, $propertyName); }; return array('haveSearchStrategies' => function ($subject, $expected) use($readProperty) { $engine = $readProperty($subject, 'searchEngine'); $strategies = array_map('get_class', array_filter(call_user_func_array('array_merge', $readProperty($engine, 'searchStrategies')))); $constraint = new \PHPUnit_Framework_Constraint_IsEqual($expected); return $constraint->evaluate($strategies, '', true); }, 'haveCommands' => function ($subject, $expected) use($readProperty) { $commandInvoker = $readProperty($subject, 'commandInvoker'); $commands = array_map('get_class', $readProperty($commandInvoker, 'commands')); $constraint = new \PHPUnit_Framework_Constraint_IsEqual($expected); return $constraint->evaluate($commands, '', true); }, 'haveSearchStrategiesCount' => function ($subject, $expected) use($readProperty) { $engine = $readProperty($subject, 'searchEngine'); $count = array_reduce($readProperty($engine, 'searchStrategies'), function ($carry, $item) { return $carry + count($item); }); return $expected == $count; }, 'haveCommandCount' => function ($subject, $expected) use($readProperty) { $commandInvoker = $readProperty($subject, 'commandInvoker'); $commands = $readProperty($commandInvoker, 'commands'); return $expected == count($commands); }); }
public function matches($other, $description = '') { $description = $description ?: '$array'; if (!is_array($other)) { return false; } foreach ($this->pattern as $key => $expectedValue) { if (!array_key_exists($key, $other)) { return false; } $otherValue = $other[$key]; $description .= "['{$key}']"; if (is_array($expectedValue)) { $constraint = new static($expectedValue, $otherValue, $description); } elseif ($expectedValue instanceof \PHPUnit_Framework_Constraint) { $constraint = $expectedValue; } else { $constraint = new \PHPUnit_Framework_Constraint_IsEqual($expectedValue); } if (!$constraint->evaluate($otherValue, $description, true)) { return false; } } return true; }
/** * Evaluate * * @param \Closure $other * @param string $description Additional information about the test * @param bool $returnResult Whether to return a result or throw an exception * @return boolean */ public function evaluate($other, $description = '', $returnResult = FALSE) { if (!$other instanceof \Closure) { $this->_cause = 'Variable must be a Closure'; if ($returnResult) { return FALSE; } $this->fail($other, $description); } $reflection = new \ReflectionFunction($other); $requiredParameters = new \PHPUnit_Framework_Constraint_IsEqual(1); if (false === $requiredParameters->evaluate($reflection->getNumberOfRequiredParameters(), $description, true)) { $this->_cause = 'Closure does not have 1 required parameter'; if ($returnResult) { return FALSE; } $this->fail($other, $description); } $params = $reflection->getParameters(); $tokenParameter = $params[0]; /* @var $tokenParameter \ReflectionParameter */ $parameterType = new \PHPUnit_Framework_Constraint_IsEqual('PHP\\Manipulator\\Token'); if (false === $parameterType->evaluate($tokenParameter->getClass()->name, $description, true)) { $this->_cause = 'Closures Token-Parameter has wrong Typehint'; if ($returnResult) { return FALSE; } $this->fail($other, $description); } return true; }
public function compare($expected, $actual) { $constraint = new \PHPUnit_Framework_Constraint_IsEqual($expected); try { $constraint->evaluate($actual); throw new \Exception('Can not diff equal values'); } catch (\PHPUnit_Framework_ExpectationFailedException $e) { return $e->getComparisonFailure()->getDiff(); } }
private function evaluateArgumentValue(Definition $definition, $returnResult) { $actualValue = $definition->getArgument($this->argumentIndex); $constraint = new \PHPUnit_Framework_Constraint_IsEqual($this->expectedValue); if (!$constraint->evaluate($actualValue, '', true)) { if ($returnResult) { return false; } $this->fail($definition, sprintf('The value of argument with index %d (%s) is not equal to the expected value (%s)', $this->argumentIndex, $this->exporter->export($actualValue), $this->exporter->export($this->expectedValue))); } return true; }
private function evaluateParameterValue(ContainerInterface $container, $returnResult) { $actualValue = $container->getParameter($this->parameterName); $constraint = new \PHPUnit_Framework_Constraint_IsEqual($this->expectedParameterValue); if (!$constraint->evaluate($actualValue, '', true)) { if ($returnResult) { return false; } $this->fail($container, sprintf('The value of parameter "%s" (%s) does not match the expected value (%s)', $this->parameterName, $this->exporter->export($this->expectedParameterValue), $this->exporter->export($actualValue))); } return true; }
/** * @inheritdoc */ public function evaluate($other, $description = '', $returnResult = false) { if ($this->value === $other) { return true; } if ($this->value instanceof Equatable) { return $this->handleResult($this->value, $other, $this->value->equals($other), $description, $returnResult); } if ($other instanceof Equatable) { return $this->handleResult($this->value, $other, $other->equals($this->value), $description, $returnResult); } return parent::evaluate($other, $description, $returnResult); }
private function evaluateClass(ContainerBuilder $containerBuilder, $returnResult) { $definition = $containerBuilder->findDefinition($this->serviceId); $actualClass = $containerBuilder->getParameterBag()->resolveValue($definition->getClass()); $constraint = new \PHPUnit_Framework_Constraint_IsEqual($this->expectedClass); if (!$constraint->evaluate($actualClass, '', true)) { if ($returnResult) { return false; } $this->fail($containerBuilder, sprintf('The class of the service definition of "%s" (%s) does not match the expected value (%s)', $this->serviceId, $this->exporter->export($actualClass), $this->exporter->export($this->expectedClass))); } return true; }
/** * Evaluates the constraint for parameter $other * * If $shouldreturnesult is set to false (the default), an exception is thrown * in case of a failure. null is returned otherwise. * * If $shouldreturnesult is true, the result of the evaluation is returned as * a boolean value instead: true in case of success, false in case of a * failure. * * @param mixed $other Value or object to evaluate. * @param string $description Additional information about the test * @param bool $shouldreturnesult Whether to return a result or throw an exception * @return mixed * @throws PHPUnit_Framework_ExpectationFailedException */ public function evaluate($other, $description = '', $shouldreturnesult = false) { foreach ($this->keys as $key => $comparison) { if (isset($other->{$key}) || isset($this->value->{$key})) { // One of the keys is present, therefore run the comparison. PHPUnit_Framework_Assert::$comparison($this->value->{$key}, $other->{$key}); // Unset the keys, otherwise the standard evaluation will take place. unset($other->{$key}); unset($this->value->{$key}); } } // Run the parent evaluation (isEqual). return parent::evaluate($other, $description, $shouldreturnesult); }
public static function assertEqualsButIgnoreParameterIds($expected, $actual) { $comparator = new self(); $factory = ComparatorFactory::getInstance(); $comparator->setFactory($factory); $factory->register($comparator); $constraint = new \PHPUnit_Framework_Constraint_IsEqual($expected); try { $constraint->evaluate($actual, 'Queries must be equivalent'); } catch (\Exception $exception) { $factory->unregister($comparator); throw $exception; } $factory->unregister($comparator); }
private function evaluateServiceId(ContainerBuilder $containerBuilder, $returnResult) { $alias = $containerBuilder->getAlias($this->aliasId); /* * The aliases service id can be retrieved by casting the alias to a string, * see Alias::__toString() */ $actualServiceId = (string) $alias; $constraint = new \PHPUnit_Framework_Constraint_IsEqual(strtolower($this->expectedServiceId)); if (!$constraint->evaluate($actualServiceId, '', true)) { if ($returnResult) { return false; } $this->fail($containerBuilder, sprintf('"%s" is not an alias for "%s", but for "%s"', $this->aliasId, $this->expectedServiceId, $actualServiceId)); } return true; }
private function equalArguments($expectedArguments, $actualArguments) { $constraint = new \PHPUnit_Framework_Constraint_IsEqual($expectedArguments); return $constraint->evaluate($actualArguments, '', true); }
public function evaluate($other, $description = '', $returnResult = false) { $processedConfiguration = $this->processConfiguration($this->configurationValues); $constraint = new \PHPUnit_Framework_Constraint_IsEqual($other); return $constraint->evaluate($processedConfiguration, '', $returnResult); }
public function testConstraintIsEqual() { $constraint = new PHPUnit_Framework_Constraint_IsEqual(1); $this->assertFalse($constraint->evaluate(0)); $this->assertTrue($constraint->evaluate(1)); $this->assertEquals('is equal to <integer:1>', $constraint->toString()); try { $constraint->fail(0, ''); } catch (PHPUnit_Framework_ExpectationFailedException $e) { $this->assertEquals("Failed asserting that <integer:0> is equal to <integer:1>.", $e->getDescription()); return; } $this->fail(); }