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'); }