Laravel version update

Laravel version update

vendor/webmozart/assert/.gitignore

@@ -1,2 +0,0 @@
-/vendor/
-composer.lock

vendor/webmozart/assert/.styleci.yml

@@ -1,7 +1,11 @@
 preset: symfony
 
+finder:
+    exclude:
+        - "tests"
+
 enabled:
     - ordered_use
 
 disabled:
-    - empty_return
+    - phpdoc_annotation_without_dot # This is still buggy: https://github.com/symfony/symfony/pull/19198

vendor/webmozart/assert/.travis.yml

@@ -1,35 +0,0 @@
-language: php
-
-sudo: false
-
-cache:
-  directories:
-    - $HOME/.composer/cache/files
-
-matrix:
-  include:
-    - php: 5.3
-    - php: 5.4
-    - php: 5.5
-    - php: 5.6
-    - php: hhvm
-    - php: nightly
-    - php: 7.0
-      env: COVERAGE=yes
-    - php: 7.0
-      env: COMPOSER_FLAGS='--prefer-lowest --prefer-stable'
-  allow_failures:
-    - php: hhvm
-    - php: nightly
-  fast_finish: true
-
-before_install:
-  - if [[ $TRAVIS_PHP_VERSION != hhvm && $COVERAGE != yes ]]; then phpenv config-rm xdebug.ini; fi;
-  - if [[ $TRAVIS_REPO_SLUG = webmozart/assert ]]; then cp .composer-auth.json ~/.composer/auth.json; fi;
-  - composer self-update
-
-install: composer update $COMPOSER_FLAGS --prefer-dist --no-interaction
-
-script: if [[ $COVERAGE = yes ]]; then vendor/bin/phpunit --verbose --coverage-clover=coverage.clover; else vendor/bin/phpunit --verbose; 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

vendor/webmozart/assert/CHANGELOG.md

@@ -1,7 +1,32 @@
 Changelog
 =========
 
-* 1.1.0 (2016-08-09)
+## UNRELEASED
+
+### 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
+
+## 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()`
@@ -10,19 +35,19 @@ Changelog
  * added `Assert::methodNotExists()`
  * added `Assert::uuid()`
 
-* 1.0.2 (2015-08-24)
+## 1.0.2 (2015-08-24)
 
  * integrated Style CI
  * add tests for minimum package dependencies on Travis CI
 
-* 1.0.1 (2015-05-12)
+## 1.0.1 (2015-05-12)
 
  * added support for PHP 5.3.3
 
-* 1.0.0 (2015-05-12)
+## 1.0.0 (2015-05-12)
 
  * first stable release
 
-* 1.0.0-beta (2015-03-19)
+## 1.0.0-beta (2015-03-19)
 
  * first beta release

vendor/webmozart/assert/README.md

@@ -1,13 +1,13 @@
 Webmozart Assert
 ================
 
-[![Build Status](https://travis-ci.org/webmozart/assert.svg?branch=1.1.0)](https://travis-ci.org/webmozart/assert)
+[![Build Status](https://travis-ci.org/webmozart/assert.svg?branch=master)](https://travis-ci.org/webmozart/assert)
 [![Build status](https://ci.appveyor.com/api/projects/status/lyg83bcsisrr94se/branch/master?svg=true)](https://ci.appveyor.com/project/webmozart/assert/branch/master)
 [![Latest Stable Version](https://poser.pugx.org/webmozart/assert/v/stable.svg)](https://packagist.org/packages/webmozart/assert)
 [![Total Downloads](https://poser.pugx.org/webmozart/assert/downloads.svg)](https://packagist.org/packages/webmozart/assert)
-[![Dependency Status](https://www.versioneye.com/php/webmozart:assert/1.1.0/badge.svg)](https://www.versioneye.com/php/webmozart:assert/1.1.0)
+[![Dependency Status](https://www.versioneye.com/php/webmozart:assert/1.2.0/badge.svg)](https://www.versioneye.com/php/webmozart:assert/1.2.0)
 
-Latest release: [1.1.0](https://packagist.org/packages/webmozart/assert#1.1.0)
+Latest release: [1.2.0](https://packagist.org/packages/webmozart/assert#1.2.0)
 
 PHP >= 5.3.9
 
@@ -89,23 +89,28 @@ 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
-`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 = '')`          | Check that a value is an array or a `\Traversable`
-`isInstanceOf($value, $class, $message = '')`   | Check that a value is an `instanceof` a class
-`notInstanceOf($value, $class, $message = '')`  | Check that a value is not an `instanceof` a class
+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
+`isArrayAccessible($value, $message = '')`               | Check that a value can be accessed as an array
 
 ### Comparison Assertions
 
@@ -134,8 +139,9 @@ 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
@@ -150,6 +156,7 @@ Method                                              | Description
 `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
+`notWhitespaceOnly($value, $message = '')`          | Check that a string contains at least one non-whitespace character
 
 ### File Assertions
 
@@ -175,10 +182,20 @@ Method                                                | Description
 
 ### 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
+`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
+
+### Function 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
+------------------------------------------- | -----------------------------------------------------------------------------------------------------
+`throws($closure, $class, $message = '')`   | Check that a function throws a certain exception. Subclasses of the exception class will be accepted.
 
 ### Collection Assertions
 
@@ -186,7 +203,7 @@ All of the above assertions can be prefixed with `all*()` to test the contents
 of an array or a `\Traversable`:
 
 ```php
-Assert::allIsInstanceOf('Acme\Employee', $employees);
+Assert::allIsInstanceOf($employees, 'Acme\Employee');
 ```
 
 ### Nullable Assertions
@@ -228,7 +245,7 @@ All contents of this package are licensed under the [MIT license].
 [Composer]: https://getcomposer.org
 [Bernhard Schussek]: http://webmozarts.com
 [The Community Contributors]: https://github.com/webmozart/assert/graphs/contributors
-[issue tracker]: https://github.com/webmozart/assert
+[issue tracker]: https://github.com/webmozart/assert/issues
 [Git repository]: https://github.com/webmozart/assert
 [@webmozart]: https://twitter.com/webmozart
 [MIT license]: LICENSE

vendor/webmozart/assert/appveyor.yml

@@ -1,36 +0,0 @@
-build: false
-platform: x86
-clone_folder: c:\projects\webmozart\assert
-
-cache:
-  - c:\php -> appveyor.yml
-
-init:
-  - SET PATH=c:\php;%PATH%
-  - SET COMPOSER_NO_INTERACTION=1
-  - SET PHP=1
-
-install:
-  - IF EXIST c:\php (SET PHP=0) ELSE (mkdir c:\php)
-  - cd c:\php
-  - IF %PHP%==1 appveyor DownloadFile http://windows.php.net/downloads/releases/archives/php-7.0.0-nts-Win32-VC14-x86.zip
-  - IF %PHP%==1 7z x php-7.0.0-nts-Win32-VC14-x86.zip -y >nul
-  - IF %PHP%==1 del /Q *.zip
-  - IF %PHP%==1 echo @php %%~dp0composer.phar %%* > composer.bat
-  - IF %PHP%==1 copy /Y php.ini-development php.ini
-  - IF %PHP%==1 echo max_execution_time=1200 >> php.ini
-  - IF %PHP%==1 echo date.timezone="UTC" >> php.ini
-  - IF %PHP%==1 echo extension_dir=ext >> php.ini
-  - IF %PHP%==1 echo extension=php_curl.dll >> php.ini
-  - IF %PHP%==1 echo extension=php_openssl.dll >> php.ini
-  - IF %PHP%==1 echo extension=php_mbstring.dll >> php.ini
-  - IF %PHP%==1 echo extension=php_fileinfo.dll >> php.ini
-  - appveyor DownloadFile https://getcomposer.org/composer.phar
-  - cd c:\projects\webmozart\assert
-  - mkdir %APPDATA%\Composer
-  - IF %APPVEYOR_REPO_NAME%==webmozart/assert copy /Y .composer-auth.json %APPDATA%\Composer\auth.json
-  - composer update --prefer-dist --no-progress --ansi
-
-test_script:
-  - cd c:\projects\webmozart\assert
-  - vendor\bin\phpunit.bat --verbose

vendor/webmozart/assert/composer.json

@@ -10,7 +10,7 @@
         }
     ],
     "require": {
-        "php": "^5.3.3|^7.0"
+        "php": "^5.3.3 || ^7.0"
     },
     "require-dev": {
         "phpunit/phpunit": "^4.6",
@@ -28,7 +28,7 @@
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "1.2-dev"
+            "dev-master": "1.3-dev"
         }
     }
 }

vendor/webmozart/assert/phpunit.xml.dist

@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<phpunit bootstrap="vendor/autoload.php" colors="true">
-    <testsuites>
-        <testsuite name="Webmozart Assert Test Suite">
-            <directory suffix="Test.php">./tests/</directory>
-        </testsuite>
-    </testsuites>
-
-    <!-- Whitelist for code coverage -->
-    <filter>
-        <whitelist>
-            <directory suffix=".php">./src/</directory>
-        </whitelist>
-    </filter>
-</phpunit>

vendor/webmozart/assert/src/Assert.php

@@ -11,8 +11,13 @@
 
 namespace Webmozart\Assert;
 
+use ArrayAccess;
 use BadMethodCallException;
+use Closure;
+use Countable;
+use Exception;
 use InvalidArgumentException;
+use Throwable;
 use Traversable;
 
 /**
@@ -31,8 +36,11 @@ use Traversable;
  * @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 nullOrIsInstanceOf($value, $class, $message = '')
  * @method static void nullOrNotInstanceOf($value, $class, $message = '')
+ * @method static void nullOrIsInstanceOfAny($value, $classes, $message = '')
  * @method static void nullOrIsEmpty($value, $message = '')
  * @method static void nullOrNotEmpty($value, $message = '')
  * @method static void nullOrTrue($value, $message = '')
@@ -48,6 +56,8 @@ use Traversable;
  * @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 = '')
@@ -75,6 +85,10 @@ use Traversable;
  * @method static void nullOrMethodNotExists($value, $method, $message = '')
  * @method static void nullOrKeyExists($value, $key, $message = '')
  * @method static void nullOrKeyNotExists($value, $key, $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 nullCountBetween($value, $min, $max, $message = '')
  * @method static void nullOrUuid($values, $message = '')
  * @method static void allString($values, $message = '')
  * @method static void allStringNotEmpty($values, $message = '')
@@ -89,8 +103,11 @@ use Traversable;
  * @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 allIsInstanceOf($values, $class, $message = '')
  * @method static void allNotInstanceOf($values, $class, $message = '')
+ * @method static void allIsInstanceOfAny($values, $classes, $message = '')
  * @method static void allNull($values, $message = '')
  * @method static void allNotNull($values, $message = '')
  * @method static void allIsEmpty($values, $message = '')
@@ -108,6 +125,8 @@ use Traversable;
  * @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 = '')
@@ -135,6 +154,10 @@ use Traversable;
  * @method static void allMethodNotExists($values, $method, $message = '')
  * @method static void allKeyExists($values, $key, $message = '')
  * @method static void allKeyNotExists($values, $key, $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 allUuid($values, $message = '')
  *
  * @since  1.0
@@ -146,25 +169,25 @@ class Assert
     public static function string($value, $message = '')
     {
         if (!is_string($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a string. Got: %s',
-                self::typeToString($value)
+                static::typeToString($value)
             ));
         }
     }
 
     public static function stringNotEmpty($value, $message = '')
     {
-        self::string($value, $message);
-        self::notEmpty($value, $message);
+        static::string($value, $message);
+        static::notEq($value, '', $message);
     }
 
     public static function integer($value, $message = '')
     {
         if (!is_int($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected an integer. Got: %s',
-                self::typeToString($value)
+                static::typeToString($value)
             ));
         }
     }
@@ -172,9 +195,9 @@ class Assert
     public static function integerish($value, $message = '')
     {
         if (!is_numeric($value) || $value != (int) $value) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected an integerish value. Got: %s',
-                self::typeToString($value)
+                static::typeToString($value)
             ));
         }
     }
@@ -182,9 +205,9 @@ class Assert
     public static function float($value, $message = '')
     {
         if (!is_float($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a float. Got: %s',
-                self::typeToString($value)
+                static::typeToString($value)
             ));
         }
     }
@@ -192,9 +215,19 @@ class Assert
     public static function numeric($value, $message = '')
     {
         if (!is_numeric($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a numeric. Got: %s',
-                self::typeToString($value)
+                static::typeToString($value)
+            ));
+        }
+    }
+
+    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)
             ));
         }
     }
@@ -202,9 +235,9 @@ class Assert
     public static function boolean($value, $message = '')
     {
         if (!is_bool($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a boolean. Got: %s',
-                self::typeToString($value)
+                static::typeToString($value)
             ));
         }
     }
@@ -212,9 +245,9 @@ class Assert
     public static function scalar($value, $message = '')
     {
         if (!is_scalar($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a scalar. Got: %s',
-                self::typeToString($value)
+                static::typeToString($value)
             ));
         }
     }
@@ -222,9 +255,9 @@ class Assert
     public static function object($value, $message = '')
     {
         if (!is_object($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected an object. Got: %s',
-                self::typeToString($value)
+                static::typeToString($value)
             ));
         }
     }
@@ -232,16 +265,16 @@ class Assert
     public static function resource($value, $type = null, $message = '')
     {
         if (!is_resource($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a resource. Got: %s',
-                self::typeToString($value)
+                static::typeToString($value)
             ));
         }
 
         if ($type && $type !== get_resource_type($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a resource of type %2$s. Got: %s',
-                self::typeToString($value),
+                static::typeToString($value),
                 $type
             ));
         }
@@ -250,9 +283,9 @@ class Assert
     public static function isCallable($value, $message = '')
     {
         if (!is_callable($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a callable. Got: %s',
-                self::typeToString($value)
+                static::typeToString($value)
             ));
         }
     }
@@ -260,19 +293,57 @@ class Assert
     public static function isArray($value, $message = '')
     {
         if (!is_array($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected an array. Got: %s',
-                self::typeToString($value)
+                static::typeToString($value)
             ));
         }
     }
 
     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)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a traversable. Got: %s',
-                self::typeToString($value)
+                static::typeToString($value)
+            ));
+        }
+    }
+
+    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)
+            ));
+        }
+    }
+
+    public static function isCountable($value, $message = '')
+    {
+        if (!is_array($value) && !($value instanceof Countable)) {
+            static::reportInvalidArgument(sprintf(
+                $message ?: 'Expected a countable. Got: %s',
+                static::typeToString($value)
+            ));
+        }
+    }
+
+    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)
             ));
         }
     }
@@ -280,9 +351,9 @@ class Assert
     public static function isInstanceOf($value, $class, $message = '')
     {
         if (!($value instanceof $class)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected an instance of %2$s. Got: %s',
-                self::typeToString($value),
+                static::typeToString($value),
                 $class
             ));
         }
@@ -291,20 +362,35 @@ class Assert
     public static function notInstanceOf($value, $class, $message = '')
     {
         if ($value instanceof $class) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected an instance other than %2$s. Got: %s',
-                self::typeToString($value),
+                static::typeToString($value),
                 $class
             ));
         }
     }
 
+    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))
+        ));
+    }
+
     public static function isEmpty($value, $message = '')
     {
         if (!empty($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected an empty value. Got: %s',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
@@ -312,9 +398,9 @@ class Assert
     public static function notEmpty($value, $message = '')
     {
         if (empty($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a non-empty value. Got: %s',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
@@ -322,9 +408,9 @@ class Assert
     public static function null($value, $message = '')
     {
         if (null !== $value) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected null. Got: %s',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
@@ -332,7 +418,7 @@ class Assert
     public static function notNull($value, $message = '')
     {
         if (null === $value) {
-            throw new InvalidArgumentException(
+            static::reportInvalidArgument(
                 $message ?: 'Expected a value other than null.'
             );
         }
@@ -341,9 +427,9 @@ class Assert
     public static function true($value, $message = '')
     {
         if (true !== $value) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value to be true. Got: %s',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
@@ -351,9 +437,9 @@ class Assert
     public static function false($value, $message = '')
     {
         if (false !== $value) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value to be false. Got: %s',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
@@ -361,10 +447,10 @@ class Assert
     public static function eq($value, $value2, $message = '')
     {
         if ($value2 != $value) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value equal to %2$s. Got: %s',
-                self::valueToString($value),
-                self::valueToString($value2)
+                static::valueToString($value),
+                static::valueToString($value2)
             ));
         }
     }
@@ -372,9 +458,9 @@ class Assert
     public static function notEq($value, $value2, $message = '')
     {
         if ($value2 == $value) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a different value than %s.',
-                self::valueToString($value2)
+                static::valueToString($value2)
             ));
         }
     }
@@ -382,10 +468,10 @@ class Assert
     public static function same($value, $value2, $message = '')
     {
         if ($value2 !== $value) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value identical to %2$s. Got: %s',
-                self::valueToString($value),
-                self::valueToString($value2)
+                static::valueToString($value),
+                static::valueToString($value2)
             ));
         }
     }
@@ -393,9 +479,9 @@ class Assert
     public static function notSame($value, $value2, $message = '')
     {
         if ($value2 === $value) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value not identical to %s.',
-                self::valueToString($value2)
+                static::valueToString($value2)
             ));
         }
     }
@@ -403,10 +489,10 @@ class Assert
     public static function greaterThan($value, $limit, $message = '')
     {
         if ($value <= $limit) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value greater than %2$s. Got: %s',
-                self::valueToString($value),
-                self::valueToString($limit)
+                static::valueToString($value),
+                static::valueToString($limit)
             ));
         }
     }
@@ -414,10 +500,10 @@ class Assert
     public static function greaterThanEq($value, $limit, $message = '')
     {
         if ($value < $limit) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value greater than or equal to %2$s. Got: %s',
-                self::valueToString($value),
-                self::valueToString($limit)
+                static::valueToString($value),
+                static::valueToString($limit)
             ));
         }
     }
@@ -425,10 +511,10 @@ class Assert
     public static function lessThan($value, $limit, $message = '')
     {
         if ($value >= $limit) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value less than %2$s. Got: %s',
-                self::valueToString($value),
-                self::valueToString($limit)
+                static::valueToString($value),
+                static::valueToString($limit)
             ));
         }
     }
@@ -436,10 +522,10 @@ class Assert
     public static function lessThanEq($value, $limit, $message = '')
     {
         if ($value > $limit) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value less than or equal to %2$s. Got: %s',
-                self::valueToString($value),
-                self::valueToString($limit)
+                static::valueToString($value),
+                static::valueToString($limit)
             ));
         }
     }
@@ -447,11 +533,11 @@ class Assert
     public static function range($value, $min, $max, $message = '')
     {
         if ($value < $min || $value > $max) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value between %2$s and %3$s. Got: %s',
-                self::valueToString($value),
-                self::valueToString($min),
-                self::valueToString($max)
+                static::valueToString($value),
+                static::valueToString($min),
+                static::valueToString($max)
             ));
         }
     }
@@ -459,10 +545,10 @@ class Assert
     public static function oneOf($value, array $values, $message = '')
     {
         if (!in_array($value, $values, true)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected one of: %2$s. Got: %s',
-                self::valueToString($value),
-                implode(', ', array_map(array(__CLASS__, 'valueToString'), $values))
+                static::valueToString($value),
+                implode(', ', array_map(array('static', 'valueToString'), $values))
             ));
         }
     }
@@ -470,10 +556,31 @@ class Assert
     public static function contains($value, $subString, $message = '')
     {
         if (false === strpos($value, $subString)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value to contain %2$s. Got: %s',
-                self::valueToString($value),
-                self::valueToString($subString)
+                static::valueToString($value),
+                static::valueToString($subString)
+            ));
+        }
+    }
+
+    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)
+            ));
+        }
+    }
+
+    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)
             ));
         }
     }
@@ -481,10 +588,10 @@ class Assert
     public static function startsWith($value, $prefix, $message = '')
     {
         if (0 !== strpos($value, $prefix)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value to start with %2$s. Got: %s',
-                self::valueToString($value),
-                self::valueToString($prefix)
+                static::valueToString($value),
+                static::valueToString($prefix)
             ));
         }
     }
@@ -501,20 +608,20 @@ class Assert
         }
 
         if (!$valid) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value to start with a letter. Got: %s',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
 
     public static function endsWith($value, $suffix, $message = '')
     {
-        if ($suffix !== substr($value, -self::strlen($suffix))) {
-            throw new InvalidArgumentException(sprintf(
+        if ($suffix !== substr($value, -static::strlen($suffix))) {
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value to end with %2$s. Got: %s',
-                self::valueToString($value),
-                self::valueToString($suffix)
+                static::valueToString($value),
+                static::valueToString($suffix)
             ));
         }
     }
@@ -522,9 +629,9 @@ class Assert
     public static function regex($value, $pattern, $message = '')
     {
         if (!preg_match($pattern, $value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'The value %s does not match the expected pattern.',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
@@ -537,9 +644,9 @@ class Assert
         setlocale(LC_CTYPE, $locale);
 
         if ($valid) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value to contain only letters. Got: %s',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
@@ -552,9 +659,9 @@ class Assert
         setlocale(LC_CTYPE, $locale);
 
         if ($valid) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value to contain digits only. Got: %s',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
@@ -567,9 +674,9 @@ class Assert
         setlocale(LC_CTYPE, $locale);
 
         if ($valid) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value to contain letters and digits only. Got: %s',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
@@ -582,9 +689,9 @@ class Assert
         setlocale(LC_CTYPE, $locale);
 
         if ($valid) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value to contain lowercase characters only. Got: %s',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
@@ -597,19 +704,19 @@ class Assert
         setlocale(LC_CTYPE, $locale);
 
         if ($valid) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value to contain uppercase characters only. Got: %s',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
 
     public static function length($value, $length, $message = '')
     {
-        if ($length !== self::strlen($value)) {
-            throw new InvalidArgumentException(sprintf(
+        if ($length !== static::strlen($value)) {
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value to contain %2$s characters. Got: %s',
-                self::valueToString($value),
+                static::valueToString($value),
                 $length
             ));
         }
@@ -617,10 +724,10 @@ class Assert
 
     public static function minLength($value, $min, $message = '')
     {
-        if (self::strlen($value) < $min) {
-            throw new InvalidArgumentException(sprintf(
+        if (static::strlen($value) < $min) {
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value to contain at least %2$s characters. Got: %s',
-                self::valueToString($value),
+                static::valueToString($value),
                 $min
             ));
         }
@@ -628,10 +735,10 @@ class Assert
 
     public static function maxLength($value, $max, $message = '')
     {
-        if (self::strlen($value) > $max) {
-            throw new InvalidArgumentException(sprintf(
+        if (static::strlen($value) > $max) {
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value to contain at most %2$s characters. Got: %s',
-                self::valueToString($value),
+                static::valueToString($value),
                 $max
             ));
         }
@@ -639,12 +746,12 @@ class Assert
 
     public static function lengthBetween($value, $min, $max, $message = '')
     {
-        $length = self::strlen($value);
+        $length = static::strlen($value);
 
         if ($length < $min || $length > $max) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a value to contain between %2$s and %3$s characters. Got: %s',
-                self::valueToString($value),
+                static::valueToString($value),
                 $min,
                 $max
             ));
@@ -653,36 +760,36 @@ class Assert
 
     public static function fileExists($value, $message = '')
     {
-        self::string($value);
+        static::string($value);
 
         if (!file_exists($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'The file %s does not exist.',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
 
     public static function file($value, $message = '')
     {
-        self::fileExists($value, $message);
+        static::fileExists($value, $message);
 
         if (!is_file($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'The path %s is not a file.',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
 
     public static function directory($value, $message = '')
     {
-        self::fileExists($value, $message);
+        static::fileExists($value, $message);
 
         if (!is_dir($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'The path %s is no directory.',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
@@ -690,9 +797,9 @@ class Assert
     public static function readable($value, $message = '')
     {
         if (!is_readable($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'The path %s is not readable.',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
@@ -700,9 +807,9 @@ class Assert
     public static function writable($value, $message = '')
     {
         if (!is_writable($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'The path %s is not writable.',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
@@ -710,9 +817,9 @@ class Assert
     public static function classExists($value, $message = '')
     {
         if (!class_exists($value)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected an existing class name. Got: %s',
-                self::valueToString($value)
+                static::valueToString($value)
             ));
         }
     }
@@ -720,10 +827,10 @@ class Assert
     public static function subclassOf($value, $class, $message = '')
     {
         if (!is_subclass_of($value, $class)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected a sub-class of %2$s. Got: %s',
-                self::valueToString($value),
-                self::valueToString($class)
+                static::valueToString($value),
+                static::valueToString($class)
             ));
         }
     }
@@ -731,10 +838,10 @@ class Assert
     public static function implementsInterface($value, $interface, $message = '')
     {
         if (!in_array($interface, class_implements($value))) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected an implementation of %2$s. Got: %s',
-                self::valueToString($value),
-                self::valueToString($interface)
+                static::valueToString($value),
+                static::valueToString($interface)
             ));
         }
     }
@@ -742,9 +849,9 @@ class Assert
     public static function propertyExists($classOrObject, $property, $message = '')
     {
         if (!property_exists($classOrObject, $property)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected the property %s to exist.',
-                self::valueToString($property)
+                static::valueToString($property)
             ));
         }
     }
@@ -752,9 +859,9 @@ class Assert
     public static function propertyNotExists($classOrObject, $property, $message = '')
     {
         if (property_exists($classOrObject, $property)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected the property %s to not exist.',
-                self::valueToString($property)
+                static::valueToString($property)
             ));
         }
     }
@@ -762,9 +869,9 @@ class Assert
     public static function methodExists($classOrObject, $method, $message = '')
     {
         if (!method_exists($classOrObject, $method)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected the method %s to exist.',
-                self::valueToString($method)
+                static::valueToString($method)
             ));
         }
     }
@@ -772,9 +879,9 @@ class Assert
     public static function methodNotExists($classOrObject, $method, $message = '')
     {
         if (method_exists($classOrObject, $method)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected the method %s to not exist.',
-                self::valueToString($method)
+                static::valueToString($method)
             ));
         }
     }
@@ -782,9 +889,9 @@ class Assert
     public static function keyExists($array, $key, $message = '')
     {
         if (!array_key_exists($key, $array)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected the key %s to exist.',
-                self::valueToString($key)
+                static::valueToString($key)
             ));
         }
     }
@@ -792,9 +899,54 @@ class Assert
     public static function keyNotExists($array, $key, $message = '')
     {
         if (array_key_exists($key, $array)) {
-            throw new InvalidArgumentException(sprintf(
+            static::reportInvalidArgument(sprintf(
                 $message ?: 'Expected the key %s to not exist.',
-                self::valueToString($key)
+                static::valueToString($key)
+            ));
+        }
+    }
+
+    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))
+        );
+    }
+
+    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
+            ));
+        }
+    }
+
+    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
+            ));
+        }
+    }
+
+    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
             ));
         }
     }
@@ -810,13 +962,40 @@ class Assert
         }
 
         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)) {
-            throw new InvalidArgumentException(sprintf(
-                $message ?: 'Value "%s" is not a valid UUID.',
-                self::valueToString($value)
+            static::reportInvalidArgument(sprintf(
+                $message ?: 'Value %s is not a valid UUID.',
+                static::valueToString($value)
             ));
         }
     }
 
+    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
+        ));
+    }
+
     public static function __callStatic($name, $arguments)
     {
         if ('nullOr' === substr($name, 0, 6)) {
@@ -829,7 +1008,7 @@ class Assert
         }
 
         if ('all' === substr($name, 0, 3)) {
-            self::isTraversable($arguments[0]);
+            static::isIterable($arguments[0]);
 
             $method = lcfirst(substr($name, 3));
             $args = $arguments;
@@ -897,6 +1076,11 @@ class Assert
         return mb_strwidth($value, $encoding);
     }
 
+    protected static function reportInvalidArgument($message)
+    {
+        throw new InvalidArgumentException($message);
+    }
+
     private function __construct()
     {
     }

vendor/webmozart/assert/tests/AssertTest.php

@@ -1,422 +0,0 @@
-<?php
-
-/*
- * This file is part of the webmozart/assert package.
- *
- * (c) Bernhard Schussek <bschussek@gmail.com>
- *
- * 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 Exception;
-use PHPUnit_Framework_TestCase;
-use RuntimeException;
-use stdClass;
-use Webmozart\Assert\Assert;
-
-/**
- * @since  1.0
- *
- * @author Bernhard Schussek <bschussek@gmail.com>
- */
-class AssertTest extends PHPUnit_Framework_TestCase
-{
-    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(''), 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('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('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('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('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('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('startsWith', array('abcd', 'ab'), true),
-            array('startsWith', array('abcd', 'bc'), false),
-            array('startsWith', array('', 'bc'), false),
-            array('startsWithLetter', array('abcd'), true),
-            array('startsWithLetter', array('1abcd'), false),
-            array('startsWithLetter', array(''), false),
-            array('endsWith', array('abcd', 'cd'), true),
-            array('endsWith', array('abcd', 'bc'), false),
-            array('endsWith', array('', 'bc'), false),
-            array('regex', array('abcd', '~^ab~'), true),
-            array('regex', array('abcd', '~^bc~'), false),
-            array('regex', array('', '~^bc~'), false),
-            array('alpha', array('abcd'), true),
-            array('alpha', array('ab1cd'), false),
-            array('alpha', 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('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('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('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('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__, 'PHPUnit_Framework_TestCase'), true),
-            array('subclassOf', array(__CLASS__, 'stdClass'), 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('uuid', array('00000000-0000-0000-0000-000000000000'), 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),
-
-        );
-    }
-
-    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)
-    {
-        if ($multibyte && !function_exists('mb_strlen')) {
-            $this->markTestSkipped('The fucntion mb_strlen() is not available');
-
-            return;
-        }
-
-        if (!$success) {
-            $this->setExpectedException('\InvalidArgumentException');
-        }
-
-        call_user_func_array(array('Webmozart\Assert\Assert', $method), $args);
-    }
-
-    /**
-     * @dataProvider getTests
-     */
-    public function testNullOr($method, $args, $success, $multibyte = false)
-    {
-        if ($multibyte && !function_exists('mb_strlen')) {
-            $this->markTestSkipped('The fucntion mb_strlen() is not available');
-
-            return;
-        }
-
-        if (!$success && null !== reset($args)) {
-            $this->setExpectedException('\InvalidArgumentException');
-        }
-
-        call_user_func_array(array('Webmozart\Assert\Assert', 'nullOr'.ucfirst($method)), $args);
-    }
-
-    /**
-     * @dataProvider getMethods
-     */
-    public function testNullOrAcceptsNull($method)
-    {
-        call_user_func(array('Webmozart\Assert\Assert', 'nullOr'.ucfirst($method)), null);
-    }
-
-    /**
-     * @dataProvider getTests
-     */
-    public function testAllArray($method, $args, $success, $multibyte = false)
-    {
-        if ($multibyte && !function_exists('mb_strlen')) {
-            $this->markTestSkipped('The fucntion mb_strlen() is not available');
-
-            return;
-        }
-
-        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);
-    }
-
-    /**
-     * @dataProvider getTests
-     */
-    public function testAllTraversable($method, $args, $success, $multibyte = false)
-    {
-        if ($multibyte && !function_exists('mb_strlen')) {
-            $this->markTestSkipped('The fucntion mb_strlen() is not available');
-
-            return;
-        }
-
-        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);
-    }
-
-    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(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);
-    }
-}