/**
* Creates and returns an ExtendsOrImplements constraint.
*
* @param string[] $parentsAndInterfaces
*
* @return ExtendsOrImplements
* @throws \PHPUnit_Framework_Exception
*/
public static function extendsOrImplements($parentsAndInterfaces)
{
if (!is_array($parentsAndInterfaces)) {
throw \PHPUnit_Util_InvalidArgumentHelper::factory(1, 'array or ArrayAccess');
}
return new ExtendsOrImplements($parentsAndInterfaces);
}
/**
* @param array|ArrayAccess $value
* @throws PHPUnit_Framework_Exception
*/
public function __construct($value)
{
if (!(is_array($value) || $value instanceof ArrayAccess)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'array or ArrayAccess');
}
$this->value = $value;
}
/**
* @param \PHP\Manipulator\Tokenfinder\Result $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 Result) {
throw \PHPUnit_Util_InvalidArgumentHelper::factory(1, 'PHP\\Manipulator\\Tokenfinder\\Result');
}
$expectedResultTokens = $this->_expectedResult->getTokens();
$actualResultTokens = $other->getTokens();
if (count($expectedResultTokens) != count($actualResultTokens)) {
$this->_cause = 'length';
if ($returnResult) {
return FALSE;
}
$this->fail($other, $description);
}
foreach ($expectedResultTokens as $key => $token) {
if ($token !== $actualResultTokens[$key]) {
$this->_cause = 'missmatch of token: ' . $key;
if ($returnResult) {
return FALSE;
}
$this->fail($other, $description);
}
}
return true;
}
/**
* Defines if should use STDERR redirection or not.
*
* Then $stderrRedirection is TRUE, STDERR is redirected to STDOUT.
*
* @throws PHPUnit_Framework_Exception
*
* @param bool $stderrRedirection
*/
public function setUseStderrRedirection($stderrRedirection)
{
if (!is_bool($stderrRedirection)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'boolean');
}
$this->stderrRedirection = $stderrRedirection;
}
/** Checks the status code.
*
* @param Test_Browser $browser
*
* @throws InvalidArgumentException
* @return bool
*/
protected function matches($browser)
{
if (!$browser instanceof Test_Browser) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(0, 'Test_Browser');
}
return $this->_equal === in_array($browser->getResponse()->getStatusCode(), $this->_expected);
}
/** Checks the status code.
*
* @param sfForm $form
*
* @return bool
*/
protected function matches($form)
{
if (!$form instanceof sfForm) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(0, 'Test_Browser');
}
return $form->isValid() == $this->_expected;
}
/**
* Creates and returns an DefaultAttributesValues constraint.
*
* @param array $defaultAttributes
*
* @return DefaultAttributesValues
* @throws \PHPUnit_Framework_Exception
*/
public static function defaultAttributesValues($defaultAttributes)
{
if (!is_array($defaultAttributes)) {
throw \PHPUnit_Util_InvalidArgumentHelper::factory(1, 'array or ArrayAccess');
}
return new DefaultAttributesValues($defaultAttributes);
}
/**
* Creates configuration constraint for config object
*
* @param Varien_Simplexml_Config $config
*/
public function __construct($constraint)
{
if (!$constraint instanceof Mage_PHPUnit_Constraint_Config_Interface) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'Mage_PHPUnit_Constraint_Config_Interface');
}
$this->constraint = $constraint;
}
public function setOs($os)
{
if (!is_string($os)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
}
$this->os = $os;
}
/**
* Creates and returns an UsesTraits constraint.
*
* @param string[] $traits
*
* @return UsesTraits
* @throws \PHPUnit_Framework_Exception
*/
public static function usesTraits($traits)
{
if (!is_array($traits)) {
throw \PHPUnit_Util_InvalidArgumentHelper::factory(1, 'array or ArrayAccess');
}
return new UsesTraits($traits);
}
/**
* Constraint for testing observer
* event definitions in configuration
*
* @param string $area
* @param string $eventName
* @param string $observerClassAlias
* @param string $observerMethod
* @param string|null $observerName
*/
public function __construct($area, $eventName, $observerClassAlias, $observerMethod, $type = self::TYPE_DEFINDED, $observerName = null)
{
if (empty($area) || !is_string($area)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string', $area);
}
if (empty($eventName) || !is_string($eventName)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string', $eventName);
}
if (empty($observerClassAlias) || !is_string($observerClassAlias)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(3, 'string', $observerClassAlias);
}
if (empty($observerMethod) || !is_string($observerMethod)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(4, 'string', $observerMethod);
}
if ($observerName !== null && !is_string($observerName)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(6, 'string', $observerName);
}
$this->_area = $area;
$this->_eventName = $eventName;
$this->_observerClassAlias = $observerClassAlias;
$this->_observerMethod = $observerMethod;
$this->_observerName = $observerName;
$expectedValue = $this->_observerClassAlias . '::' . $this->_observerMethod;
$nodePath = sprintf(self::XML_PATH_EVENTS, $this->_area, $this->_eventName);
parent::__construct($nodePath, $type, $expectedValue);
}
public static function regExp($pattern)
{
if (!is_string($pattern)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
}
return new PHPUnit_Framework_Constraint_PCREMatch($pattern);
}
/**
* @param \PHP\Manipulator\Token $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 Token) {
throw \PHPUnit_Util_InvalidArgumentHelper::factory(1, 'PHP\\Manipulator\\Token');
}
$expectedToken = $this->_expectedToken;
$equal = $this->_getEqualsConstraint($expectedToken->getValue());
if (!$equal->evaluate($other->getValue(), $description, true)) {
$this->_difference = 'values';
if ($returnResult) {
return FALSE;
}
$this->fail($other, $description);
}
$equal = $this->_getEqualsConstraint($expectedToken->getType());
if (!$equal->evaluate($other->getType(), $description, true)) {
$this->_difference = 'types';
if ($returnResult) {
return FALSE;
}
$this->fail($other, $description);
}
if (true === $this->_strict) {
$equal = $this->_getEqualsConstraint($expectedToken->getLinenumber());
if (!$equal->evaluate($other->getLinenumber(), $description, true)) {
$this->_difference = 'linenumber';
if ($returnResult) {
return FALSE;
}
$this->fail($other, $description);
}
}
return true;
}
/**
* @param \PHP\Manipulator\TokenContainer $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 TokenContainer) {
throw \PHPUnit_Util_InvalidArgumentHelper::factory(1, 'PHP\\Manipulator\\TokenContainer');
}
$expectedIterator = $this->_expectedContainer->getIterator();
$actualIterator = $other->getIterator();
$i = 0;
while ($expectedIterator->valid() && $actualIterator->valid()) {
$expectedToken = $expectedIterator->current();
/* @var $expectedToken PHP\Manipulator\Token */
$actualToken = $actualIterator->current();
/* @var $actualToken PHP\Manipulator\Token */
if (!$actualToken->equals($expectedToken, $this->_strict)) {
if ($returnResult) {
return FALSE;
}
$this->fail($other, $description);
}
$i++;
$expectedIterator->next();
$actualIterator->next();
}
if ($expectedIterator->valid() || $actualIterator->valid()) {
if ($returnResult) {
return FALSE;
}
$this->fail($other, $description);
}
return true;
}
/**
* Constraint constructor
*
* @param string $nodePath
* @param string $type
* @param mixed $expectedValue
* @throws PHPUnit_Framework_Exception
*/
public function __construct($nodePath, $type, $expectedValue = null)
{
if (empty($nodePath) || !is_string($nodePath)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string', $type);
}
$this->_nodePath = $nodePath;
parent::__construct($type, $expectedValue);
}
/**
* @param int $value
* @throws PHPUnit_Framework_Exception
*/
public function __construct($value)
{
if (!is_int($value)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'integer');
}
parent::__construct();
$this->value = $value;
}
public function __construct($value)
{
parent::__construct();
if (!is_string($value)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
}
$this->value = $value;
}
/**
* @param boolean $value
* @param mixed $checkForObjectIdentity
* @throws PHPUnit_Framework_Exception
*/
public function __construct($value, $checkForObjectIdentity = TRUE)
{
if (!is_bool($checkForObjectIdentity)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'boolean');
}
$this->checkForObjectIdentity = $checkForObjectIdentity;
$this->value = $value;
}
/**
* @param callable $callback
* @throws PHPUnit_Framework_Exception
*/
public function __construct($callback)
{
if (!is_callable($callback)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'callable');
}
parent::__construct();
$this->callback = $callback;
}
/**
* Response header assertion
*
* @param string $headerName
* @param string $type
* @param PHPUnit_Framework_Constraint $constraint
*/
public function __construct($headerName, $type, PHPUnit_Framework_Constraint $constraint = null)
{
if (empty($headerName) || !is_string($headerName)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string', $headerName);
}
$this->_expectedValueValidation += array(self::TYPE_CONSTRAINT => array(true, null, 'PHPUnit_Framework_Constraint'));
parent::__construct($type, $constraint);
$this->_headerName = $headerName;
}
/**
* @param PHPUnit_Framework_Test $test
* @param int $timesRepeat
* @param bool $processIsolation
* @throws PHPUnit_Framework_Exception
*/
public function __construct(PHPUnit_Framework_Test $test, int $timesRepeat = 1, $processIsolation = false)
{
if ($timesRepeat < 1) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'positive integer');
}
parent::__construct($test);
$this->timesRepeat = $timesRepeat;
$this->processIsolation = $processIsolation;
}
/**
* @param int $expected
* @param int $actual
*
* @throws PHPUnit_Framework_Exception
*/
public function __construct($expected, $actual)
{
if (!is_int($expected)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'integer');
}
parent::__construct();
$this->expectedValue = $expected;
$this->actualValue = $actual;
}
/**
* @param PHPUnit_Framework_Constraint|string
* @throws PHPUnit_Framework_Constraint
*/
public function __construct($constraint)
{
if (!$constraint instanceof PHPUnit_Framework_Constraint) {
if (!is_string($constraint)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
}
$constraint = new PHPUnit_Framework_Constraint_IsEqual($constraint, 0, 10, FALSE, TRUE);
}
$this->constraint = $constraint;
}
/**
* Constructs a test case with the given filename.
*
* @param string $filename
* @throws PHPUnit_Framework_Exception
*/
public function __construct($filename)
{
if (!is_string($filename)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
}
if (!is_file($filename)) {
throw new PHPUnit_Framework_Exception(sprintf('File "%s" does not exist.', $filename));
}
$this->filename = $filename;
}
/**
* Constraint for evaluation of table alias
*
* @param string $tableAlias
* @param string $expectedTableName
* @param string $type
*/
public function __construct($tableAlias, $expectedTableName, $type = self::TYPE_TABLE_ALIAS)
{
if (!strpos($tableAlias, '/')) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'table alias', $tableAlias);
}
list($this->_tableAliasPrefix, $this->_tableAliasName) = explode('/', $tableAlias, 2);
$this->_expectedValueValidation += array(self::TYPE_TABLE_ALIAS => array(true, 'is_string', 'string'));
$this->_typesWithDiff[] = self::TYPE_TABLE_ALIAS;
parent::__construct(self::XML_PATH_MODELS, $type, $expectedTableName);
}
/**
* Constraint for checking JSON values
*
*
* @param string $type
* @param array $expectedValue expected json in array format
* @param string $matchType
*/
public function __construct($type, $expectedValue = null, $matchType = self::MATCH_AND)
{
if ($expectedValue !== null && (empty($matchType) || !is_string($matchType))) {
PHPUnit_Util_InvalidArgumentHelper::factory(3, 'string', $matchType);
}
$this->_expectedValueValidation += array(self::TYPE_MATCH => array(true, 'is_array', 'array'));
$this->_typesWithDiff[] = self::TYPE_MATCH;
parent::__construct($type, $expectedValue);
$this->_matchType = $matchType;
}
/**
* @param PHPUnit_Framework_Test $test
* @param int $timesRepeat
* @param bool $processIsolation
* @throws PHPUnit_Framework_Exception
*/
public function __construct(PHPUnit_Framework_Test $test, $timesRepeat = 1, $processIsolation = false)
{
parent::__construct($test);
if (is_integer($timesRepeat) && $timesRepeat >= 0) {
$this->timesRepeat = $timesRepeat;
} else {
throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'positive integer');
}
$this->processIsolation = $processIsolation;
}
/**
* Block property constraint
*
* @return boolean
*/
public function __construct($blockName, $propertyName, PHPUnit_Framework_Constraint $constraint, $type = self::TYPE_CONSTRAINT)
{
if (empty($blockName) || !is_string($blockName)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string', $blockName);
}
if (empty($propertyName) || !is_string($propertyName)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string', $propertyName);
}
parent::__construct($type, $constraint);
$this->_blockName = $blockName;
$this->_propertyName = $propertyName;
}
/**
* Constructs a new TestSuite for .phpt test cases.
*
* @param string $directory
* @param array $options Array with ini settings for the php instance run,
* key being the name if the setting, value the ini value.
* @throws InvalidArgumentException
*/
public function __construct($directory, array $options = array())
{
if (is_string($directory) && is_dir($directory)) {
$this->setName($directory);
$iterator = File_Iterator_Factory::getFileIterator($directory, '.phpt');
foreach ($iterator as $testFile) {
$this->addTestFile($testFile->getPathname(), $options);
}
} else {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'directory name');
}
}
/**
* Constructs a new TestSuite for .phpt test cases.
*
* @param string $directory
* @throws PHPUnit_Framework_Exception
*/
public function __construct(string $directory)
{
if (!is_dir($directory)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'directory name');
}
$this->setName($directory);
$facade = new File_Iterator_Facade();
$files = $facade->getFilesAsArray($directory, '.phpt');
foreach ($files as $file) {
$this->addTestFile($file);
}
}