pax_global_header 0000666 0000000 0000000 00000000064 13624547556 0014533 g ustar 00root root 0000000 0000000 52 comment=a24726b36482c1540d3e98c4f7bf5d9b2a51d9d8
php-webmozart-assert-1.7.0/ 0000775 0000000 0000000 00000000000 13624547556 0015636 5 ustar 00root root 0000000 0000000 php-webmozart-assert-1.7.0/.editorconfig 0000664 0000000 0000000 00000000236 13624547556 0020314 0 ustar 00root root 0000000 0000000 root = true
[*]
charset=utf-8
end_of_line=lf
trim_trailing_whitespace=true
insert_final_newline=true
indent_style=space
indent_size=4
[*.yml]
indent_size=2
php-webmozart-assert-1.7.0/.gitignore 0000664 0000000 0000000 00000000026 13624547556 0017624 0 ustar 00root root 0000000 0000000 vendor/
composer.lock
php-webmozart-assert-1.7.0/.styleci.yml 0000664 0000000 0000000 00000000276 13624547556 0020120 0 ustar 00root root 0000000 0000000 preset: symfony
finder:
exclude:
- "tests"
enabled:
- ordered_use
disabled:
- phpdoc_annotation_without_dot # This is still buggy: https://github.com/symfony/symfony/pull/19198
php-webmozart-assert-1.7.0/.travis.yml 0000664 0000000 0000000 00000002373 13624547556 0017754 0 ustar 00root root 0000000 0000000 language: php
branches:
only:
- master
cache:
directories:
- $HOME/.composer/cache/files
matrix:
include:
- php: 5.3
dist: precise
- php: 5.4
dist: trusty
- php: 5.5
dist: trusty
- php: 5.6
- php: 7.0
- php: 7.1
- php: 7.2
- php: 7.3
env:
- COVERAGE=yes
- ANALYSIS=yes
- php: 7.4
- php: hhvm-3.30
- php: nightly
allow_failures:
- php: nightly
fast_finish: true
before_install:
- if [[ $COVERAGE != yes ]]; then phpenv config-rm xdebug.ini || true; fi;
install:
- if [[ $TRAVIS_PHP_VERSION = hhvm-3.30 ]]; then composer require phpunit/phpunit:4.8.36 --dev; fi
- export COMPOSER_FLAGS="--prefer-dist --no-interaction"
- if [[ $TRAVIS_PHP_VERSION = nightly ]]; then export COMPOSER_FLAGS="$COMOPSER_FLAGS --ignore-platform-reqs"; fi
- composer update $COMPOSER_FLAGS
script:
- if [[ $COVERAGE = yes ]]; then vendor/bin/phpunit --coverage-clover=coverage.clover; else vendor/bin/phpunit; fi
- if [[ $ANALYSIS = yes ]]; then composer i --working-dir=ci && ci/vendor/bin/psalm; fi
after_script:
- if [[ $COVERAGE = yes ]]; then wget https://scrutinizer-ci.com/ocular.phar && php ocular.phar code-coverage:upload --format=php-clover coverage.clover; fi
php-webmozart-assert-1.7.0/CHANGELOG.md 0000664 0000000 0000000 00000007474 13624547556 0017463 0 ustar 00root root 0000000 0000000 Changelog
=========
## UNRELEASED
## 1.7.0 (2020-02-14)
### Added
* added `Assert::notFalse()`
* added `Assert::isAOf()`
* added `Assert::isAnyOf()`
* added `Assert::isNotA()`
## 1.6.0 (2019-11-24)
### Added
* added `Assert::validArrayKey()`
* added `Assert::isNonEmptyList()`
* added `Assert::isNonEmptyMap()`
* added `@throws InvalidArgumentException` annotations to all methods that throw.
* added `@psalm-assert` for the list type to the `isList` assertion.
### Fixed
* `ResourceBundle` & `SimpleXMLElement` now pass the `isCountable` assertions.
They are countable, without implementing the `Countable` interface.
* The doc block of `range` now has the proper variables.
* An empty array will now pass `isList` and `isMap`. As it is a valid form of both.
If a non empty variant is needed, use `isNonEmptyList` or `isNonEmptyMap`.
### Changed
* Removed some `@psalm-assert` annotations, that were 'side effect' assertions See:
* [#144](https://github.com/webmozart/assert/pull/144)
* [#145](https://github.com/webmozart/assert/issues/145)
* [#146](https://github.com/webmozart/assert/pull/146)
* [#150](https://github.com/webmozart/assert/pull/150)
* If you use psalm, the minimum version needed is `3.6.0`. Which is enforced through a composer conflict.
If you don't use psalm, then this has no impact.
## 1.5.0 (2019-08-24)
### Added
* added `Assert::uniqueValues()`
* added `Assert::unicodeLetters()`
* added: `Assert::email()`
* added support for [Psalm](https://github.com/vimeo/psalm), by adding `@psalm-assert` annotations where appropriate.
### Fixed
* `Assert::endsWith()` would not give the correct result when dealing with multibyte suffix.
* `Assert::length(), minLength, maxLength, lengthBetween` would not give the correct result when dealing with multibyte characters.
**NOTE**: These 2 changes may break your assertions if you relied on the fact that multibyte characters didn't behave correctly.
### Changed
* The names of some variables have been updated to better reflect what they are.
* All function calls are now in their FQN form, slightly increasing performance.
* Tests are now properly ran against HHVM-3.30 and PHP nightly.
### Deprecation
* deprecated `Assert::isTraversable()` in favor of `Assert::isIterable()`
* This was already done in 1.3.0, but it was only done through a silenced `trigger_error`. It is now annotated as well.
## 1.4.0 (2018-12-25)
### Added
* added `Assert::ip()`
* added `Assert::ipv4()`
* added `Assert::ipv6()`
* added `Assert::notRegex()`
* added `Assert::interfaceExists()`
* added `Assert::isList()`
* added `Assert::isMap()`
* added polyfill for ctype
### Fixed
* Special case when comparing objects implementing `__toString()`
## 1.3.0 (2018-01-29)
### Added
* added `Assert::minCount()`
* added `Assert::maxCount()`
* added `Assert::countBetween()`
* added `Assert::isCountable()`
* added `Assert::notWhitespaceOnly()`
* added `Assert::natural()`
* added `Assert::notContains()`
* added `Assert::isArrayAccessible()`
* added `Assert::isInstanceOfAny()`
* added `Assert::isIterable()`
### Fixed
* `stringNotEmpty` will no longer report "0" is an empty string
### Deprecation
* deprecated `Assert::isTraversable()` in favor of `Assert::isIterable()`
## 1.2.0 (2016-11-23)
* added `Assert::throws()`
* added `Assert::count()`
* added extension point `Assert::reportInvalidArgument()` for custom subclasses
## 1.1.0 (2016-08-09)
* added `Assert::object()`
* added `Assert::propertyExists()`
* added `Assert::propertyNotExists()`
* added `Assert::methodExists()`
* added `Assert::methodNotExists()`
* added `Assert::uuid()`
## 1.0.2 (2015-08-24)
* integrated Style CI
* add tests for minimum package dependencies on Travis CI
## 1.0.1 (2015-05-12)
* added support for PHP 5.3.3
## 1.0.0 (2015-05-12)
* first stable release
## 1.0.0-beta (2015-03-19)
* first beta release
php-webmozart-assert-1.7.0/LICENSE 0000664 0000000 0000000 00000002074 13624547556 0016646 0 ustar 00root root 0000000 0000000 The MIT License (MIT)
Copyright (c) 2014 Bernhard Schussek
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
php-webmozart-assert-1.7.0/README.md 0000664 0000000 0000000 00000036561 13624547556 0017130 0 ustar 00root root 0000000 0000000 Webmozart Assert
================
[](https://travis-ci.org/webmozart/assert)
[](https://ci.appveyor.com/project/webmozart/assert/branch/master)
[](https://scrutinizer-ci.com/g/webmozart/assert/?branch=master)
[](https://packagist.org/packages/webmozart/assert)
[](https://packagist.org/packages/webmozart/assert)
This library contains efficient assertions to test the input and output of
your methods. With these assertions, you can greatly reduce the amount of coding
needed to write a safe implementation.
All assertions in the [`Assert`] class throw an `\InvalidArgumentException` if
they fail.
FAQ
---
**What's the difference to [beberlei/assert]?**
This library is heavily inspired by Benjamin Eberlei's wonderful [assert package],
but fixes a usability issue with error messages that can't be fixed there without
breaking backwards compatibility.
This package features usable error messages by default. However, you can also
easily write custom error messages:
```
Assert::string($path, 'The path is expected to be a string. Got: %s');
```
In [beberlei/assert], the ordering of the `%s` placeholders is different for
every assertion. This package, on the contrary, provides consistent placeholder
ordering for all assertions:
* `%s`: The tested value as string, e.g. `"/foo/bar"`.
* `%2$s`, `%3$s`, ...: Additional assertion-specific values, e.g. the
minimum/maximum length, allowed values, etc.
Check the source code of the assertions to find out details about the additional
available placeholders.
Installation
------------
Use [Composer] to install the package:
```
$ composer require webmozart/assert
```
Example
-------
```php
use Webmozart\Assert\Assert;
class Employee
{
public function __construct($id)
{
Assert::integer($id, 'The employee ID must be an integer. Got: %s');
Assert::greaterThan($id, 0, 'The employee ID must be a positive integer. Got: %s');
}
}
```
If you create an employee with an invalid ID, an exception is thrown:
```php
new Employee('foobar');
// => InvalidArgumentException:
// The employee ID must be an integer. Got: string
new Employee(-10);
// => InvalidArgumentException:
// The employee ID must be a positive integer. Got: -10
```
Assertions
----------
The [`Assert`] class provides the following assertions:
### Type Assertions
Method | Description
-------------------------------------------------------- | --------------------------------------------------
`string($value, $message = '')` | Check that a value is a string
`stringNotEmpty($value, $message = '')` | Check that a value is a non-empty string
`integer($value, $message = '')` | Check that a value is an integer
`integerish($value, $message = '')` | Check that a value casts to an integer
`float($value, $message = '')` | Check that a value is a float
`numeric($value, $message = '')` | Check that a value is numeric
`natural($value, $message= ''')` | Check that a value is a non-negative integer
`boolean($value, $message = '')` | Check that a value is a boolean
`scalar($value, $message = '')` | Check that a value is a scalar
`object($value, $message = '')` | Check that a value is an object
`resource($value, $type = null, $message = '')` | Check that a value is a resource
`isCallable($value, $message = '')` | Check that a value is a callable
`isArray($value, $message = '')` | Check that a value is an array
`isTraversable($value, $message = '')` (deprecated) | Check that a value is an array or a `\Traversable`
`isIterable($value, $message = '')` | Check that a value is an array or a `\Traversable`
`isCountable($value, $message = '')` | Check that a value is an array or a `\Countable`
`isInstanceOf($value, $class, $message = '')` | Check that a value is an `instanceof` a class
`isInstanceOfAny($value, array $classes, $message = '')` | Check that a value is an `instanceof` a at least one class on the array of classes
`notInstanceOf($value, $class, $message = '')` | Check that a value is not an `instanceof` a class
`isAOf($value, $class, $message = '')` | Check that a value is of the class or has one of its parents
`isAnyOf($value, array $classes, $message = '')` | Check that a value a at least one of the class or has one of its parents
`isNotA($value, $class, $message = '')` | Check that a value is not of the class or has not one of its parents
`isArrayAccessible($value, $message = '')` | Check that a value can be accessed as an array
`uniqueValues($values, $message = '')` | Check that the given array contains unique values
### Comparison Assertions
Method | Description
----------------------------------------------- | --------------------------------------------------
`true($value, $message = '')` | Check that a value is `true`
`false($value, $message = '')` | Check that a value is `false`
`notFalse($value, $message = '')` | Check that a value is not `false`
`null($value, $message = '')` | Check that a value is `null`
`notNull($value, $message = '')` | Check that a value is not `null`
`isEmpty($value, $message = '')` | Check that a value is `empty()`
`notEmpty($value, $message = '')` | Check that a value is not `empty()`
`eq($value, $value2, $message = '')` | Check that a value equals another (`==`)
`notEq($value, $value2, $message = '')` | Check that a value does not equal another (`!=`)
`same($value, $value2, $message = '')` | Check that a value is identical to another (`===`)
`notSame($value, $value2, $message = '')` | Check that a value is not identical to another (`!==`)
`greaterThan($value, $value2, $message = '')` | Check that a value is greater than another
`greaterThanEq($value, $value2, $message = '')` | Check that a value is greater than or equal to another
`lessThan($value, $value2, $message = '')` | Check that a value is less than another
`lessThanEq($value, $value2, $message = '')` | Check that a value is less than or equal to another
`range($value, $min, $max, $message = '')` | Check that a value is within a range
`oneOf($value, array $values, $message = '')` | Check that a value is one of a list of values
### String Assertions
You should check that a value is a string with `Assert::string()` before making
any of the following assertions.
Method | Description
--------------------------------------------------- | -----------------------------------------------------------------
`contains($value, $subString, $message = '')` | Check that a string contains a substring
`notContains($value, $subString, $message = '')` | Check that a string does not contains a substring
`startsWith($value, $prefix, $message = '')` | Check that a string has a prefix
`startsWithLetter($value, $message = '')` | Check that a string starts with a letter
`endsWith($value, $suffix, $message = '')` | Check that a string has a suffix
`regex($value, $pattern, $message = '')` | Check that a string matches a regular expression
`notRegex($value, $pattern, $message = '')` | Check that a string does not match a regular expression
`unicodeLetters($value, $message = '')` | Check that a string contains Unicode letters only
`alpha($value, $message = '')` | Check that a string contains letters only
`digits($value, $message = '')` | Check that a string contains digits only
`alnum($value, $message = '')` | Check that a string contains letters and digits only
`lower($value, $message = '')` | Check that a string contains lowercase characters only
`upper($value, $message = '')` | Check that a string contains uppercase characters only
`length($value, $length, $message = '')` | Check that a string has a certain number of characters
`minLength($value, $min, $message = '')` | Check that a string has at least a certain number of characters
`maxLength($value, $max, $message = '')` | Check that a string has at most a certain number of characters
`lengthBetween($value, $min, $max, $message = '')` | Check that a string has a length in the given range
`uuid($value, $message = '')` | Check that a string is a valid UUID
`ip($value, $message = '')` | Check that a string is a valid IP (either IPv4 or IPv6)
`ipv4($value, $message = '')` | Check that a string is a valid IPv4
`ipv6($value, $message = '')` | Check that a string is a valid IPv6
`email($value, $message = '')` | Check that a string is a valid e-mail address
`notWhitespaceOnly($value, $message = '')` | Check that a string contains at least one non-whitespace character
### File Assertions
Method | Description
----------------------------------- | --------------------------------------------------
`fileExists($value, $message = '')` | Check that a value is an existing path
`file($value, $message = '')` | Check that a value is an existing file
`directory($value, $message = '')` | Check that a value is an existing directory
`readable($value, $message = '')` | Check that a value is a readable path
`writable($value, $message = '')` | Check that a value is a writable path
### Object Assertions
Method | Description
----------------------------------------------------- | --------------------------------------------------
`classExists($value, $message = '')` | Check that a value is an existing class name
`subclassOf($value, $class, $message = '')` | Check that a class is a subclass of another
`interfaceExists($value, $message = '')` | Check that a value is an existing interface name
`implementsInterface($value, $class, $message = '')` | Check that a class implements an interface
`propertyExists($value, $property, $message = '')` | Check that a property exists in a class/object
`propertyNotExists($value, $property, $message = '')` | Check that a property does not exist in a class/object
`methodExists($value, $method, $message = '')` | Check that a method exists in a class/object
`methodNotExists($value, $method, $message = '')` | Check that a method does not exist in a class/object
### Array Assertions
Method | Description
-------------------------------------------------- | ------------------------------------------------------------------
`keyExists($array, $key, $message = '')` | Check that a key exists in an array
`keyNotExists($array, $key, $message = '')` | Check that a key does not exist in an array
`validArrayKey($key, $message = '')` | Check that a value is a valid array key (int or string)
`count($array, $number, $message = '')` | Check that an array contains a specific number of elements
`minCount($array, $min, $message = '')` | Check that an array contains at least a certain number of elements
`maxCount($array, $max, $message = '')` | Check that an array contains at most a certain number of elements
`countBetween($array, $min, $max, $message = '')` | Check that an array has a count in the given range
`isList($array, $message = '')` | Check that an array is a non-associative list
`isNonEmptyList($array, $message = '')` | Check that an array is a non-associative list, and not empty
`isMap($array, $message = '')` | Check that an array is associative and has strings as keys
`isNonEmptyMap($array, $message = '')` | Check that an array is associative and has strings as keys, and is not empty
### Function Assertions
Method | Description
------------------------------------------- | -----------------------------------------------------------------------------------------------------
`throws($closure, $class, $message = '')` | Check that a function throws a certain exception. Subclasses of the exception class will be accepted.
### Collection Assertions
All of the above assertions can be prefixed with `all*()` to test the contents
of an array or a `\Traversable`:
```php
Assert::allIsInstanceOf($employees, 'Acme\Employee');
```
### Nullable Assertions
All of the above assertions can be prefixed with `nullOr*()` to run the
assertion only if it the value is not `null`:
```php
Assert::nullOrString($middleName, 'The middle name must be a string or null. Got: %s');
```
### Extending Assert
The `Assert` class comes with a few methods, which can be overridden to change the class behaviour. You can also extend it to
add your own assertions.
#### Overriding methods
Overriding the following methods in your assertion class allows you to change the behaviour of the assertions:
* `public static function __callStatic($name, $arguments)`
* This method is used to 'create' the `nullOr` and `all` versions of the assertions.
* `protected static function valueToString($value)`
* This method is used for error messages, to convert the value to a string value for displaying. You could use this for representing a value object with a `__toString` method for example.
* `protected static function typeToString($value)`
* This method is used for error messages, to convert the a value to a string representing its type.
* `protected static function strlen($value)`
* This method is used to calculate string length for relevant methods, using the `mb_strlen` if available and useful.
* `protected static function reportInvalidArgument($message)`
* This method is called when an assertion fails, with the specified error message. Here you can throw your own exception, or log something.
Authors
-------
* [Bernhard Schussek] a.k.a. [@webmozart]
* [The Community Contributors]
Contribute
----------
Contributions to the package are always welcome!
* Report any bugs or issues you find on the [issue tracker].
* You can grab the source code at the package's [Git repository].
License
-------
All contents of this package are licensed under the [MIT license].
[beberlei/assert]: https://github.com/beberlei/assert
[assert package]: https://github.com/beberlei/assert
[Composer]: https://getcomposer.org
[Bernhard Schussek]: https://webmozarts.com
[The Community Contributors]: https://github.com/webmozart/assert/graphs/contributors
[issue tracker]: https://github.com/webmozart/assert/issues
[Git repository]: https://github.com/webmozart/assert
[@webmozart]: https://twitter.com/webmozart
[MIT license]: LICENSE
[`Assert`]: src/Assert.php
php-webmozart-assert-1.7.0/appveyor.yml 0000664 0000000 0000000 00000001444 13624547556 0020231 0 ustar 00root root 0000000 0000000 build: false
platform: x86
clone_folder: c:\projects\webmozart\assert
branches:
only:
- master
init:
- SET PATH=c:\php;%PATH%
- SET COMPOSER_NO_INTERACTION=1
- SET PHP=1
cache:
- '%LOCALAPPDATA%\Composer\files'
install:
- ps: Set-Service wuauserv -StartupType Manual
- cinst -y php composer
- refreshenv
- cd c:\tools\php74
- copy php.ini-production php.ini /Y
- echo date.timezone="UTC" >> php.ini
- echo extension_dir=ext >> php.ini
- echo extension=php_openssl.dll >> php.ini
- echo extension=php_mbstring.dll >> php.ini
- echo extension=php_curl.dll >> php.ini
- echo memory_limit=3G >> php.ini
- cd %APPVEYOR_BUILD_FOLDER%
- composer install --no-interaction --no-progress
test_script:
- cd %APPVEYOR_BUILD_FOLDER%
- vendor\bin\phpunit.bat --verbose
php-webmozart-assert-1.7.0/ci/ 0000775 0000000 0000000 00000000000 13624547556 0016231 5 ustar 00root root 0000000 0000000 php-webmozart-assert-1.7.0/ci/composer.json 0000664 0000000 0000000 00000000073 13624547556 0020753 0 ustar 00root root 0000000 0000000 {
"require": {
"vimeo/psalm": "^3.8.5"
}
}
php-webmozart-assert-1.7.0/composer.json 0000664 0000000 0000000 00000001427 13624547556 0020364 0 ustar 00root root 0000000 0000000 {
"name": "webmozart/assert",
"description": "Assertions to validate method input/output with nice error messages.",
"keywords": [
"assert",
"check",
"validate"
],
"license": "MIT",
"authors": [
{
"name": "Bernhard Schussek",
"email": "bschussek@gmail.com"
}
],
"require": {
"php": "^5.3.3 || ^7.0",
"symfony/polyfill-ctype": "^1.8"
},
"require-dev": {
"phpunit/phpunit": "^4.8.36 || ^7.5.13"
},
"conflict": {
"vimeo/psalm": "<3.6.0"
},
"autoload": {
"psr-4": {
"Webmozart\\Assert\\": "src/"
}
},
"autoload-dev": {
"psr-4": {
"Webmozart\\Assert\\Tests\\": "tests/"
}
}
}
php-webmozart-assert-1.7.0/phpunit.xml.dist 0000664 0000000 0000000 00000001216 13624547556 0021011 0 ustar 00root root 0000000 0000000
./tests/
./tests/static-analysis
./src/
php-webmozart-assert-1.7.0/psalm.xml 0000664 0000000 0000000 00000000713 13624547556 0017475 0 ustar 00root root 0000000 0000000
php-webmozart-assert-1.7.0/src/ 0000775 0000000 0000000 00000000000 13624547556 0016425 5 ustar 00root root 0000000 0000000 php-webmozart-assert-1.7.0/src/Assert.php 0000664 0000000 0000000 00000171036 13624547556 0020407 0 ustar 00root root 0000000 0000000
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Webmozart\Assert;
use ArrayAccess;
use BadMethodCallException;
use Closure;
use Countable;
use Exception;
use InvalidArgumentException;
use ResourceBundle;
use SimpleXMLElement;
use Throwable;
use Traversable;
/**
* Efficient assertions to validate the input/output of your methods.
*
* @method static void nullOrString($value, $message = '')
* @method static void nullOrStringNotEmpty($value, $message = '')
* @method static void nullOrInteger($value, $message = '')
* @method static void nullOrIntegerish($value, $message = '')
* @method static void nullOrFloat($value, $message = '')
* @method static void nullOrNumeric($value, $message = '')
* @method static void nullOrNatural($value, $message = '')
* @method static void nullOrBoolean($value, $message = '')
* @method static void nullOrScalar($value, $message = '')
* @method static void nullOrObject($value, $message = '')
* @method static void nullOrResource($value, $type = null, $message = '')
* @method static void nullOrIsCallable($value, $message = '')
* @method static void nullOrIsArray($value, $message = '')
* @method static void nullOrIsTraversable($value, $message = '')
* @method static void nullOrIsArrayAccessible($value, $message = '')
* @method static void nullOrIsCountable($value, $message = '')
* @method static void nullOrIsIterable($value, $message = '')
* @method static void nullOrIsInstanceOf($value, $class, $message = '')
* @method static void nullOrNotInstanceOf($value, $class, $message = '')
* @method static void nullOrIsInstanceOfAny($value, $classes, $message = '')
* @method static void nullOrIsAOf($value, $classes, $message = '')
* @method static void nullOrIsAnyOf($value, $classes, $message = '')
* @method static void nullOrIsNotA($value, $classes, $message = '')
* @method static void nullOrIsEmpty($value, $message = '')
* @method static void nullOrNotEmpty($value, $message = '')
* @method static void nullOrTrue($value, $message = '')
* @method static void nullOrFalse($value, $message = '')
* @method static void nullOrNotFalse($value, $message = '')
* @method static void nullOrIp($value, $message = '')
* @method static void nullOrIpv4($value, $message = '')
* @method static void nullOrIpv6($value, $message = '')
* @method static void nullOrEmail($value, $message = '')
* @method static void nullOrUniqueValues($values, $message = '')
* @method static void nullOrEq($value, $expect, $message = '')
* @method static void nullOrNotEq($value, $expect, $message = '')
* @method static void nullOrSame($value, $expect, $message = '')
* @method static void nullOrNotSame($value, $expect, $message = '')
* @method static void nullOrGreaterThan($value, $limit, $message = '')
* @method static void nullOrGreaterThanEq($value, $limit, $message = '')
* @method static void nullOrLessThan($value, $limit, $message = '')
* @method static void nullOrLessThanEq($value, $limit, $message = '')
* @method static void nullOrRange($value, $min, $max, $message = '')
* @method static void nullOrOneOf($value, $values, $message = '')
* @method static void nullOrContains($value, $subString, $message = '')
* @method static void nullOrNotContains($value, $subString, $message = '')
* @method static void nullOrNotWhitespaceOnly($value, $message = '')
* @method static void nullOrStartsWith($value, $prefix, $message = '')
* @method static void nullOrStartsWithLetter($value, $message = '')
* @method static void nullOrEndsWith($value, $suffix, $message = '')
* @method static void nullOrRegex($value, $pattern, $message = '')
* @method static void nullOrNotRegex($value, $pattern, $message = '')
* @method static void nullOrUnicodeLetters($value, $message = '')
* @method static void nullOrAlpha($value, $message = '')
* @method static void nullOrDigits($value, $message = '')
* @method static void nullOrAlnum($value, $message = '')
* @method static void nullOrLower($value, $message = '')
* @method static void nullOrUpper($value, $message = '')
* @method static void nullOrLength($value, $length, $message = '')
* @method static void nullOrMinLength($value, $min, $message = '')
* @method static void nullOrMaxLength($value, $max, $message = '')
* @method static void nullOrLengthBetween($value, $min, $max, $message = '')
* @method static void nullOrFileExists($value, $message = '')
* @method static void nullOrFile($value, $message = '')
* @method static void nullOrDirectory($value, $message = '')
* @method static void nullOrReadable($value, $message = '')
* @method static void nullOrWritable($value, $message = '')
* @method static void nullOrClassExists($value, $message = '')
* @method static void nullOrSubclassOf($value, $class, $message = '')
* @method static void nullOrInterfaceExists($value, $message = '')
* @method static void nullOrImplementsInterface($value, $interface, $message = '')
* @method static void nullOrPropertyExists($value, $property, $message = '')
* @method static void nullOrPropertyNotExists($value, $property, $message = '')
* @method static void nullOrMethodExists($value, $method, $message = '')
* @method static void nullOrMethodNotExists($value, $method, $message = '')
* @method static void nullOrKeyExists($value, $key, $message = '')
* @method static void nullOrKeyNotExists($value, $key, $message = '')
* @method static void nullOrValidArrayKey($value, $message = '')
* @method static void nullOrCount($value, $key, $message = '')
* @method static void nullOrMinCount($value, $min, $message = '')
* @method static void nullOrMaxCount($value, $max, $message = '')
* @method static void nullOrIsList($value, $message = '')
* @method static void nullOrIsNonEmptyList($value, $message = '')
* @method static void nullOrIsMap($value, $message = '')
* @method static void nullOrIsNonEmptyMap($value, $message = '')
* @method static void nullOrCountBetween($value, $min, $max, $message = '')
* @method static void nullOrUuid($values, $message = '')
* @method static void nullOrThrows($expression, $class = 'Exception', $message = '')
* @method static void allString($values, $message = '')
* @method static void allStringNotEmpty($values, $message = '')
* @method static void allInteger($values, $message = '')
* @method static void allIntegerish($values, $message = '')
* @method static void allFloat($values, $message = '')
* @method static void allNumeric($values, $message = '')
* @method static void allNatural($values, $message = '')
* @method static void allBoolean($values, $message = '')
* @method static void allScalar($values, $message = '')
* @method static void allObject($values, $message = '')
* @method static void allResource($values, $type = null, $message = '')
* @method static void allIsCallable($values, $message = '')
* @method static void allIsArray($values, $message = '')
* @method static void allIsTraversable($values, $message = '')
* @method static void allIsArrayAccessible($values, $message = '')
* @method static void allIsCountable($values, $message = '')
* @method static void allIsIterable($values, $message = '')
* @method static void allIsInstanceOf($values, $class, $message = '')
* @method static void allNotInstanceOf($values, $class, $message = '')
* @method static void allIsInstanceOfAny($values, $classes, $message = '')
* @method static void allIsAOf($values, $class, $message = '')
* @method static void allIsAnyOf($values, $class, $message = '')
* @method static void allIsNotA($values, $class, $message = '')
* @method static void allNull($values, $message = '')
* @method static void allNotNull($values, $message = '')
* @method static void allIsEmpty($values, $message = '')
* @method static void allNotEmpty($values, $message = '')
* @method static void allTrue($values, $message = '')
* @method static void allFalse($values, $message = '')
* @method static void allNotFalse($values, $message = '')
* @method static void allIp($values, $message = '')
* @method static void allIpv4($values, $message = '')
* @method static void allIpv6($values, $message = '')
* @method static void allEmail($values, $message = '')
* @method static void allUniqueValues($values, $message = '')
* @method static void allEq($values, $expect, $message = '')
* @method static void allNotEq($values, $expect, $message = '')
* @method static void allSame($values, $expect, $message = '')
* @method static void allNotSame($values, $expect, $message = '')
* @method static void allGreaterThan($values, $limit, $message = '')
* @method static void allGreaterThanEq($values, $limit, $message = '')
* @method static void allLessThan($values, $limit, $message = '')
* @method static void allLessThanEq($values, $limit, $message = '')
* @method static void allRange($values, $min, $max, $message = '')
* @method static void allOneOf($values, $values, $message = '')
* @method static void allContains($values, $subString, $message = '')
* @method static void allNotContains($values, $subString, $message = '')
* @method static void allNotWhitespaceOnly($values, $message = '')
* @method static void allStartsWith($values, $prefix, $message = '')
* @method static void allStartsWithLetter($values, $message = '')
* @method static void allEndsWith($values, $suffix, $message = '')
* @method static void allRegex($values, $pattern, $message = '')
* @method static void allNotRegex($values, $pattern, $message = '')
* @method static void allUnicodeLetters($values, $message = '')
* @method static void allAlpha($values, $message = '')
* @method static void allDigits($values, $message = '')
* @method static void allAlnum($values, $message = '')
* @method static void allLower($values, $message = '')
* @method static void allUpper($values, $message = '')
* @method static void allLength($values, $length, $message = '')
* @method static void allMinLength($values, $min, $message = '')
* @method static void allMaxLength($values, $max, $message = '')
* @method static void allLengthBetween($values, $min, $max, $message = '')
* @method static void allFileExists($values, $message = '')
* @method static void allFile($values, $message = '')
* @method static void allDirectory($values, $message = '')
* @method static void allReadable($values, $message = '')
* @method static void allWritable($values, $message = '')
* @method static void allClassExists($values, $message = '')
* @method static void allSubclassOf($values, $class, $message = '')
* @method static void allInterfaceExists($values, $message = '')
* @method static void allImplementsInterface($values, $interface, $message = '')
* @method static void allPropertyExists($values, $property, $message = '')
* @method static void allPropertyNotExists($values, $property, $message = '')
* @method static void allMethodExists($values, $method, $message = '')
* @method static void allMethodNotExists($values, $method, $message = '')
* @method static void allKeyExists($values, $key, $message = '')
* @method static void allKeyNotExists($values, $key, $message = '')
* @method static void allValidArrayKey($values, $message = '')
* @method static void allCount($values, $key, $message = '')
* @method static void allMinCount($values, $min, $message = '')
* @method static void allMaxCount($values, $max, $message = '')
* @method static void allCountBetween($values, $min, $max, $message = '')
* @method static void allIsList($values, $message = '')
* @method static void allIsNonEmptyList($values, $message = '')
* @method static void allIsMap($values, $message = '')
* @method static void allIsNonEmptyMap($values, $message = '')
* @method static void allUuid($values, $message = '')
* @method static void allThrows($expressions, $class = 'Exception', $message = '')
*
* @since 1.0
*
* @author Bernhard Schussek
*/
class Assert
{
/**
* @psalm-assert string $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function string($value, $message = '')
{
if (!\is_string($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a string. Got: %s',
static::typeToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function stringNotEmpty($value, $message = '')
{
static::string($value, $message);
static::notEq($value, '', $message);
}
/**
* @psalm-assert int $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function integer($value, $message = '')
{
if (!\is_int($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an integer. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-assert numeric $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function integerish($value, $message = '')
{
if (!\is_numeric($value) || $value != (int) $value) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an integerish value. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-assert float $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function float($value, $message = '')
{
if (!\is_float($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a float. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-assert numeric $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function numeric($value, $message = '')
{
if (!\is_numeric($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a numeric. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-assert int $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function natural($value, $message = '')
{
if (!\is_int($value) || $value < 0) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a non-negative integer. Got %s',
static::valueToString($value)
));
}
}
/**
* @psalm-assert bool $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function boolean($value, $message = '')
{
if (!\is_bool($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a boolean. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-assert scalar $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function scalar($value, $message = '')
{
if (!\is_scalar($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a scalar. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-assert object $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function object($value, $message = '')
{
if (!\is_object($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an object. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-assert resource $value
*
* @param mixed $value
* @param string|null $type type of resource this should be. @see https://www.php.net/manual/en/function.get-resource-type.php
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function resource($value, $type = null, $message = '')
{
if (!\is_resource($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a resource. Got: %s',
static::typeToString($value)
));
}
if ($type && $type !== \get_resource_type($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a resource of type %2$s. Got: %s',
static::typeToString($value),
$type
));
}
}
/**
* @psalm-assert callable $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isCallable($value, $message = '')
{
if (!\is_callable($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a callable. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-assert array $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isArray($value, $message = '')
{
if (!\is_array($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an array. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-assert iterable $value
*
* @deprecated use "isIterable" or "isInstanceOf" instead
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isTraversable($value, $message = '')
{
@\trigger_error(
\sprintf(
'The "%s" assertion is deprecated. You should stop using it, as it will soon be removed in 2.0 version. Use "isIterable" or "isInstanceOf" instead.',
__METHOD__
),
\E_USER_DEPRECATED
);
if (!\is_array($value) && !($value instanceof Traversable)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a traversable. Got: %s',
static::typeToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isArrayAccessible($value, $message = '')
{
if (!\is_array($value) && !($value instanceof ArrayAccess)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an array accessible. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-assert countable $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isCountable($value, $message = '')
{
if (
!\is_array($value)
&& !($value instanceof Countable)
&& !($value instanceof ResourceBundle)
&& !($value instanceof SimpleXMLElement)
) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a countable. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-assert iterable $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isIterable($value, $message = '')
{
if (!\is_array($value) && !($value instanceof Traversable)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an iterable. Got: %s',
static::typeToString($value)
));
}
}
/**
* @psalm-template ExpectedType of object
* @psalm-param class-string $class
* @psalm-assert ExpectedType $value
*
* @param mixed $value
* @param string|object $class
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isInstanceOf($value, $class, $message = '')
{
if (!($value instanceof $class)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an instance of %2$s. Got: %s',
static::typeToString($value),
$class
));
}
}
/**
* @psalm-template ExpectedType of object
* @psalm-param class-string $class
* @psalm-assert !ExpectedType $value
*
* @param mixed $value
* @param string|object $class
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notInstanceOf($value, $class, $message = '')
{
if ($value instanceof $class) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an instance other than %2$s. Got: %s',
static::typeToString($value),
$class
));
}
}
/**
* @param mixed $value
* @param array $classes
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isInstanceOfAny($value, array $classes, $message = '')
{
foreach ($classes as $class) {
if ($value instanceof $class) {
return;
}
}
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an instance of any of %2$s. Got: %s',
static::typeToString($value),
\implode(', ', \array_map(array('static', 'valueToString'), $classes))
));
}
/**
* @param object|string $value
* @param string $class
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isAOf($value, $class, $message = '')
{
static::string($class, 'Expected class as a string. Got: %s');
if (!\is_a($value, $class, \is_string($value))) {
static::reportInvalidArgument(sprintf(
$message ?: 'Expected an instance of this class or to this class among his parents %2$s. Got: %s',
static::typeToString($value),
$class
));
}
}
/**
* @param object|string $value
* @param string $class
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isNotA($value, $class, $message = '')
{
static::string($class, 'Expected class as a string. Got: %s');
if (\is_a($value, $class, \is_string($value))) {
static::reportInvalidArgument(sprintf(
$message ?: 'Expected an instance of this class or to this class among his parents other than %2$s. Got: %s',
static::typeToString($value),
$class
));
}
}
/**
* @param object|string $value
* @param string[] $classes
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isAnyOf($value, array $classes, $message = '')
{
foreach ($classes as $class) {
static::string($class, 'Expected class as a string. Got: %s');
if (\is_a($value, $class, \is_string($value))) {
return;
}
}
static::reportInvalidArgument(sprintf(
$message ?: 'Expected an any of instance of this class or to this class among his parents other than %2$s. Got: %s',
static::typeToString($value),
\implode(', ', \array_map(array('static', 'valueToString'), $classes))
));
}
/**
* @psalm-assert empty $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isEmpty($value, $message = '')
{
if (!empty($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an empty value. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-assert !empty $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notEmpty($value, $message = '')
{
if (empty($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a non-empty value. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-assert null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function null($value, $message = '')
{
if (null !== $value) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected null. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-assert !null $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notNull($value, $message = '')
{
if (null === $value) {
static::reportInvalidArgument(
$message ?: 'Expected a value other than null.'
);
}
}
/**
* @psalm-assert true $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function true($value, $message = '')
{
if (true !== $value) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to be true. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-assert false $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function false($value, $message = '')
{
if (false !== $value) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to be false. Got: %s',
static::valueToString($value)
));
}
}
/**
* @psalm-assert !false $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notFalse($value, $message = '')
{
if (false === $value) {
static::reportInvalidArgument(
$message ?: 'Expected a value other than false.'
);
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function ip($value, $message = '')
{
if (false === \filter_var($value, \FILTER_VALIDATE_IP)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to be an IP. Got: %s',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function ipv4($value, $message = '')
{
if (false === \filter_var($value, \FILTER_VALIDATE_IP, \FILTER_FLAG_IPV4)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to be an IPv4. Got: %s',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function ipv6($value, $message = '')
{
if (false === \filter_var($value, \FILTER_VALIDATE_IP, \FILTER_FLAG_IPV6)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to be an IPv6. Got %s',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function email($value, $message = '')
{
if (false === \filter_var($value, FILTER_VALIDATE_EMAIL)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to be a valid e-mail address. Got %s',
static::valueToString($value)
));
}
}
/**
* Does non strict comparisons on the items, so ['3', 3] will not pass the assertion.
*
* @param array $values
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function uniqueValues(array $values, $message = '')
{
$allValues = \count($values);
$uniqueValues = \count(\array_unique($values));
if ($allValues !== $uniqueValues) {
$difference = $allValues - $uniqueValues;
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an array of unique values, but %s of them %s duplicated',
$difference,
(1 === $difference ? 'is' : 'are')
));
}
}
/**
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function eq($value, $expect, $message = '')
{
if ($expect != $value) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value equal to %2$s. Got: %s',
static::valueToString($value),
static::valueToString($expect)
));
}
}
/**
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notEq($value, $expect, $message = '')
{
if ($expect == $value) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a different value than %s.',
static::valueToString($expect)
));
}
}
/**
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function same($value, $expect, $message = '')
{
if ($expect !== $value) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value identical to %2$s. Got: %s',
static::valueToString($value),
static::valueToString($expect)
));
}
}
/**
* @param mixed $value
* @param mixed $expect
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notSame($value, $expect, $message = '')
{
if ($expect === $value) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value not identical to %s.',
static::valueToString($expect)
));
}
}
/**
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function greaterThan($value, $limit, $message = '')
{
if ($value <= $limit) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value greater than %2$s. Got: %s',
static::valueToString($value),
static::valueToString($limit)
));
}
}
/**
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function greaterThanEq($value, $limit, $message = '')
{
if ($value < $limit) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value greater than or equal to %2$s. Got: %s',
static::valueToString($value),
static::valueToString($limit)
));
}
}
/**
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function lessThan($value, $limit, $message = '')
{
if ($value >= $limit) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value less than %2$s. Got: %s',
static::valueToString($value),
static::valueToString($limit)
));
}
}
/**
* @param mixed $value
* @param mixed $limit
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function lessThanEq($value, $limit, $message = '')
{
if ($value > $limit) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value less than or equal to %2$s. Got: %s',
static::valueToString($value),
static::valueToString($limit)
));
}
}
/**
* Inclusive range, so Assert::(3, 3, 5) passes.
*
* @param mixed $value
* @param mixed $min
* @param mixed $max
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function range($value, $min, $max, $message = '')
{
if ($value < $min || $value > $max) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value between %2$s and %3$s. Got: %s',
static::valueToString($value),
static::valueToString($min),
static::valueToString($max)
));
}
}
/**
* Does strict comparison, so Assert::oneOf(3, ['3']) does not pass the assertion.
*
* @param mixed $value
* @param array $values
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function oneOf($value, array $values, $message = '')
{
if (!\in_array($value, $values, true)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected one of: %2$s. Got: %s',
static::valueToString($value),
\implode(', ', \array_map(array('static', 'valueToString'), $values))
));
}
}
/**
* @param mixed $value
* @param string $subString
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function contains($value, $subString, $message = '')
{
if (false === \strpos($value, $subString)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain %2$s. Got: %s',
static::valueToString($value),
static::valueToString($subString)
));
}
}
/**
* @param mixed $value
* @param string $subString
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notContains($value, $subString, $message = '')
{
if (false !== \strpos($value, $subString)) {
static::reportInvalidArgument(\sprintf(
$message ?: '%2$s was not expected to be contained in a value. Got: %s',
static::valueToString($value),
static::valueToString($subString)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notWhitespaceOnly($value, $message = '')
{
if (\preg_match('/^\s*$/', $value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a non-whitespace string. Got: %s',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $prefix
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function startsWith($value, $prefix, $message = '')
{
if (0 !== \strpos($value, $prefix)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to start with %2$s. Got: %s',
static::valueToString($value),
static::valueToString($prefix)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function startsWithLetter($value, $message = '')
{
static::string($value);
$valid = isset($value[0]);
if ($valid) {
$locale = \setlocale(LC_CTYPE, 0);
\setlocale(LC_CTYPE, 'C');
$valid = \ctype_alpha($value[0]);
\setlocale(LC_CTYPE, $locale);
}
if (!$valid) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to start with a letter. Got: %s',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $suffix
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function endsWith($value, $suffix, $message = '')
{
if ($suffix !== \substr($value, -\strlen($suffix))) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to end with %2$s. Got: %s',
static::valueToString($value),
static::valueToString($suffix)
));
}
}
/**
* @param mixed $value
* @param mixed $pattern
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function regex($value, $pattern, $message = '')
{
if (!\preg_match($pattern, $value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'The value %s does not match the expected pattern.',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param mixed $pattern
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function notRegex($value, $pattern, $message = '')
{
if (\preg_match($pattern, $value, $matches, PREG_OFFSET_CAPTURE)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'The value %s matches the pattern %s (at offset %d).',
static::valueToString($value),
static::valueToString($pattern),
$matches[0][1]
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function unicodeLetters($value, $message = '')
{
static::string($value);
if (!\preg_match('/^\p{L}+$/u', $value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain only Unicode letters. Got: %s',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function alpha($value, $message = '')
{
static::string($value);
$locale = \setlocale(LC_CTYPE, 0);
\setlocale(LC_CTYPE, 'C');
$valid = !\ctype_alpha($value);
\setlocale(LC_CTYPE, $locale);
if ($valid) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain only letters. Got: %s',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function digits($value, $message = '')
{
$locale = \setlocale(LC_CTYPE, 0);
\setlocale(LC_CTYPE, 'C');
$valid = !\ctype_digit($value);
\setlocale(LC_CTYPE, $locale);
if ($valid) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain digits only. Got: %s',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function alnum($value, $message = '')
{
$locale = \setlocale(LC_CTYPE, 0);
\setlocale(LC_CTYPE, 'C');
$valid = !\ctype_alnum($value);
\setlocale(LC_CTYPE, $locale);
if ($valid) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain letters and digits only. Got: %s',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function lower($value, $message = '')
{
$locale = \setlocale(LC_CTYPE, 0);
\setlocale(LC_CTYPE, 'C');
$valid = !\ctype_lower($value);
\setlocale(LC_CTYPE, $locale);
if ($valid) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain lowercase characters only. Got: %s',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function upper($value, $message = '')
{
$locale = \setlocale(LC_CTYPE, 0);
\setlocale(LC_CTYPE, 'C');
$valid = !\ctype_upper($value);
\setlocale(LC_CTYPE, $locale);
if ($valid) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain uppercase characters only. Got: %s',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param mixed $length
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function length($value, $length, $message = '')
{
if ($length !== static::strlen($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain %2$s characters. Got: %s',
static::valueToString($value),
$length
));
}
}
/**
* Inclusive min.
*
* @param mixed $value
* @param mixed $min
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function minLength($value, $min, $message = '')
{
if (static::strlen($value) < $min) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain at least %2$s characters. Got: %s',
static::valueToString($value),
$min
));
}
}
/**
* Inclusive max.
*
* @param mixed $value
* @param mixed $max
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function maxLength($value, $max, $message = '')
{
if (static::strlen($value) > $max) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain at most %2$s characters. Got: %s',
static::valueToString($value),
$max
));
}
}
/**
* Inclusive , so Assert::lengthBetween('asd', 3, 5); passes the assertion.
*
* @param mixed $value
* @param mixed $min
* @param mixed $max
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function lengthBetween($value, $min, $max, $message = '')
{
$length = static::strlen($value);
if ($length < $min || $length > $max) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a value to contain between %2$s and %3$s characters. Got: %s',
static::valueToString($value),
$min,
$max
));
}
}
/**
* Will also pass if $value is a directory, use Assert::file() instead if you need to be sure it is a file.
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function fileExists($value, $message = '')
{
static::string($value);
if (!\file_exists($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'The file %s does not exist.',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function file($value, $message = '')
{
static::fileExists($value, $message);
if (!\is_file($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'The path %s is not a file.',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function directory($value, $message = '')
{
static::fileExists($value, $message);
if (!\is_dir($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'The path %s is no directory.',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function readable($value, $message = '')
{
if (!\is_readable($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'The path %s is not readable.',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function writable($value, $message = '')
{
if (!\is_writable($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'The path %s is not writable.',
static::valueToString($value)
));
}
}
/**
* @psalm-assert class-string $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function classExists($value, $message = '')
{
if (!\class_exists($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an existing class name. Got: %s',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param string|object $class
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function subclassOf($value, $class, $message = '')
{
if (!\is_subclass_of($value, $class)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected a sub-class of %2$s. Got: %s',
static::valueToString($value),
static::valueToString($class)
));
}
}
/**
* @psalm-assert class-string $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function interfaceExists($value, $message = '')
{
if (!\interface_exists($value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an existing interface name. got %s',
static::valueToString($value)
));
}
}
/**
* @param mixed $value
* @param mixed $interface
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function implementsInterface($value, $interface, $message = '')
{
if (!\in_array($interface, \class_implements($value))) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an implementation of %2$s. Got: %s',
static::valueToString($value),
static::valueToString($interface)
));
}
}
/**
* @param string|object $classOrObject
* @param mixed $property
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function propertyExists($classOrObject, $property, $message = '')
{
if (!\property_exists($classOrObject, $property)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected the property %s to exist.',
static::valueToString($property)
));
}
}
/**
* @param string|object $classOrObject
* @param mixed $property
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function propertyNotExists($classOrObject, $property, $message = '')
{
if (\property_exists($classOrObject, $property)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected the property %s to not exist.',
static::valueToString($property)
));
}
}
/**
* @param string|object $classOrObject
* @param mixed $method
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function methodExists($classOrObject, $method, $message = '')
{
if (!\method_exists($classOrObject, $method)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected the method %s to exist.',
static::valueToString($method)
));
}
}
/**
* @param string|object $classOrObject
* @param mixed $method
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function methodNotExists($classOrObject, $method, $message = '')
{
if (\method_exists($classOrObject, $method)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected the method %s to not exist.',
static::valueToString($method)
));
}
}
/**
* @param array $array
* @param string|int $key
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function keyExists($array, $key, $message = '')
{
if (!(isset($array[$key]) || \array_key_exists($key, $array))) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected the key %s to exist.',
static::valueToString($key)
));
}
}
/**
* @param array $array
* @param string|int $key
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function keyNotExists($array, $key, $message = '')
{
if (isset($array[$key]) || \array_key_exists($key, $array)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected the key %s to not exist.',
static::valueToString($key)
));
}
}
/**
* Checks if a value is a valid array key (int or string).
*
* @psalm-assert array-key $value
*
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function validArrayKey($value, $message = '')
{
if (!(\is_int($value) || \is_string($value))) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected string or integer. Got: %s',
static::typeToString($value)
));
}
}
/**
* Does not check if $array is countable, this can generate a warning on php versions after 7.2.
*
* @param mixed $array
* @param mixed $number
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function count($array, $number, $message = '')
{
static::eq(
\count($array),
$number,
$message ?: \sprintf('Expected an array to contain %d elements. Got: %d.', $number, \count($array))
);
}
/**
* Does not check if $array is countable, this can generate a warning on php versions after 7.2.
*
* @param mixed $array
* @param mixed $min
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function minCount($array, $min, $message = '')
{
if (\count($array) < $min) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an array to contain at least %2$d elements. Got: %d',
\count($array),
$min
));
}
}
/**
* Does not check if $array is countable, this can generate a warning on php versions after 7.2.
*
* @param mixed $array
* @param mixed $max
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function maxCount($array, $max, $message = '')
{
if (\count($array) > $max) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an array to contain at most %2$d elements. Got: %d',
\count($array),
$max
));
}
}
/**
* Does not check if $array is countable, this can generate a warning on php versions after 7.2.
*
* @param mixed $array
* @param mixed $min
* @param mixed $max
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function countBetween($array, $min, $max, $message = '')
{
$count = \count($array);
if ($count < $min || $count > $max) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Expected an array to contain between %2$d and %3$d elements. Got: %d',
$count,
$min,
$max
));
}
}
/**
* @psalm-assert list $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isList($array, $message = '')
{
if (!\is_array($array) || $array !== \array_values($array)) {
static::reportInvalidArgument(
$message ?: 'Expected list - non-associative array.'
);
}
}
/**
* @psalm-assert non-empty-list $array
*
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isNonEmptyList($array, $message = '')
{
static::isList($array, $message);
static::notEmpty($array, $message);
}
/**
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isMap($array, $message = '')
{
if (
!\is_array($array) ||
\array_keys($array) !== \array_filter(\array_keys($array), '\is_string')
) {
static::reportInvalidArgument(
$message ?: 'Expected map - associative array with string keys.'
);
}
}
/**
* @param mixed $array
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function isNonEmptyMap($array, $message = '')
{
static::isMap($array, $message);
static::notEmpty($array, $message);
}
/**
* @param mixed $value
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function uuid($value, $message = '')
{
$value = \str_replace(array('urn:', 'uuid:', '{', '}'), '', $value);
// The nil UUID is special form of UUID that is specified to have all
// 128 bits set to zero.
if ('00000000-0000-0000-0000-000000000000' === $value) {
return;
}
if (!\preg_match('/^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}$/', $value)) {
static::reportInvalidArgument(\sprintf(
$message ?: 'Value %s is not a valid UUID.',
static::valueToString($value)
));
}
}
/**
* @param Closure $expression
* @param string|object $class
* @param string $message
*
* @throws InvalidArgumentException
*/
public static function throws(Closure $expression, $class = 'Exception', $message = '')
{
static::string($class);
$actual = 'none';
try {
$expression();
} catch (Exception $e) {
$actual = \get_class($e);
if ($e instanceof $class) {
return;
}
} catch (Throwable $e) {
$actual = \get_class($e);
if ($e instanceof $class) {
return;
}
}
static::reportInvalidArgument($message ?: \sprintf(
'Expected to throw "%s", got "%s"',
$class,
$actual
));
}
/**
* @throws BadMethodCallException
*/
public static function __callStatic($name, $arguments)
{
if ('nullOr' === \substr($name, 0, 6)) {
if (null !== $arguments[0]) {
$method = \lcfirst(\substr($name, 6));
\call_user_func_array(array('static', $method), $arguments);
}
return;
}
if ('all' === \substr($name, 0, 3)) {
static::isIterable($arguments[0]);
$method = \lcfirst(\substr($name, 3));
$args = $arguments;
foreach ($arguments[0] as $entry) {
$args[0] = $entry;
\call_user_func_array(array('static', $method), $args);
}
return;
}
throw new BadMethodCallException('No such method: '.$name);
}
/**
* @param mixed $value
*
* @return string
*/
protected static function valueToString($value)
{
if (null === $value) {
return 'null';
}
if (true === $value) {
return 'true';
}
if (false === $value) {
return 'false';
}
if (\is_array($value)) {
return 'array';
}
if (\is_object($value)) {
if (\method_exists($value, '__toString')) {
return \get_class($value).': '.self::valueToString($value->__toString());
}
return \get_class($value);
}
if (\is_resource($value)) {
return 'resource';
}
if (\is_string($value)) {
return '"'.$value.'"';
}
return (string) $value;
}
/**
* @param mixed $value
*
* @return string
*/
protected static function typeToString($value)
{
return \is_object($value) ? \get_class($value) : \gettype($value);
}
protected static function strlen($value)
{
if (!\function_exists('mb_detect_encoding')) {
return \strlen($value);
}
if (false === $encoding = \mb_detect_encoding($value)) {
return \strlen($value);
}
return \mb_strlen($value, $encoding);
}
/**
* @param string $message
*
* @throws InvalidArgumentException
*/
protected static function reportInvalidArgument($message)
{
throw new InvalidArgumentException($message);
}
private function __construct()
{
}
}
php-webmozart-assert-1.7.0/tests/ 0000775 0000000 0000000 00000000000 13624547556 0017000 5 ustar 00root root 0000000 0000000 php-webmozart-assert-1.7.0/tests/AssertTest.php 0000664 0000000 0000000 00000111113 13624547556 0021610 0 ustar 00root root 0000000 0000000
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Webmozart\Assert\Tests;
use ArrayIterator;
use ArrayObject;
use Exception;
use Error;
use LogicException;
use RuntimeException;
use stdClass;
use Webmozart\Assert\Assert;
/**
* @since 1.0
*
* @author Bernhard Schussek
*/
class AssertTest extends BaseTestCase
{
private static $resource;
public static function getResource()
{
if (!static::$resource) {
static::$resource = fopen(__FILE__, 'r');
}
return static::$resource;
}
public static function tearDownAfterClass()
{
@fclose(self::$resource);
}
public function getTests()
{
$resource = self::getResource();
return array(
array('string', array('value'), true),
array('string', array(''), true),
array('string', array(1234), false),
array('stringNotEmpty', array('value'), true),
array('stringNotEmpty', array('0'), true),
array('stringNotEmpty', array(''), false),
array('stringNotEmpty', array(1234), false),
array('integer', array(123), true),
array('integer', array('123'), false),
array('integer', array(1.0), false),
array('integer', array(1.23), false),
array('integerish', array(1.0), true),
array('integerish', array(1.23), false),
array('integerish', array(123), true),
array('integerish', array('123'), true),
array('float', array(1.0), true),
array('float', array(1.23), true),
array('float', array(123), false),
array('float', array('123'), false),
array('numeric', array(1.0), true),
array('numeric', array(1.23), true),
array('numeric', array(123), true),
array('numeric', array('123'), true),
array('numeric', array('foo'), false),
array('natural', array(0), true),
array('natural', array(1), true),
array('natural', array(-1), false),
array('natural', array('1'), false),
array('natural', array(1.0), false),
array('natural', array(1.23), false),
array('boolean', array(true), true),
array('boolean', array(false), true),
array('boolean', array(1), false),
array('boolean', array('1'), false),
array('scalar', array('1'), true),
array('scalar', array(123), true),
array('scalar', array(true), true),
array('scalar', array(null), false),
array('scalar', array(array()), false),
array('scalar', array(new stdClass()), false),
array('object', array(new stdClass()), true),
array('object', array(new RuntimeException()), true),
array('object', array(null), false),
array('object', array(true), false),
array('object', array(1), false),
array('object', array(array()), false),
array('resource', array($resource), true),
array('resource', array($resource, 'stream'), true),
array('resource', array($resource, 'other'), false),
array('resource', array(1), false),
array('isCallable', array('strlen'), true),
array('isCallable', array(array($this, 'getTests')), true),
array('isCallable', array(function () {}), true),
array('isCallable', array(1234), false),
array('isCallable', array('foobar'), false),
array('isArray', array(array()), true),
array('isArray', array(array(1, 2, 3)), true),
array('isArray', array(new ArrayIterator(array())), false),
array('isArray', array(123), false),
array('isArray', array(new stdClass()), false),
array('isTraversable', array(array()), true),
array('isTraversable', array(array(1, 2, 3)), true),
array('isTraversable', array(new ArrayIterator(array())), true),
array('isTraversable', array(123), false),
array('isTraversable', array(new stdClass()), false),
array('isArrayAccessible', array(array()), true),
array('isArrayAccessible', array(array(1, 2, 3)), true),
array('isArrayAccessible', array(new ArrayObject(array())), true),
array('isArrayAccessible', array(123), false),
array('isArrayAccessible', array(new stdClass()), false),
array('isCountable', array(array()), true),
array('isCountable', array(array(1, 2)), true),
array('isCountable', array(new ArrayIterator(array())), true),
array('isCountable', array(new stdClass()), false),
array('isCountable', array(new \SimpleXMLElement('bar')), true),
array('isCountable', array('abcd'), false),
array('isCountable', array(123), false),
array('isIterable', array(array()), true),
array('isIterable', array(array(1, 2, 3)), true),
array('isIterable', array(new ArrayIterator(array())), true),
array('isIterable', array(123), false),
array('isIterable', array(new stdClass()), false),
array('isInstanceOf', array(new stdClass(), 'stdClass'), true),
array('isInstanceOf', array(new Exception(), 'stdClass'), false),
array('isInstanceOf', array(123, 'stdClass'), false),
array('isInstanceOf', array(array(), 'stdClass'), false),
array('isInstanceOf', array(null, 'stdClass'), false),
array('notInstanceOf', array(new stdClass(), 'stdClass'), false),
array('notInstanceOf', array(new Exception(), 'stdClass'), true),
array('notInstanceOf', array(123, 'stdClass'), true),
array('notInstanceOf', array(array(), 'stdClass'), true),
array('isInstanceOfAny', array(new ArrayIterator(), array('Iterator', 'ArrayAccess')), true),
array('isInstanceOfAny', array(new Exception(), array('Exception', 'Countable')), true),
array('isInstanceOfAny', array(new Exception(), array('ArrayAccess', 'Countable')), false),
array('isInstanceOfAny', array(123, array('stdClass')), false),
array('isInstanceOfAny', array(array(), array('stdClass')), false),
array('isAOf', array('stdClass', 'stdClass'), true),
array('isAOf', array('stdClass', 123), false),
array('isAOf', array('Iterator', 'ArrayIterator'), false),
array('isAOf', array(123, 'Iterator'), false),
array('isAOf', array(array(), 'Iterator'), false),
array('isAnyOf', array('ArrayIterator', array('Iterator', 'ArrayAccess')), true),
array('isAnyOf', array('ArrayIterator', array(123)), false),
array('isAnyOf', array('Exception', array('Exception', 'Countable')), true),
array('isAnyOf', array('Exception', array('ArrayAccess', 'Countable')), false),
array('isAnyOf', array(123, array('stdClass')), false),
array('isAnyOf', array(array(), array('stdClass')), false),
array('isNotA', array('stdClass', 'stdClass'), false),
array('isNotA', array('stdClass', 123), false),
array('isNotA', array('Iterator', 'ArrayIterator'), true),
array('isNotA', array(123, 'Iterator'), true),
array('isNotA', array(array(), 'Iterator'), true),
array('true', array(true), true),
array('true', array(false), false),
array('true', array(1), false),
array('true', array(null), false),
array('false', array(false), true),
array('false', array(true), false),
array('false', array(1), false),
array('false', array(0), false),
array('false', array(null), false),
array('notFalse', array(false), false),
array('notFalse', array(true), true),
array('notFalse', array(1), true),
array('notFalse', array(0), true),
array('notFalse', array(null), true),
array('null', array(null), true),
array('null', array(false), false),
array('null', array(0), false),
array('notNull', array(false), true),
array('notNull', array(0), true),
array('notNull', array(null), false),
array('isEmpty', array(null), true),
array('isEmpty', array(false), true),
array('isEmpty', array(0), true),
array('isEmpty', array(''), true),
array('isEmpty', array(1), false),
array('isEmpty', array('a'), false),
array('notEmpty', array(1), true),
array('notEmpty', array('a'), true),
array('notEmpty', array(null), false),
array('notEmpty', array(false), false),
array('notEmpty', array(0), false),
array('notEmpty', array(''), false),
array('eq', array(1, 1), true),
array('eq', array(1, '1'), true),
array('eq', array(1, true), true),
array('eq', array(1, 0), false),
array('notEq', array(1, 0), true),
array('notEq', array(1, 1), false),
array('notEq', array(1, '1'), false),
array('notEq', array(1, true), false),
array('same', array(1, 1), true),
array('same', array(1, '1'), false),
array('same', array(1, true), false),
array('same', array(1, 0), false),
array('notSame', array(1, 0), true),
array('notSame', array(1, 1), false),
array('notSame', array(1, '1'), true),
array('notSame', array(1, true), true),
array('greaterThan', array(1, 0), true),
array('greaterThan', array(0, 0), false),
array('greaterThanEq', array(2, 1), true),
array('greaterThanEq', array(1, 1), true),
array('greaterThanEq', array(0, 1), false),
array('lessThan', array(0, 1), true),
array('lessThan', array(1, 1), false),
array('lessThanEq', array(0, 1), true),
array('lessThanEq', array(1, 1), true),
array('lessThanEq', array(2, 1), false),
array('range', array(1, 1, 2), true),
array('range', array(2, 1, 2), true),
array('range', array(0, 1, 2), false),
array('range', array(3, 1, 2), false),
array('oneOf', array(1, array(1, 2, 3)), true),
array('oneOf', array(1, array('1', '2', '3')), false),
array('contains', array('abcd', 'ab'), true),
array('contains', array('abcd', 'bc'), true),
array('contains', array('abcd', 'cd'), true),
array('contains', array('abcd', 'de'), false),
array('contains', array('', 'de'), false),
array('contains', array('äþçð', 'äþ'), true),
array('contains', array('äþçð', 'þç'), true),
array('contains', array('äþçð', 'çð'), true),
array('contains', array('äþçð', 'ðé'), false),
array('contains', array('', 'ðé'), false),
array('contains', array('あいうえ', 'あい'), true),
array('contains', array('あいうえ', 'いう'), true),
array('contains', array('あいうえ', 'うえ'), true),
array('contains', array('あいうえ', 'えお'), false),
array('contains', array('', 'えお'), false),
array('contains', array('😄😑☹️', '😄'), true),
array('contains', array('😄😑☹️', '😑'), true),
array('contains', array('😄😑☹️', '☹️'), true),
array('contains', array('😄😑☹️', '😄☹️'), false),
array('contains', array('', '😑'), false),
array('notContains', array('abcd', 'ab'), false),
array('notContains', array('abcd', 'bc'), false),
array('notContains', array('abcd', 'cd'), false),
array('notContains', array('abcd', 'de'), true),
array('notContains', array('', 'de'), true),
array('notContains', array('äþçð', 'äþ'), false),
array('notContains', array('äþçð', 'þç'), false),
array('notContains', array('äþçð', 'çð'), false),
array('notContains', array('äþçð', 'ðé'), true),
array('notContains', array('', 'ðé'), true),
array('notContains', array('あいうえ', 'あい'), false),
array('notContains', array('あいうえ', 'いう'), false),
array('notContains', array('あいうえ', 'うえ'), false),
array('notContains', array('あいうえ', 'えお'), true),
array('notContains', array('', 'えお'), true),
array('notContains', array('😄😑☹️', '😄'), false),
array('notContains', array('😄😑☹️', '😑'), false),
array('notContains', array('😄😑☹️', '☹️'), false),
array('notContains', array('😄😑☹️', '😄☹️'), true),
array('notContains', array('', '😑'), true),
array('notWhitespaceOnly', array('abc'), true),
array('notWhitespaceOnly', array('123'), true),
array('notWhitespaceOnly', array(' abc '), true),
array('notWhitespaceOnly', array('a b c'), true),
array('notWhitespaceOnly', array(''), false),
array('notWhitespaceOnly', array(' '), false),
array('notWhitespaceOnly', array("\t"), false),
array('notWhitespaceOnly', array("\n"), false),
array('notWhitespaceOnly', array("\r"), false),
array('notWhitespaceOnly', array("\r\n\t "), false),
array('startsWith', array('abcd', 'ab'), true),
array('startsWith', array('abcd', 'bc'), false),
array('startsWith', array('', 'bc'), false),
array('startsWith', array('äþçð', 'äþ'), true),
array('startsWith', array('äþçð', 'þç'), false),
array('startsWith', array('', 'þç'), false),
array('startsWith', array('あいうえ', 'あい'), true),
array('startsWith', array('あいうえ', 'いう'), false),
array('startsWith', array('', 'いう'), false),
array('startsWith', array('😄😑☹️', '😄'), true),
array('startsWith', array('😄😑☹️', '😑'), false),
array('startsWith', array('', '😑'), false),
array('startsWithLetter', array('abcd'), true),
array('startsWithLetter', array(array(66)), false),
array('startsWithLetter', array('a'), true),
array('startsWithLetter', array('a1'), true),
array('startsWithLetter', array('1abcd'), false),
array('startsWithLetter', array('1'), false),
array('startsWithLetter', array(''), false),
array('startsWithLetter', array(null), false),
array('startsWithLetter', array(66), false),
array('endsWith', array('abcd', 'cd'), true),
array('endsWith', array('abcd', 'bc'), false),
array('endsWith', array('', 'bc'), false),
array('endsWith', array('äþçð', 'çð'), true),
array('endsWith', array('äþçð', 'þç'), false),
array('endsWith', array('', 'þç'), false),
array('endsWith', array('あいうえ', 'うえ'), true),
array('endsWith', array('あいうえ', 'いう'), false),
array('endsWith', array('', 'いう'), false),
array('endsWith', array('😄😑☹️', '☹️'), true),
array('endsWith', array('😄😑☹️', '😑'), false),
array('endsWith', array('', '😑'), false),
array('regex', array('abcd', '~^ab~'), true),
array('regex', array('abcd', '~^bc~'), false),
array('regex', array('', '~^bc~'), false),
array('notRegex', array('abcd', '{^ab}'), false),
array('notRegex', array('abcd', '{^bc}'), true),
array('notRegex', array('', '{^bc}'), true),
array('unicodeLetters', array('abcd'), true),
array('unicodeLetters', array('ᴁڅਘธブ乶'), true),
array('unicodeLetters', array('ȁȄ'), true),
array('unicodeLetters', array('ȁ1Ȅ'), false),
array('unicodeLetters', array('©'), false),
array('unicodeLetters', array('🙁'), false),
array('unicodeLetters', array(''), false),
array('alpha', array('abcd'), true),
array('alpha', array('ab1cd'), false),
array('alpha', array(''), false),
array('alpha', array(66), false),
array('alpha', array(array()), false),
array('digits', array('1234'), true),
array('digits', array('12a34'), false),
array('digits', array(''), false),
array('alnum', array('ab12'), true),
array('alnum', array('ab12$'), false),
array('alnum', array(''), false),
array('lower', array('abcd'), true),
array('lower', array('abCd'), false),
array('lower', array('ab_d'), false),
array('lower', array(''), false),
array('upper', array('ABCD'), true),
array('upper', array('ABcD'), false),
array('upper', array('AB_D'), false),
array('upper', array(''), false),
array('length', array('abcd', 4), true),
array('length', array('abc', 4), false),
array('length', array('abcde', 4), false),
array('length', array('äbcd', 4), true, true),
array('length', array('äbc', 4), false, true),
array('length', array('äbcde', 4), false, true),
array('length', array('あbcd', 4), true, true), // 'HIRAGANA LETTER A' (U+3042)
array('length', array('あbc', 4), false, true),
array('length', array('あbcde', 4), false, true),
array('minLength', array('abcd', 4), true),
array('minLength', array('abcde', 4), true),
array('minLength', array('abc', 4), false),
array('minLength', array('äbcd', 4), true, true),
array('minLength', array('äbcde', 4), true, true),
array('minLength', array('äbc', 4), false, true),
array('minLength', array('あbcd', 4), true, true),
array('minLength', array('あbcde', 4), true, true),
array('minLength', array('あbc', 4), false, true),
array('maxLength', array('abcd', 4), true),
array('maxLength', array('abc', 4), true),
array('maxLength', array('abcde', 4), false),
array('maxLength', array('äbcd', 4), true, true),
array('maxLength', array('äbc', 4), true, true),
array('maxLength', array('äbcde', 4), false, true),
array('maxLength', array('あbcd', 4), true, true),
array('maxLength', array('あbc', 4), true, true),
array('maxLength', array('あbcde', 4), false, true),
array('lengthBetween', array('abcd', 3, 5), true),
array('lengthBetween', array('abc', 3, 5), true),
array('lengthBetween', array('abcde', 3, 5), true),
array('lengthBetween', array('ab', 3, 5), false),
array('lengthBetween', array('abcdef', 3, 5), false),
array('lengthBetween', array('äbcd', 3, 5), true, true),
array('lengthBetween', array('äbc', 3, 5), true, true),
array('lengthBetween', array('äbcde', 3, 5), true, true),
array('lengthBetween', array('äb', 3, 5), false, true),
array('lengthBetween', array('äbcdef', 3, 5), false, true),
array('lengthBetween', array('あbcd', 3, 5), true, true),
array('lengthBetween', array('あbc', 3, 5), true, true),
array('lengthBetween', array('あbcde', 3, 5), true, true),
array('lengthBetween', array('あb', 3, 5), false, true),
array('lengthBetween', array('あbcdef', 3, 5), false, true),
array('fileExists', array(__FILE__), true),
array('fileExists', array(__DIR__), true),
array('fileExists', array(__DIR__.'/foobar'), false),
array('file', array(__FILE__), true),
array('file', array(__DIR__), false),
array('file', array(__DIR__.'/foobar'), false),
array('directory', array(__DIR__), true),
array('directory', array(__FILE__), false),
array('directory', array(__DIR__.'/foobar'), false),
// no tests for readable()/writable() for now
array('classExists', array(__CLASS__), true),
array('classExists', array(__NAMESPACE__.'\Foobar'), false),
array('subclassOf', array(__CLASS__, 'Webmozart\Assert\Tests\BaseTestCase'), true),
array('subclassOf', array(__CLASS__, 'stdClass'), false),
array('interfaceExists', array('\Countable'), true),
array('interfaceExists', array(__CLASS__), false),
array('implementsInterface', array('ArrayIterator', 'Traversable'), true),
array('implementsInterface', array(__CLASS__, 'Traversable'), false),
array('propertyExists', array((object) array('property' => 0), 'property'), true),
array('propertyExists', array((object) array('property' => null), 'property'), true),
array('propertyExists', array((object) array('property' => null), 'foo'), false),
array('propertyNotExists', array((object) array('property' => 0), 'property'), false),
array('propertyNotExists', array((object) array('property' => null), 'property'), false),
array('propertyNotExists', array((object) array('property' => null), 'foo'), true),
array('methodExists', array('RuntimeException', 'getMessage'), true),
array('methodExists', array(new RuntimeException(), 'getMessage'), true),
array('methodExists', array('stdClass', 'getMessage'), false),
array('methodExists', array(new stdClass(), 'getMessage'), false),
array('methodExists', array(null, 'getMessage'), false),
array('methodExists', array(true, 'getMessage'), false),
array('methodExists', array(1, 'getMessage'), false),
array('methodNotExists', array('RuntimeException', 'getMessage'), false),
array('methodNotExists', array(new RuntimeException(), 'getMessage'), false),
array('methodNotExists', array('stdClass', 'getMessage'), true),
array('methodNotExists', array(new stdClass(), 'getMessage'), true),
array('methodNotExists', array(null, 'getMessage'), true),
array('methodNotExists', array(true, 'getMessage'), true),
array('methodNotExists', array(1, 'getMessage'), true),
array('keyExists', array(array('key' => 0), 'key'), true),
array('keyExists', array(array('key' => null), 'key'), true),
array('keyExists', array(array('key' => null), 'foo'), false),
array('keyNotExists', array(array('key' => 0), 'key'), false),
array('keyNotExists', array(array('key' => null), 'key'), false),
array('keyNotExists', array(array('key' => null), 'foo'), true),
array('validArrayKey', array('abcd'), true),
array('validArrayKey', array(1), true),
array('validArrayKey', array(false), false),
array('validArrayKey', array(true), false),
array('validArrayKey', array(new stdClass()), false),
array('validArrayKey', array(new ToStringClass('testString')), false),
array('validArrayKey', array(self::getResource()), false),
array('count', array(array(0, 1, 2), 3), true),
array('count', array(array(0, 1, 2), 2), false),
array('minCount', array(array(0), 2), false),
array('minCount', array(array(0, 1), 2), true),
array('minCount', array(array(0, 1, 2), 2), true),
array('maxCount', array(array(0, 1, 2), 2), false),
array('maxCount', array(array(0, 1), 2), true),
array('maxCount', array(array(0), 2), true),
array('countBetween', array(array(0, 1, 2), 4, 5), false),
array('countBetween', array(array(0, 1, 2), 3, 5), true),
array('countBetween', array(array(0, 1, 2), 1, 2), false),
array('countBetween', array(array(0, 1, 2), 2, 5), true),
array('countBetween', array(array(0, 1, 2), 2, 3), true),
array('isList', array(array(1, 2, 3)), true),
array('isList', array(array()), true),
array('isList', array(array(0 => 1, 2 => 3)), false),
array('isList', array(array('key' => 1, 'foo' => 2)), false),
array('isList', array(true), false),
array('isList', array(false), false),
array('isList', array(array(true)), true),
array('isList', array(array(false)), true),
array('isList', array(array(array(1), array(2))), true),
array('isList', array(array(array('foo' => 'bar'), array('baz' => 'tab'))), true),
array('isNonEmptyList', array(array(1, 2, 3)), true),
array('isNonEmptyList', array(array()), false),
array('isNonEmptyList', array(array(0 => 1, 2 => 3)), false),
array('isNonEmptyList', array(array('key' => 1, 'foo' => 2)), false),
array('isNonEmptyList', array(true), false),
array('isNonEmptyList', array(false), false),
array('isNonEmptyList', array(array(true)), true),
array('isNonEmptyList', array(array(false)), true),
array('isNonEmptyList', array(array(array(1), array(2))), true),
array('isNonEmptyList', array(array(array('foo' => 'bar'), array('baz' => 'tab'))), true),
array('isMap', array(array('key' => 1, 'foo' => 2)), true),
array('isMap', array(array()), true),
array('isMap', array(array(1, 2, 3)), false),
array('isMap', array(array(0 => 1, 2 => 3)), false),
array('isNonEmptyMap', array(array('key' => 1, 'foo' => 2)), true),
array('isNonEmptyMap', array(array()), false),
array('isNonEmptyMap', array(array(1, 2, 3)), false),
array('isNonEmptyMap', array(array(0 => 1, 2 => 3)), false),
array('uuid', array('00000000-0000-0000-0000-000000000000'), true),
array('uuid', array('urn:ff6f8cb0-c57d-21e1-9b21-0800200c9a66'), true),
array('uuid', array('uuid:{ff6f8cb0-c57d-21e1-9b21-0800200c9a66}'), true),
array('uuid', array('ff6f8cb0-c57d-21e1-9b21-0800200c9a66'), true),
array('uuid', array('ff6f8cb0-c57d-11e1-9b21-0800200c9a66'), true),
array('uuid', array('ff6f8cb0-c57d-31e1-9b21-0800200c9a66'), true),
array('uuid', array('ff6f8cb0-c57d-41e1-9b21-0800200c9a66'), true),
array('uuid', array('ff6f8cb0-c57d-51e1-9b21-0800200c9a66'), true),
array('uuid', array('FF6F8CB0-C57D-11E1-9B21-0800200C9A66'), true),
array('uuid', array('zf6f8cb0-c57d-11e1-9b21-0800200c9a66'), false),
array('uuid', array('af6f8cb0c57d11e19b210800200c9a66'), false),
array('uuid', array('ff6f8cb0-c57da-51e1-9b21-0800200c9a66'), false),
array('uuid', array('af6f8cb-c57d-11e1-9b21-0800200c9a66'), false),
array('uuid', array('3f6f8cb0-c57d-11e1-9b21-0800200c9a6'), false),
array('throws', array(function() { throw new LogicException('test'); }, 'LogicException'), true),
array('throws', array(function() { throw new LogicException('test'); }, 'IllogicException'), false),
array('throws', array(function() { throw new Exception('test'); }), true),
array('throws', array(function() { trigger_error('test'); }, 'Throwable'), true, false, 70000),
array('throws', array(function() { trigger_error('test'); }, 'Unthrowable'), false, false, 70000),
array('throws', array(function() { throw new Error(); }, 'Throwable'), true, true, 70000),
array('ip', array('192.168.0.1'), true),
array('ip', array(new ToStringClass('192.168.0.1')), true),
array('ip', array('255.255.255.255'), true),
array('ip', array('0.0.0.0'), true),
array('ip', array('2001:0db8:0000:0042:0000:8a2e:0370:7334'), true),
array('ip', array('::ffff:192.0.2.1'), true),
array('ip', array('::1'), true),
array('ip', array('::'), true),
array('ip', array('foo'), false),
array('ip', array(123), false),
array('ip', array(array()), false),
array('ip', array(null), false),
array('ip', array(false), false),
array('ipv4', array('192.168.0.1'), true),
array('ipv4', array(new ToStringClass('192.168.0.1')), true),
array('ipv4', array('255.255.255.255'), true),
array('ipv4', array('0.0.0.0'), true),
array('ipv4', array('2001:0db8:0000:0042:0000:8a2e:0370:7334'), false),
array('ipv4', array('::ffff:192.0.2.1'), false),
array('ipv4', array('::1'), false),
array('ipv4', array('::'), false),
array('ipv4', array('foo'), false),
array('ipv4', array(123), false),
array('ipv4', array(array()), false),
array('ipv4', array(null), false),
array('ipv4', array(false), false),
array('ipv6', array('192.168.0.1'), false),
array('ipv6', array('255.255.255.255'), false),
array('ipv6', array('0.0.0.0'), false),
array('ipv6', array('2001:0db8:0000:0042:0000:8a2e:0370:7334'), true),
array('ipv6', array(new ToStringClass('2001:0db8:0000:0042:0000:8a2e:0370:7334')), true),
array('ipv6', array('::ffff:192.0.2.1'), true),
array('ipv6', array('::1'), true),
array('ipv6', array('::'), true),
array('ipv6', array('foo'), false),
array('ipv6', array(123), false),
array('ipv6', array(array()), false),
array('ipv6', array(null), false),
array('ipv6', array(false), false),
array('email', array('foo'), false),
array('email', array(123), false),
array('email', array('foo.com'), false),
array('email', array('foo@bar.com'), true),
array('email', array(new ToStringClass('foo@bar.com')), true),
array('uniqueValues', array(array('qwerty', 'qwerty')), false),
array('uniqueValues', array(array('asdfg', 'qwerty')), true),
array('uniqueValues', array(array(123, '123')), false),
);
}
public function getMethods()
{
$methods = array();
foreach ($this->getTests() as $params) {
$methods[$params[0]] = array($params[0]);
}
return array_values($methods);
}
/**
* @dataProvider getTests
*/
public function testAssert($method, $args, $success, $multibyte = false, $minVersion = null)
{
if ($minVersion && PHP_VERSION_ID < $minVersion) {
$this->markTestSkipped(sprintf('This test requires php %s or upper.', $minVersion));
return;
}
if ($multibyte && !function_exists('mb_strlen')) {
$this->markTestSkipped('The function mb_strlen() is not available');
}
if (!$success) {
$this->setExpectedException('\InvalidArgumentException');
}
call_user_func_array(array('Webmozart\Assert\Assert', $method), $args);
$this->addToAssertionCount(1);
}
/**
* @dataProvider getTests
*/
public function testNullOr($method, $args, $success, $multibyte = false, $minVersion = null)
{
if ($minVersion && PHP_VERSION_ID < $minVersion) {
$this->markTestSkipped(sprintf('This test requires php %s or upper.', $minVersion));
return;
}
if ($multibyte && !function_exists('mb_strlen')) {
$this->markTestSkipped('The function mb_strlen() is not available');
}
if (!$success && null !== reset($args)) {
$this->setExpectedException('\InvalidArgumentException');
}
call_user_func_array(array('Webmozart\Assert\Assert', 'nullOr'.ucfirst($method)), $args);
$this->addToAssertionCount(1);
}
/**
* @dataProvider getMethods
*/
public function testNullOrAcceptsNull($method)
{
call_user_func(array('Webmozart\Assert\Assert', 'nullOr'.ucfirst($method)), null);
$this->addToAssertionCount(1);
}
/**
* @dataProvider getTests
*/
public function testAllArray($method, $args, $success, $multibyte = false, $minVersion = null)
{
if ($minVersion && PHP_VERSION_ID < $minVersion) {
$this->markTestSkipped(sprintf('This test requires php %s or upper.', $minVersion));
return;
}
if ($multibyte && !function_exists('mb_strlen')) {
$this->markTestSkipped('The function mb_strlen() is not available');
}
if (!$success) {
$this->setExpectedException('\InvalidArgumentException');
}
$arg = array_shift($args);
array_unshift($args, array($arg));
call_user_func_array(array('Webmozart\Assert\Assert', 'all'.ucfirst($method)), $args);
$this->addToAssertionCount(1);
}
/**
* @dataProvider getTests
*/
public function testAllTraversable($method, $args, $success, $multibyte = false, $minVersion = null)
{
if ($minVersion && PHP_VERSION_ID < $minVersion) {
$this->markTestSkipped(sprintf('This test requires php %s or upper.', $minVersion));
return;
}
if ($multibyte && !function_exists('mb_strlen')) {
$this->markTestSkipped('The function mb_strlen() is not available');
}
if (!$success) {
$this->setExpectedException('\InvalidArgumentException');
}
$arg = array_shift($args);
array_unshift($args, new ArrayIterator(array($arg)));
call_user_func_array(array('Webmozart\Assert\Assert', 'all'.ucfirst($method)), $args);
$this->addToAssertionCount(1);
}
public function getStringConversions()
{
return array(
array('integer', array('foobar'), 'Expected an integer. Got: string'),
array('string', array(1), 'Expected a string. Got: integer'),
array('string', array(true), 'Expected a string. Got: boolean'),
array('string', array(null), 'Expected a string. Got: NULL'),
array('string', array(array()), 'Expected a string. Got: array'),
array('string', array(new stdClass()), 'Expected a string. Got: stdClass'),
array('string', array(self::getResource()), 'Expected a string. Got: resource'),
array('eq', array('1', '2'), 'Expected a value equal to "2". Got: "1"'),
array('eq', array(new ToStringClass("XXX"), new ToStringClass("YYY")), 'Expected a value equal to Webmozart\Assert\Tests\ToStringClass: "YYY". Got: Webmozart\Assert\Tests\ToStringClass: "XXX"'),
array('eq', array(1, 2), 'Expected a value equal to 2. Got: 1'),
array('eq', array(true, false), 'Expected a value equal to false. Got: true'),
array('eq', array(true, null), 'Expected a value equal to null. Got: true'),
array('eq', array(null, true), 'Expected a value equal to true. Got: null'),
array('eq', array(array(1), array(2)), 'Expected a value equal to array. Got: array'),
array('eq', array(new ArrayIterator(array()), new stdClass()), 'Expected a value equal to stdClass. Got: ArrayIterator'),
array('eq', array(1, self::getResource()), 'Expected a value equal to resource. Got: 1'),
);
}
/**
* @dataProvider getStringConversions
*/
public function testConvertValuesToStrings($method, $args, $exceptionMessage)
{
$this->setExpectedException('\InvalidArgumentException', $exceptionMessage);
call_user_func_array(array('Webmozart\Assert\Assert', $method), $args);
}
public function testAnUnkownMethodThrowsABadMethodCall()
{
$this->setExpectedException('\BadMethodCallException');
Assert::nonExistentMethod();
}
}
/**
* @ignore
*/
class ToStringClass {
/**
* @var string
*/
private $value;
public function __construct($value)
{
$this->value = $value;
}
public function __toString()
{
return $this->value;
}
}
php-webmozart-assert-1.7.0/tests/BaseTestCase.php 0000664 0000000 0000000 00000002173 13624547556 0022022 0 ustar 00root root 0000000 0000000 expectException($exceptionName);
if($exceptionMessage) {
$this->expectExceptionMessage($exceptionMessage);
}
if( $exceptionCode) {
$this->expectExceptionCode($exceptionCode);
}
return;
}
parent::setExpectedException($exceptionName, $exceptionMessage, $exceptionCode);
}
}
php-webmozart-assert-1.7.0/tests/ProjectCodeTest.php 0000664 0000000 0000000 00000010452 13624547556 0022554 0 ustar 00root root 0000000 0000000 getDocComment();
}
/**
* @dataProvider providesMethodNames
*
* @param string $method
*/
public function testHasNullOr($method)
{
if ($method === 'notNull' || $method === 'null') {
$this->addToAssertionCount(1);
return;
}
$correct = strpos( (string)self::$assertDocComment,'@method static void nullOr' . ucfirst($method));
if ($correct === false) {
$this->fail(sprintf(
'All methods have a corresponding "nullOr" method, please add the "nullOr%s" method to the class level doc comment.',
ucfirst($method)
));
}
$this->addToAssertionCount(1);
}
/**
* @dataProvider providesMethodNames
*
* @param string $method
*/
public function testHasAll($method)
{
$correct = strpos((string) self::$assertDocComment,'@method static void all' . ucfirst($method));
if ($correct === false) {
$this->fail(sprintf(
'All methods have a corresponding "all" method, please add the "all%s" method to the class level doc comment.',
ucfirst($method)
));
}
$this->addToAssertionCount(1);
}
/**
* @dataProvider providesMethodNames
*
* @param string $method
*/
public function testIsInReadme($method)
{
$correct = strpos((string) self::$readmeContent,$method);
if($correct === false) {
$this->fail(sprintf(
'All methods must be documented in the README.md, please add the "%s" method.',
$method
));
}
$this->addToAssertionCount(1);
}
/**
* @dataProvider provideMethods
*
* @param ReflectionMethod $method
*/
public function testHasThrowsAnnotation($method)
{
$doc = $method->getDocComment();
$this->assertNotFalse(
$doc,
sprintf(
'Expected a doc comment on the "%s" method, but none found',
$method->getName()
)
);
$this->assertContains(
'@throws InvalidArgumentException',
$doc,
sprintf(
'Expected method "%s" to have an @throws InvalidArgumentException annotation, but none found',
$method->getName()
)
);
}
/**
* @dataProvider provideMethods
*
* @param ReflectionMethod $method
*/
public function testHasCorrespondingStaticAnalysisFile($method)
{
$doc = $method->getDocComment();
if($doc === false || strpos($doc, '@psalm-assert') === false) {
$this->addToAssertionCount(1);
return;
}
$this->assertFileExists(
__DIR__ . '/static-analysis/assert-'. $method->getName() . '.php'
);
}
/**
* @return array
*/
public function providesMethodNames()
{
return array_map(function($value) {
return array($value->getName());
}, $this->getMethods());
}
/**
* @return array
*/
public function provideMethods()
{
return array_map(function($value) {
return array($value);
}, $this->getMethods());
}
/**
* @return array
*/
private function getMethods()
{
static $methods;
if ($methods !== null) {
return $methods;
}
$rc = new ReflectionClass('\Webmozart\Assert\Assert');
$methods = array();
$rcMethods = $rc->getMethods(ReflectionMethod::IS_PUBLIC);
foreach ($rcMethods as $rcMethod) {
$methodName = $rcMethod->getName();
if (strpos($methodName, '__') === 0) {
continue;
}
$methods[] = $rcMethod;
}
return $methods;
}
}
php-webmozart-assert-1.7.0/tests/static-analysis/ 0000775 0000000 0000000 00000000000 13624547556 0022110 5 ustar 00root root 0000000 0000000 php-webmozart-assert-1.7.0/tests/static-analysis/assert-boolean.php 0000664 0000000 0000000 00000000320 13624547556 0025532 0 ustar 00root root 0000000 0000000
*/
function consume($value): array
{
Assert::isList($value);
return $value;
}
php-webmozart-assert-1.7.0/tests/static-analysis/assert-isNonEmptyList.php 0000664 0000000 0000000 00000000402 13624547556 0027055 0 ustar 00root root 0000000 0000000
*/
function consume($value): array
{
Assert::isNonEmptyList($value);
return $value;
}
php-webmozart-assert-1.7.0/tests/static-analysis/assert-isTraversable.php 0000664 0000000 0000000 00000000406 13624547556 0026726 0 ustar 00root root 0000000 0000000 $array
*
* @return array
*/
function consume($value, array $array): array
{
Assert::validArrayKey($value);
$array[$value] = 12;
return $array;
}