public function __construct(string $className, string $methodName, int $paramIndex)
{
parent::__construct();
$this->className = $className;
$this->methodName = $methodName;
$this->paramIndex = $paramIndex;
}
/**
* Creates NumArrayEqual
*
* @param \NumPHP\Core\NumArray $value expected NumArray
*
* @since 1.0.0
*/
public function __construct(NumArray $value)
{
parent::__construct();
$this->value = clone $value;
// flush the cache
$this->value->flushCache();
}
/**
* Constructor
*
* @param string $header Cache debug header; defaults to X-Cache-Debug
*/
public function __construct($header = null)
{
if ($header) {
$this->header = $header;
}
parent::__construct();
}
/**
* @param object $schema
* @param string|null $context
*/
public function __construct($schema, $context = null)
{
parent::__construct();
$this->schema = $schema;
$this->context = $context ?: 'schema';
$this->validator = new Validator($this->context);
}
/**
* @param mixed $value
* @param bool $checkForObjectIdentity
* @param bool $checkForNonObjectIdentity
*/
public function __construct($value, bool $checkForObjectIdentity = true, bool $checkForNonObjectIdentity = false)
{
parent::__construct();
$this->checkForObjectIdentity = $checkForObjectIdentity;
$this->checkForNonObjectIdentity = $checkForNonObjectIdentity;
$this->value = $value;
}
/**
* JsonValueMatches constructor.
*
* @param string $jsonPath The JSON path that identifies the value(s)
* in the JSON document that the constraint
* should match
* @param Constraint $constraint The actual constraint that the selected
* value(s) must match
* @param bool $matchAll This flag controls how this constraint
* handles multiple values. Usually, this
* constraint will match successfully, when
* (at least) one found value matches the
* given constraint. When this flag is set,
* _all_ found values must match the
* constraint.
*/
public function __construct($jsonPath, Constraint $constraint, $matchAll = false)
{
parent::__construct();
$this->jsonPath = $jsonPath;
$this->constraint = $constraint;
$this->matchAll = $matchAll;
}
public function __construct($expected, $mainProperty, $secondaryProperty)
{
parent::__construct();
$this->expected = is_array($expected) ? $expected : [$expected];
$this->mainProperty = $mainProperty;
$this->secondaryProperty = $secondaryProperty;
}
/**
* @param int|string $permissions
*/
public function __construct($permissions)
{
parent::__construct();
if (is_string($permissions)) {
if (!ctype_digit($permissions)) {
if (1 !== preg_match(self::$permissionFormat, $permissions)) {
throw new \InvalidArgumentException(sprintf('Permission to match "%s" is not formatted correctly.', $permissions));
}
$this->permissions = $permissions;
return;
}
if ('0' === $permissions[0]) {
$permissions = intval($permissions, 8);
} else {
$permissions = (int) $permissions;
}
}
if (!is_int($permissions)) {
if (is_object($permissions)) {
$type = sprintf('%s#%s', get_class($permissions), method_exists($permissions, '__toString') ? $permissions->__toString() : '');
} elseif (null === $permissions) {
$type = 'null';
} else {
$type = gettype($permissions) . '#' . $permissions;
}
throw new \InvalidArgumentException(sprintf('Invalid value for permission to match "%s", expected int >= 0 or string.', $type));
}
if ($permissions < 0) {
throw new \InvalidArgumentException(sprintf('Invalid value for permission to match "%d", expected >= 0.', $permissions));
}
$this->permissions = $permissions;
}
/**
* @param int $type
*/
public function __construct($type)
{
parent::__construct();
switch ($type) {
case self::TYPE_BOOL:
$this->testFunction = 'is_bool';
$this->type = 'bool';
break;
case self::TYPE_INT:
$this->testFunction = 'is_int';
$this->type = 'int';
break;
case self::TYPE_STRING:
$this->testFunction = 'is_string';
$this->type = 'string';
break;
case self::TYPE_FLOAT:
$this->testFunction = 'is_float';
$this->type = 'float';
break;
case self::TYPE_ARRAY:
$this->testFunction = 'is_array';
$this->type = 'array';
break;
case self::TYPE_SCALAR:
$this->testFunction = 'is_scalar';
$this->type = 'scalar';
break;
default:
throw new \InvalidArgumentException(sprintf('Unknown ScalarConstraint type "%s" provided.', is_object($type) ? get_class($type) : (null === $type ? 'null' : gettype($type) . '#' . $type)));
}
}
public function __construct($expected, $mainProperty, $secondaryProperty)
{
parent::__construct();
$this->expected = $expected;
$this->mainProperty = $mainProperty;
$this->secondaryProperty = $secondaryProperty;
}
/**
* @param int|float $lowerBoundary
* @param int|float $upperBoundary
* @param bool $onBoundary pass if value is same as a boundary value, or false; value must be within the boundaries values
*/
public function __construct($lowerBoundary, $upperBoundary, $onBoundary)
{
parent::__construct();
$this->lowerBoundary = $lowerBoundary;
$this->upperBoundary = $upperBoundary;
$this->onBoundary = $onBoundary;
}
/**
* Construct the class.
*
* @since 0.1.0
*
* @param string $table
* @param string $column
* @param string $prefix
*/
public function __construct($table, $column, $prefix)
{
parent::__construct();
$this->table = esc_sql($table);
$this->column = esc_sql($column);
$this->prefix = $prefix;
}
public function __construct(array $constraints, $autoConfigureGroups = true, $implicitGroupName = null)
{
parent::__construct();
$this->constraintTypes = array_filter($constraints, 'is_string');
$this->constraints = array_filter($constraints, 'is_object');
$this->autoConfigureGroups = $autoConfigureGroups;
$this->implicitGroupName = $implicitGroupName;
}
/**
* @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;
}
/**
* @param string $expectedCommand The expected, executed command substring
*/
public function __construct($expectedCommand)
{
if (!is_string($expectedCommand)) {
throw new \InvalidArgumentException('Expected command should be a string, ' . gettype($expectedCommand) . ' given');
}
$this->expectedCommand = $expectedCommand;
parent::__construct();
}
/**
* @param SchemaManager $schemaManager
* @param string $path Swagger path template.
* @param string $httpMethod
* @param int $httpCode
*/
public function __construct(SchemaManager $schemaManager, $path, $httpMethod, $httpCode)
{
parent::__construct();
$this->schemaManager = $schemaManager;
$this->path = $path;
$this->httpMethod = $httpMethod;
$this->httpCode = $httpCode;
}
public function __construct($value)
{
parent::__construct();
if (!is_string($value)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
}
$this->value = $value;
}
/**
* @param PHPUnit_Framework_Constraint $constraint
*/
public function __construct($constraint)
{
parent::__construct();
if (!$constraint instanceof PHPUnit_Framework_Constraint) {
$constraint = new PHPUnit_Framework_Constraint_IsEqual($constraint);
}
$this->constraint = $constraint;
}
/**
* @param string $type
* @throws PHPUnit_Framework_Exception
*/
public function __construct($type)
{
parent::__construct();
if (!isset($this->types[$type])) {
throw new PHPUnit_Framework_Exception(sprintf('Type specified for PHPUnit_Framework_Constraint_IsType <%s> ' . 'is not a valid type.', $type));
}
$this->type = $type;
}
/**
* @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;
}
public function __construct($status)
{
parent::__construct();
if (!$status instanceof Constraint) {
$status = Assert::equalTo($status);
}
$this->status = $status;
}
/**
* @param array|ArrayAccess $value
* @throws PHPUnit_Framework_Exception
*/
public function __construct($value)
{
parent::__construct();
if (!(is_array($value) || $value instanceof ArrayAccess)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'array or ArrayAccess');
}
$this->value = $value;
}
/**
* @param mixed $value
* @param float $delta
* @param int $maxDepth
* @param bool $canonicalize
* @param bool $ignoreCase
*/
public function __construct($value, float $delta = 0.0, int $maxDepth = 10, bool $canonicalize = false, bool $ignoreCase = false)
{
parent::__construct();
$this->value = $value;
$this->delta = $delta;
$this->maxDepth = $maxDepth;
$this->canonicalize = $canonicalize;
$this->ignoreCase = $ignoreCase;
}
/**
* @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;
}
/**
* Construct the class.
*
* @since 0.1.0
*
* @param string $table
* @param string $column
* @param string $prefix
*/
public function __construct($table, $column, $prefix)
{
$this->table = esc_sql($table);
$this->column = esc_sql($column);
$this->prefix = $prefix;
// Back-compat for pre PHPUnit 4.0.0. See #14.
if (is_callable('parent::__construct')) {
parent::__construct();
}
}
/**
* @param string $type
* @param bool $isNativeType
*/
public function __construct($type, $isNativeType = true)
{
parent::__construct();
if ($isNativeType) {
$this->constraint = new PHPUnit_Framework_Constraint_IsType($type);
} else {
$this->constraint = new PHPUnit_Framework_Constraint_IsInstanceOf($type);
}
$this->type = $type;
}
/**
* JsonValueMatchesMany constructor.
*
* @param array $constraints A set of constraints. This is a key-value map
* where each key is a JSON path expression,
* associated with a constraint that all values
* matched by that expression must fulfill.
*/
public function __construct(array $constraints)
{
parent::__construct();
foreach ($constraints as $key => $constraint) {
if (!$constraint instanceof Constraint) {
$constraint = new \PHPUnit_Framework_Constraint_IsEqual($constraint);
}
$this->constraints[] = new JsonValueMatches($key, $constraint);
}
}
public function __construct($expected, $property, $comparisonOperator = '===')
{
parent::__construct();
$this->expected = $expected;
$this->property = $property;
$this->comparisonOperator = $comparisonOperator;
if (!in_array($comparisonOperator, $this->validOperators)) {
throw new Exception('Invalid operators: ' . $comparisonOperator);
}
}
public function __construct($name, $constraint = null)
{
parent::__construct();
if ($constraint === null) {
$constraint = Assert::logicalNot(Assert::isEmpty());
} elseif (!$constraint instanceof Constraint) {
$constraint = Assert::equalTo($constraint);
}
$this->name = strtolower($name);
$this->constraint = $constraint;
}
/**
* @param array $expectedSchemes
* @param string $host
* @param string $basePath
* @param string $template
* @param array $pathParams
* @param array $queryParams
*/
public function __construct(array $expectedSchemes, $host, $basePath, $template, array $pathParams, array $queryParams)
{
parent::__construct();
$this->allowedSchemes = array_map('strtolower', $expectedSchemes);
$this->host = $host;
$this->basePath = $basePath;
$this->template = $template;
$this->templateParams = array_map([$this, 'normalizeJsonSchema'], $pathParams);
$this->queryParams = array_map([$this, 'normalizeJsonSchema'], $queryParams);
$this->validator = new Validator('undefined');
}
