chillerlan / php-traits

vendor/phpunit/phpunit/src/Framework/BaseTestListener.php

Indentation +1 added lines, -1 removed lines

@@ -16,5 +16,5 @@
  */
 abstract class BaseTestListener implements TestListener
 {
-    use TestListenerDefaultImplementation;
+	use TestListenerDefaultImplementation;
 }

vendor/phpunit/phpunit/src/Framework/Assert.php

Indentation +2848 added lines, -2848 removed lines

@@ -69,2852 +69,2852 @@
  */
 abstract class Assert
 {
-    /**
-     * @var int
-     */
-    private static $count = 0;
-
-    /**
-     * Asserts that an array has a specified key.
-     *
-     * @param mixed             $key
-     * @param array|ArrayAccess $array
-     * @param string            $message
-     */
-    public static function assertArrayHasKey($key, $array, $message = '')
-    {
-        if (!(\is_int($key) || \is_string($key))) {
-            throw InvalidArgumentHelper::factory(
-                1,
-                'integer or string'
-            );
-        }
-
-        if (!(\is_array($array) || $array instanceof ArrayAccess)) {
-            throw InvalidArgumentHelper::factory(
-                2,
-                'array or ArrayAccess'
-            );
-        }
-
-        $constraint = new ArrayHasKey($key);
-
-        static::assertThat($array, $constraint, $message);
-    }
-
-    /**
-     * Asserts that an array has a specified subset.
-     *
-     * @param array|ArrayAccess $subset
-     * @param array|ArrayAccess $array
-     * @param bool              $strict  Check for object identity
-     * @param string            $message
-     */
-    public static function assertArraySubset($subset, $array, $strict = false, $message = '')
-    {
-        if (!(\is_array($subset) || $subset instanceof ArrayAccess)) {
-            throw InvalidArgumentHelper::factory(
-                1,
-                'array or ArrayAccess'
-            );
-        }
-
-        if (!(\is_array($array) || $array instanceof ArrayAccess)) {
-            throw InvalidArgumentHelper::factory(
-                2,
-                'array or ArrayAccess'
-            );
-        }
-
-        $constraint = new ArraySubset($subset, $strict);
-
-        static::assertThat($array, $constraint, $message);
-    }
-
-    /**
-     * Asserts that an array does not have a specified key.
-     *
-     * @param mixed             $key
-     * @param array|ArrayAccess $array
-     * @param string            $message
-     */
-    public static function assertArrayNotHasKey($key, $array, $message = '')
-    {
-        if (!(\is_int($key) || \is_string($key))) {
-            throw InvalidArgumentHelper::factory(
-                1,
-                'integer or string'
-            );
-        }
-
-        if (!(\is_array($array) || $array instanceof ArrayAccess)) {
-            throw InvalidArgumentHelper::factory(
-                2,
-                'array or ArrayAccess'
-            );
-        }
-
-        $constraint = new LogicalNot(
-            new ArrayHasKey($key)
-        );
-
-        static::assertThat($array, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a haystack contains a needle.
-     *
-     * @param mixed  $needle
-     * @param mixed  $haystack
-     * @param string $message
-     * @param bool   $ignoreCase
-     * @param bool   $checkForObjectIdentity
-     * @param bool   $checkForNonObjectIdentity
-     */
-    public static function assertContains($needle, $haystack, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
-    {
-        if (\is_array($haystack) ||
-            (\is_object($haystack) && $haystack instanceof Traversable)) {
-            $constraint = new TraversableContains(
-                $needle,
-                $checkForObjectIdentity,
-                $checkForNonObjectIdentity
-            );
-        } elseif (\is_string($haystack)) {
-            if (!\is_string($needle)) {
-                throw InvalidArgumentHelper::factory(
-                    1,
-                    'string'
-                );
-            }
-
-            $constraint = new StringContains(
-                $needle,
-                $ignoreCase
-            );
-        } else {
-            throw InvalidArgumentHelper::factory(
-                2,
-                'array, traversable or string'
-            );
-        }
-
-        static::assertThat($haystack, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a haystack that is stored in a static attribute of a class
-     * or an attribute of an object contains a needle.
-     *
-     * @param mixed         $needle
-     * @param string        $haystackAttributeName
-     * @param string|object $haystackClassOrObject
-     * @param string        $message
-     * @param bool          $ignoreCase
-     * @param bool          $checkForObjectIdentity
-     * @param bool          $checkForNonObjectIdentity
-     */
-    public static function assertAttributeContains($needle, $haystackAttributeName, $haystackClassOrObject, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
-    {
-        static::assertContains(
-            $needle,
-            static::readAttribute($haystackClassOrObject, $haystackAttributeName),
-            $message,
-            $ignoreCase,
-            $checkForObjectIdentity,
-            $checkForNonObjectIdentity
-        );
-    }
-
-    /**
-     * Asserts that a haystack does not contain a needle.
-     *
-     * @param mixed  $needle
-     * @param mixed  $haystack
-     * @param string $message
-     * @param bool   $ignoreCase
-     * @param bool   $checkForObjectIdentity
-     * @param bool   $checkForNonObjectIdentity
-     */
-    public static function assertNotContains($needle, $haystack, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
-    {
-        if (\is_array($haystack) ||
-            (\is_object($haystack) && $haystack instanceof Traversable)) {
-            $constraint = new LogicalNot(
-                new TraversableContains(
-                    $needle,
-                    $checkForObjectIdentity,
-                    $checkForNonObjectIdentity
-                )
-            );
-        } elseif (\is_string($haystack)) {
-            if (!\is_string($needle)) {
-                throw InvalidArgumentHelper::factory(
-                    1,
-                    'string'
-                );
-            }
-
-            $constraint = new LogicalNot(
-                new StringContains(
-                    $needle,
-                    $ignoreCase
-                )
-            );
-        } else {
-            throw InvalidArgumentHelper::factory(
-                2,
-                'array, traversable or string'
-            );
-        }
-
-        static::assertThat($haystack, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a haystack that is stored in a static attribute of a class
-     * or an attribute of an object does not contain a needle.
-     *
-     * @param mixed         $needle
-     * @param string        $haystackAttributeName
-     * @param string|object $haystackClassOrObject
-     * @param string        $message
-     * @param bool          $ignoreCase
-     * @param bool          $checkForObjectIdentity
-     * @param bool          $checkForNonObjectIdentity
-     */
-    public static function assertAttributeNotContains($needle, $haystackAttributeName, $haystackClassOrObject, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
-    {
-        static::assertNotContains(
-            $needle,
-            static::readAttribute($haystackClassOrObject, $haystackAttributeName),
-            $message,
-            $ignoreCase,
-            $checkForObjectIdentity,
-            $checkForNonObjectIdentity
-        );
-    }
-
-    /**
-     * Asserts that a haystack contains only values of a given type.
-     *
-     * @param string $type
-     * @param mixed  $haystack
-     * @param bool   $isNativeType
-     * @param string $message
-     */
-    public static function assertContainsOnly($type, $haystack, $isNativeType = null, $message = '')
-    {
-        if (!\is_array($haystack) &&
-            !(\is_object($haystack) && $haystack instanceof Traversable)) {
-            throw InvalidArgumentHelper::factory(
-                2,
-                'array or traversable'
-            );
-        }
-
-        if ($isNativeType == null) {
-            $isNativeType = Type::isType($type);
-        }
-
-        static::assertThat(
-            $haystack,
-            new TraversableContainsOnly(
-                $type,
-                $isNativeType
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a haystack contains only instances of a given classname
-     *
-     * @param string             $classname
-     * @param array|\Traversable $haystack
-     * @param string             $message
-     */
-    public static function assertContainsOnlyInstancesOf($classname, $haystack, $message = '')
-    {
-        if (!\is_array($haystack) &&
-            !(\is_object($haystack) && $haystack instanceof Traversable)) {
-            throw InvalidArgumentHelper::factory(
-                2,
-                'array or traversable'
-            );
-        }
-
-        static::assertThat(
-            $haystack,
-            new TraversableContainsOnly(
-                $classname,
-                false
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a haystack that is stored in a static attribute of a class
-     * or an attribute of an object contains only values of a given type.
-     *
-     * @param string        $type
-     * @param string        $haystackAttributeName
-     * @param string|object $haystackClassOrObject
-     * @param bool          $isNativeType
-     * @param string        $message
-     */
-    public static function assertAttributeContainsOnly($type, $haystackAttributeName, $haystackClassOrObject, $isNativeType = null, $message = '')
-    {
-        static::assertContainsOnly(
-            $type,
-            static::readAttribute($haystackClassOrObject, $haystackAttributeName),
-            $isNativeType,
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a haystack does not contain only values of a given type.
-     *
-     * @param string $type
-     * @param mixed  $haystack
-     * @param bool   $isNativeType
-     * @param string $message
-     */
-    public static function assertNotContainsOnly($type, $haystack, $isNativeType = null, $message = '')
-    {
-        if (!\is_array($haystack) &&
-            !(\is_object($haystack) && $haystack instanceof Traversable)) {
-            throw InvalidArgumentHelper::factory(
-                2,
-                'array or traversable'
-            );
-        }
-
-        if ($isNativeType == null) {
-            $isNativeType = Type::isType($type);
-        }
-
-        static::assertThat(
-            $haystack,
-            new LogicalNot(
-                new TraversableContainsOnly(
-                    $type,
-                    $isNativeType
-                )
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a haystack that is stored in a static attribute of a class
-     * or an attribute of an object does not contain only values of a given
-     * type.
-     *
-     * @param string        $type
-     * @param string        $haystackAttributeName
-     * @param string|object $haystackClassOrObject
-     * @param bool          $isNativeType
-     * @param string        $message
-     */
-    public static function assertAttributeNotContainsOnly($type, $haystackAttributeName, $haystackClassOrObject, $isNativeType = null, $message = '')
-    {
-        static::assertNotContainsOnly(
-            $type,
-            static::readAttribute($haystackClassOrObject, $haystackAttributeName),
-            $isNativeType,
-            $message
-        );
-    }
-
-    /**
-     * Asserts the number of elements of an array, Countable or Traversable.
-     *
-     * @param int    $expectedCount
-     * @param mixed  $haystack
-     * @param string $message
-     */
-    public static function assertCount($expectedCount, $haystack, $message = '')
-    {
-        if (!\is_int($expectedCount)) {
-            throw InvalidArgumentHelper::factory(1, 'integer');
-        }
-
-        if (!$haystack instanceof Countable &&
-            !$haystack instanceof Traversable &&
-            !\is_array($haystack)) {
-            throw InvalidArgumentHelper::factory(2, 'countable or traversable');
-        }
-
-        static::assertThat(
-            $haystack,
-            new Count($expectedCount),
-            $message
-        );
-    }
-
-    /**
-     * Asserts the number of elements of an array, Countable or Traversable
-     * that is stored in an attribute.
-     *
-     * @param int           $expectedCount
-     * @param string        $haystackAttributeName
-     * @param string|object $haystackClassOrObject
-     * @param string        $message
-     */
-    public static function assertAttributeCount($expectedCount, $haystackAttributeName, $haystackClassOrObject, $message = '')
-    {
-        static::assertCount(
-            $expectedCount,
-            static::readAttribute($haystackClassOrObject, $haystackAttributeName),
-            $message
-        );
-    }
-
-    /**
-     * Asserts the number of elements of an array, Countable or Traversable.
-     *
-     * @param int    $expectedCount
-     * @param mixed  $haystack
-     * @param string $message
-     */
-    public static function assertNotCount($expectedCount, $haystack, $message = '')
-    {
-        if (!\is_int($expectedCount)) {
-            throw InvalidArgumentHelper::factory(1, 'integer');
-        }
-
-        if (!$haystack instanceof Countable &&
-            !$haystack instanceof Traversable &&
-            !\is_array($haystack)) {
-            throw InvalidArgumentHelper::factory(2, 'countable or traversable');
-        }
-
-        $constraint = new LogicalNot(
-            new Count($expectedCount)
-        );
-
-        static::assertThat($haystack, $constraint, $message);
-    }
-
-    /**
-     * Asserts the number of elements of an array, Countable or Traversable
-     * that is stored in an attribute.
-     *
-     * @param int           $expectedCount
-     * @param string        $haystackAttributeName
-     * @param string|object $haystackClassOrObject
-     * @param string        $message
-     */
-    public static function assertAttributeNotCount($expectedCount, $haystackAttributeName, $haystackClassOrObject, $message = '')
-    {
-        static::assertNotCount(
-            $expectedCount,
-            static::readAttribute($haystackClassOrObject, $haystackAttributeName),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that two variables are equal.
-     *
-     * @param mixed  $expected
-     * @param mixed  $actual
-     * @param string $message
-     * @param float  $delta
-     * @param int    $maxDepth
-     * @param bool   $canonicalize
-     * @param bool   $ignoreCase
-     */
-    public static function assertEquals($expected, $actual, $message = '', $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
-    {
-        $constraint = new IsEqual(
-            $expected,
-            $delta,
-            $maxDepth,
-            $canonicalize,
-            $ignoreCase
-        );
-
-        static::assertThat($actual, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a variable is equal to an attribute of an object.
-     *
-     * @param mixed         $expected
-     * @param string        $actualAttributeName
-     * @param string|object $actualClassOrObject
-     * @param string        $message
-     * @param float         $delta
-     * @param int           $maxDepth
-     * @param bool          $canonicalize
-     * @param bool          $ignoreCase
-     */
-    public static function assertAttributeEquals($expected, $actualAttributeName, $actualClassOrObject, $message = '', $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
-    {
-        static::assertEquals(
-            $expected,
-            static::readAttribute($actualClassOrObject, $actualAttributeName),
-            $message,
-            $delta,
-            $maxDepth,
-            $canonicalize,
-            $ignoreCase
-        );
-    }
-
-    /**
-     * Asserts that two variables are not equal.
-     *
-     * @param mixed  $expected
-     * @param mixed  $actual
-     * @param string $message
-     * @param float  $delta
-     * @param int    $maxDepth
-     * @param bool   $canonicalize
-     * @param bool   $ignoreCase
-     */
-    public static function assertNotEquals($expected, $actual, $message = '', $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
-    {
-        $constraint = new LogicalNot(
-            new IsEqual(
-                $expected,
-                $delta,
-                $maxDepth,
-                $canonicalize,
-                $ignoreCase
-            )
-        );
-
-        static::assertThat($actual, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a variable is not equal to an attribute of an object.
-     *
-     * @param mixed         $expected
-     * @param string        $actualAttributeName
-     * @param string|object $actualClassOrObject
-     * @param string        $message
-     * @param float         $delta
-     * @param int           $maxDepth
-     * @param bool          $canonicalize
-     * @param bool          $ignoreCase
-     */
-    public static function assertAttributeNotEquals($expected, $actualAttributeName, $actualClassOrObject, $message = '', $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
-    {
-        static::assertNotEquals(
-            $expected,
-            static::readAttribute($actualClassOrObject, $actualAttributeName),
-            $message,
-            $delta,
-            $maxDepth,
-            $canonicalize,
-            $ignoreCase
-        );
-    }
-
-    /**
-     * Asserts that a variable is empty.
-     *
-     * @param mixed  $actual
-     * @param string $message
-     *
-     * @throws AssertionFailedError
-     */
-    public static function assertEmpty($actual, $message = '')
-    {
-        static::assertThat($actual, static::isEmpty(), $message);
-    }
-
-    /**
-     * Asserts that a static attribute of a class or an attribute of an object
-     * is empty.
-     *
-     * @param string        $haystackAttributeName
-     * @param string|object $haystackClassOrObject
-     * @param string        $message
-     */
-    public static function assertAttributeEmpty($haystackAttributeName, $haystackClassOrObject, $message = '')
-    {
-        static::assertEmpty(
-            static::readAttribute($haystackClassOrObject, $haystackAttributeName),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is not empty.
-     *
-     * @param mixed  $actual
-     * @param string $message
-     *
-     * @throws AssertionFailedError
-     */
-    public static function assertNotEmpty($actual, $message = '')
-    {
-        static::assertThat($actual, static::logicalNot(static::isEmpty()), $message);
-    }
-
-    /**
-     * Asserts that a static attribute of a class or an attribute of an object
-     * is not empty.
-     *
-     * @param string        $haystackAttributeName
-     * @param string|object $haystackClassOrObject
-     * @param string        $message
-     */
-    public static function assertAttributeNotEmpty($haystackAttributeName, $haystackClassOrObject, $message = '')
-    {
-        static::assertNotEmpty(
-            static::readAttribute($haystackClassOrObject, $haystackAttributeName),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a value is greater than another value.
-     *
-     * @param mixed  $expected
-     * @param mixed  $actual
-     * @param string $message
-     */
-    public static function assertGreaterThan($expected, $actual, $message = '')
-    {
-        static::assertThat($actual, static::greaterThan($expected), $message);
-    }
-
-    /**
-     * Asserts that an attribute is greater than another value.
-     *
-     * @param mixed         $expected
-     * @param string        $actualAttributeName
-     * @param string|object $actualClassOrObject
-     * @param string        $message
-     */
-    public static function assertAttributeGreaterThan($expected, $actualAttributeName, $actualClassOrObject, $message = '')
-    {
-        static::assertGreaterThan(
-            $expected,
-            static::readAttribute($actualClassOrObject, $actualAttributeName),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a value is greater than or equal to another value.
-     *
-     * @param mixed  $expected
-     * @param mixed  $actual
-     * @param string $message
-     */
-    public static function assertGreaterThanOrEqual($expected, $actual, $message = '')
-    {
-        static::assertThat(
-            $actual,
-            static::greaterThanOrEqual($expected),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that an attribute is greater than or equal to another value.
-     *
-     * @param mixed         $expected
-     * @param string        $actualAttributeName
-     * @param string|object $actualClassOrObject
-     * @param string        $message
-     */
-    public static function assertAttributeGreaterThanOrEqual($expected, $actualAttributeName, $actualClassOrObject, $message = '')
-    {
-        static::assertGreaterThanOrEqual(
-            $expected,
-            static::readAttribute($actualClassOrObject, $actualAttributeName),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a value is smaller than another value.
-     *
-     * @param mixed  $expected
-     * @param mixed  $actual
-     * @param string $message
-     */
-    public static function assertLessThan($expected, $actual, $message = '')
-    {
-        static::assertThat($actual, static::lessThan($expected), $message);
-    }
-
-    /**
-     * Asserts that an attribute is smaller than another value.
-     *
-     * @param mixed         $expected
-     * @param string        $actualAttributeName
-     * @param string|object $actualClassOrObject
-     * @param string        $message
-     */
-    public static function assertAttributeLessThan($expected, $actualAttributeName, $actualClassOrObject, $message = '')
-    {
-        static::assertLessThan(
-            $expected,
-            static::readAttribute($actualClassOrObject, $actualAttributeName),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a value is smaller than or equal to another value.
-     *
-     * @param mixed  $expected
-     * @param mixed  $actual
-     * @param string $message
-     */
-    public static function assertLessThanOrEqual($expected, $actual, $message = '')
-    {
-        static::assertThat($actual, static::lessThanOrEqual($expected), $message);
-    }
-
-    /**
-     * Asserts that an attribute is smaller than or equal to another value.
-     *
-     * @param mixed         $expected
-     * @param string        $actualAttributeName
-     * @param string|object $actualClassOrObject
-     * @param string        $message
-     */
-    public static function assertAttributeLessThanOrEqual($expected, $actualAttributeName, $actualClassOrObject, $message = '')
-    {
-        static::assertLessThanOrEqual(
-            $expected,
-            static::readAttribute($actualClassOrObject, $actualAttributeName),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that the contents of one file is equal to the contents of another
-     * file.
-     *
-     * @param string $expected
-     * @param string $actual
-     * @param string $message
-     * @param bool   $canonicalize
-     * @param bool   $ignoreCase
-     */
-    public static function assertFileEquals($expected, $actual, $message = '', $canonicalize = false, $ignoreCase = false)
-    {
-        static::assertFileExists($expected, $message);
-        static::assertFileExists($actual, $message);
-
-        static::assertEquals(
-            \file_get_contents($expected),
-            \file_get_contents($actual),
-            $message,
-            0,
-            10,
-            $canonicalize,
-            $ignoreCase
-        );
-    }
-
-    /**
-     * Asserts that the contents of one file is not equal to the contents of
-     * another file.
-     *
-     * @param string $expected
-     * @param string $actual
-     * @param string $message
-     * @param bool   $canonicalize
-     * @param bool   $ignoreCase
-     */
-    public static function assertFileNotEquals($expected, $actual, $message = '', $canonicalize = false, $ignoreCase = false)
-    {
-        static::assertFileExists($expected, $message);
-        static::assertFileExists($actual, $message);
-
-        static::assertNotEquals(
-            \file_get_contents($expected),
-            \file_get_contents($actual),
-            $message,
-            0,
-            10,
-            $canonicalize,
-            $ignoreCase
-        );
-    }
-
-    /**
-     * Asserts that the contents of a string is equal
-     * to the contents of a file.
-     *
-     * @param string $expectedFile
-     * @param string $actualString
-     * @param string $message
-     * @param bool   $canonicalize
-     * @param bool   $ignoreCase
-     */
-    public static function assertStringEqualsFile($expectedFile, $actualString, $message = '', $canonicalize = false, $ignoreCase = false)
-    {
-        static::assertFileExists($expectedFile, $message);
-
-        static::assertEquals(
-            \file_get_contents($expectedFile),
-            $actualString,
-            $message,
-            0,
-            10,
-            $canonicalize,
-            $ignoreCase
-        );
-    }
-
-    /**
-     * Asserts that the contents of a string is not equal
-     * to the contents of a file.
-     *
-     * @param string $expectedFile
-     * @param string $actualString
-     * @param string $message
-     * @param bool   $canonicalize
-     * @param bool   $ignoreCase
-     */
-    public static function assertStringNotEqualsFile($expectedFile, $actualString, $message = '', $canonicalize = false, $ignoreCase = false)
-    {
-        static::assertFileExists($expectedFile, $message);
-
-        static::assertNotEquals(
-            \file_get_contents($expectedFile),
-            $actualString,
-            $message,
-            0,
-            10,
-            $canonicalize,
-            $ignoreCase
-        );
-    }
-
-    /**
-     * Asserts that a file/dir is readable.
-     *
-     * @param string $filename
-     * @param string $message
-     */
-    public static function assertIsReadable($filename, $message = '')
-    {
-        if (!\is_string($filename)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        $constraint = new IsReadable;
-
-        static::assertThat($filename, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a file/dir exists and is not readable.
-     *
-     * @param string $filename
-     * @param string $message
-     */
-    public static function assertNotIsReadable($filename, $message = '')
-    {
-        if (!\is_string($filename)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        $constraint = new LogicalNot(
-            new IsReadable
-        );
-
-        static::assertThat($filename, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a file/dir exists and is writable.
-     *
-     * @param string $filename
-     * @param string $message
-     */
-    public static function assertIsWritable($filename, $message = '')
-    {
-        if (!\is_string($filename)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        $constraint = new IsWritable;
-
-        static::assertThat($filename, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a file/dir exists and is not writable.
-     *
-     * @param string $filename
-     * @param string $message
-     */
-    public static function assertNotIsWritable($filename, $message = '')
-    {
-        if (!\is_string($filename)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        $constraint = new LogicalNot(
-            new IsWritable
-        );
-
-        static::assertThat($filename, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a directory exists.
-     *
-     * @param string $directory
-     * @param string $message
-     */
-    public static function assertDirectoryExists($directory, $message = '')
-    {
-        if (!\is_string($directory)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        $constraint = new DirectoryExists;
-
-        static::assertThat($directory, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a directory does not exist.
-     *
-     * @param string $directory
-     * @param string $message
-     */
-    public static function assertDirectoryNotExists($directory, $message = '')
-    {
-        if (!\is_string($directory)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        $constraint = new LogicalNot(
-            new DirectoryExists
-        );
-
-        static::assertThat($directory, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a directory exists and is readable.
-     *
-     * @param string $directory
-     * @param string $message
-     */
-    public static function assertDirectoryIsReadable($directory, $message = '')
-    {
-        self::assertDirectoryExists($directory, $message);
-        self::assertIsReadable($directory, $message);
-    }
-
-    /**
-     * Asserts that a directory exists and is not readable.
-     *
-     * @param string $directory
-     * @param string $message
-     */
-    public static function assertDirectoryNotIsReadable($directory, $message = '')
-    {
-        self::assertDirectoryExists($directory, $message);
-        self::assertNotIsReadable($directory, $message);
-    }
-
-    /**
-     * Asserts that a directory exists and is writable.
-     *
-     * @param string $directory
-     * @param string $message
-     */
-    public static function assertDirectoryIsWritable($directory, $message = '')
-    {
-        self::assertDirectoryExists($directory, $message);
-        self::assertIsWritable($directory, $message);
-    }
-
-    /**
-     * Asserts that a directory exists and is not writable.
-     *
-     * @param string $directory
-     * @param string $message
-     */
-    public static function assertDirectoryNotIsWritable($directory, $message = '')
-    {
-        self::assertDirectoryExists($directory, $message);
-        self::assertNotIsWritable($directory, $message);
-    }
-
-    /**
-     * Asserts that a file exists.
-     *
-     * @param string $filename
-     * @param string $message
-     */
-    public static function assertFileExists($filename, $message = '')
-    {
-        if (!\is_string($filename)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        $constraint = new FileExists;
-
-        static::assertThat($filename, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a file does not exist.
-     *
-     * @param string $filename
-     * @param string $message
-     */
-    public static function assertFileNotExists($filename, $message = '')
-    {
-        if (!\is_string($filename)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        $constraint = new LogicalNot(
-            new FileExists
-        );
-
-        static::assertThat($filename, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a file exists and is readable.
-     *
-     * @param string $file
-     * @param string $message
-     */
-    public static function assertFileIsReadable($file, $message = '')
-    {
-        self::assertFileExists($file, $message);
-        self::assertIsReadable($file, $message);
-    }
-
-    /**
-     * Asserts that a file exists and is not readable.
-     *
-     * @param string $file
-     * @param string $message
-     */
-    public static function assertFileNotIsReadable($file, $message = '')
-    {
-        self::assertFileExists($file, $message);
-        self::assertNotIsReadable($file, $message);
-    }
-
-    /**
-     * Asserts that a file exists and is writable.
-     *
-     * @param string $file
-     * @param string $message
-     */
-    public static function assertFileIsWritable($file, $message = '')
-    {
-        self::assertFileExists($file, $message);
-        self::assertIsWritable($file, $message);
-    }
-
-    /**
-     * Asserts that a file exists and is not writable.
-     *
-     * @param string $file
-     * @param string $message
-     */
-    public static function assertFileNotIsWritable($file, $message = '')
-    {
-        self::assertFileExists($file, $message);
-        self::assertNotIsWritable($file, $message);
-    }
-
-    /**
-     * Asserts that a condition is true.
-     *
-     * @param bool   $condition
-     * @param string $message
-     *
-     * @throws AssertionFailedError
-     */
-    public static function assertTrue($condition, $message = '')
-    {
-        static::assertThat($condition, static::isTrue(), $message);
-    }
-
-    /**
-     * Asserts that a condition is not true.
-     *
-     * @param bool   $condition
-     * @param string $message
-     *
-     * @throws AssertionFailedError
-     */
-    public static function assertNotTrue($condition, $message = '')
-    {
-        static::assertThat($condition, static::logicalNot(static::isTrue()), $message);
-    }
-
-    /**
-     * Asserts that a condition is false.
-     *
-     * @param bool   $condition
-     * @param string $message
-     *
-     * @throws AssertionFailedError
-     */
-    public static function assertFalse($condition, $message = '')
-    {
-        static::assertThat($condition, static::isFalse(), $message);
-    }
-
-    /**
-     * Asserts that a condition is not false.
-     *
-     * @param bool   $condition
-     * @param string $message
-     *
-     * @throws AssertionFailedError
-     */
-    public static function assertNotFalse($condition, $message = '')
-    {
-        static::assertThat($condition, static::logicalNot(static::isFalse()), $message);
-    }
-
-    /**
-     * Asserts that a variable is null.
-     *
-     * @param mixed  $actual
-     * @param string $message
-     */
-    public static function assertNull($actual, $message = '')
-    {
-        static::assertThat($actual, static::isNull(), $message);
-    }
-
-    /**
-     * Asserts that a variable is not null.
-     *
-     * @param mixed  $actual
-     * @param string $message
-     */
-    public static function assertNotNull($actual, $message = '')
-    {
-        static::assertThat($actual, static::logicalNot(static::isNull()), $message);
-    }
-
-    /**
-     * Asserts that a variable is finite.
-     *
-     * @param mixed  $actual
-     * @param string $message
-     */
-    public static function assertFinite($actual, $message = '')
-    {
-        static::assertThat($actual, static::isFinite(), $message);
-    }
-
-    /**
-     * Asserts that a variable is infinite.
-     *
-     * @param mixed  $actual
-     * @param string $message
-     */
-    public static function assertInfinite($actual, $message = '')
-    {
-        static::assertThat($actual, static::isInfinite(), $message);
-    }
-
-    /**
-     * Asserts that a variable is nan.
-     *
-     * @param mixed  $actual
-     * @param string $message
-     */
-    public static function assertNan($actual, $message = '')
-    {
-        static::assertThat($actual, static::isNan(), $message);
-    }
-
-    /**
-     * Asserts that a class has a specified attribute.
-     *
-     * @param string $attributeName
-     * @param string $className
-     * @param string $message
-     */
-    public static function assertClassHasAttribute($attributeName, $className, $message = '')
-    {
-        if (!\is_string($attributeName)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
-            throw InvalidArgumentHelper::factory(1, 'valid attribute name');
-        }
-
-        if (!\is_string($className) || !\class_exists($className)) {
-            throw InvalidArgumentHelper::factory(2, 'class name', $className);
-        }
-
-        $constraint = new ClassHasAttribute(
-            $attributeName
-        );
-
-        static::assertThat($className, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a class does not have a specified attribute.
-     *
-     * @param string $attributeName
-     * @param string $className
-     * @param string $message
-     */
-    public static function assertClassNotHasAttribute($attributeName, $className, $message = '')
-    {
-        if (!\is_string($attributeName)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
-            throw InvalidArgumentHelper::factory(1, 'valid attribute name');
-        }
-
-        if (!\is_string($className) || !\class_exists($className)) {
-            throw InvalidArgumentHelper::factory(2, 'class name', $className);
-        }
-
-        $constraint = new LogicalNot(
-            new ClassHasAttribute($attributeName)
-        );
-
-        static::assertThat($className, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a class has a specified static attribute.
-     *
-     * @param string $attributeName
-     * @param string $className
-     * @param string $message
-     */
-    public static function assertClassHasStaticAttribute($attributeName, $className, $message = '')
-    {
-        if (!\is_string($attributeName)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
-            throw InvalidArgumentHelper::factory(1, 'valid attribute name');
-        }
-
-        if (!\is_string($className) || !\class_exists($className)) {
-            throw InvalidArgumentHelper::factory(2, 'class name', $className);
-        }
-
-        $constraint = new ClassHasStaticAttribute(
-            $attributeName
-        );
-
-        static::assertThat($className, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a class does not have a specified static attribute.
-     *
-     * @param string $attributeName
-     * @param string $className
-     * @param string $message
-     */
-    public static function assertClassNotHasStaticAttribute($attributeName, $className, $message = '')
-    {
-        if (!\is_string($attributeName)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
-            throw InvalidArgumentHelper::factory(1, 'valid attribute name');
-        }
-
-        if (!\is_string($className) || !\class_exists($className)) {
-            throw InvalidArgumentHelper::factory(2, 'class name', $className);
-        }
-
-        $constraint = new LogicalNot(
-            new ClassHasStaticAttribute(
-                $attributeName
-            )
-        );
-
-        static::assertThat($className, $constraint, $message);
-    }
-
-    /**
-     * Asserts that an object has a specified attribute.
-     *
-     * @param string $attributeName
-     * @param object $object
-     * @param string $message
-     */
-    public static function assertObjectHasAttribute($attributeName, $object, $message = '')
-    {
-        if (!\is_string($attributeName)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
-            throw InvalidArgumentHelper::factory(1, 'valid attribute name');
-        }
-
-        if (!\is_object($object)) {
-            throw InvalidArgumentHelper::factory(2, 'object');
-        }
-
-        $constraint = new ObjectHasAttribute(
-            $attributeName
-        );
-
-        static::assertThat($object, $constraint, $message);
-    }
-
-    /**
-     * Asserts that an object does not have a specified attribute.
-     *
-     * @param string $attributeName
-     * @param object $object
-     * @param string $message
-     */
-    public static function assertObjectNotHasAttribute($attributeName, $object, $message = '')
-    {
-        if (!\is_string($attributeName)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
-            throw InvalidArgumentHelper::factory(1, 'valid attribute name');
-        }
-
-        if (!\is_object($object)) {
-            throw InvalidArgumentHelper::factory(2, 'object');
-        }
-
-        $constraint = new LogicalNot(
-            new ObjectHasAttribute($attributeName)
-        );
-
-        static::assertThat($object, $constraint, $message);
-    }
-
-    /**
-     * Asserts that two variables have the same type and value.
-     * Used on objects, it asserts that two variables reference
-     * the same object.
-     *
-     * @param mixed  $expected
-     * @param mixed  $actual
-     * @param string $message
-     */
-    public static function assertSame($expected, $actual, $message = '')
-    {
-        if (\is_bool($expected) && \is_bool($actual)) {
-            static::assertEquals($expected, $actual, $message);
-        } else {
-            $constraint = new IsIdentical(
-                $expected
-            );
-
-            static::assertThat($actual, $constraint, $message);
-        }
-    }
-
-    /**
-     * Asserts that a variable and an attribute of an object have the same type
-     * and value.
-     *
-     * @param mixed         $expected
-     * @param string        $actualAttributeName
-     * @param string|object $actualClassOrObject
-     * @param string        $message
-     */
-    public static function assertAttributeSame($expected, $actualAttributeName, $actualClassOrObject, $message = '')
-    {
-        static::assertSame(
-            $expected,
-            static::readAttribute($actualClassOrObject, $actualAttributeName),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that two variables do not have the same type and value.
-     * Used on objects, it asserts that two variables do not reference
-     * the same object.
-     *
-     * @param mixed  $expected
-     * @param mixed  $actual
-     * @param string $message
-     */
-    public static function assertNotSame($expected, $actual, $message = '')
-    {
-        if (\is_bool($expected) && \is_bool($actual)) {
-            static::assertNotEquals($expected, $actual, $message);
-        } else {
-            $constraint = new LogicalNot(
-                new IsIdentical($expected)
-            );
-
-            static::assertThat($actual, $constraint, $message);
-        }
-    }
-
-    /**
-     * Asserts that a variable and an attribute of an object do not have the
-     * same type and value.
-     *
-     * @param mixed         $expected
-     * @param string        $actualAttributeName
-     * @param string|object $actualClassOrObject
-     * @param string        $message
-     */
-    public static function assertAttributeNotSame($expected, $actualAttributeName, $actualClassOrObject, $message = '')
-    {
-        static::assertNotSame(
-            $expected,
-            static::readAttribute($actualClassOrObject, $actualAttributeName),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is of a given type.
-     *
-     * @param string $expected
-     * @param mixed  $actual
-     * @param string $message
-     */
-    public static function assertInstanceOf($expected, $actual, $message = '')
-    {
-        if (!(\is_string($expected) && (\class_exists($expected) || \interface_exists($expected)))) {
-            throw InvalidArgumentHelper::factory(1, 'class or interface name');
-        }
-
-        $constraint = new IsInstanceOf(
-            $expected
-        );
-
-        static::assertThat($actual, $constraint, $message);
-    }
-
-    /**
-     * Asserts that an attribute is of a given type.
-     *
-     * @param string        $expected
-     * @param string        $attributeName
-     * @param string|object $classOrObject
-     * @param string        $message
-     */
-    public static function assertAttributeInstanceOf($expected, $attributeName, $classOrObject, $message = '')
-    {
-        static::assertInstanceOf(
-            $expected,
-            static::readAttribute($classOrObject, $attributeName),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is not of a given type.
-     *
-     * @param string $expected
-     * @param mixed  $actual
-     * @param string $message
-     */
-    public static function assertNotInstanceOf($expected, $actual, $message = '')
-    {
-        if (!(\is_string($expected) && (\class_exists($expected) || \interface_exists($expected)))) {
-            throw InvalidArgumentHelper::factory(1, 'class or interface name');
-        }
-
-        $constraint = new LogicalNot(
-            new IsInstanceOf($expected)
-        );
-
-        static::assertThat($actual, $constraint, $message);
-    }
-
-    /**
-     * Asserts that an attribute is of a given type.
-     *
-     * @param string        $expected
-     * @param string        $attributeName
-     * @param string|object $classOrObject
-     * @param string        $message
-     */
-    public static function assertAttributeNotInstanceOf($expected, $attributeName, $classOrObject, $message = '')
-    {
-        static::assertNotInstanceOf(
-            $expected,
-            static::readAttribute($classOrObject, $attributeName),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is of a given type.
-     *
-     * @param string $expected
-     * @param mixed  $actual
-     * @param string $message
-     */
-    public static function assertInternalType($expected, $actual, $message = '')
-    {
-        if (!\is_string($expected)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        $constraint = new IsType(
-            $expected
-        );
-
-        static::assertThat($actual, $constraint, $message);
-    }
-
-    /**
-     * Asserts that an attribute is of a given type.
-     *
-     * @param string        $expected
-     * @param string        $attributeName
-     * @param string|object $classOrObject
-     * @param string        $message
-     */
-    public static function assertAttributeInternalType($expected, $attributeName, $classOrObject, $message = '')
-    {
-        static::assertInternalType(
-            $expected,
-            static::readAttribute($classOrObject, $attributeName),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is not of a given type.
-     *
-     * @param string $expected
-     * @param mixed  $actual
-     * @param string $message
-     */
-    public static function assertNotInternalType($expected, $actual, $message = '')
-    {
-        if (!\is_string($expected)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        $constraint = new LogicalNot(
-            new IsType($expected)
-        );
-
-        static::assertThat($actual, $constraint, $message);
-    }
-
-    /**
-     * Asserts that an attribute is of a given type.
-     *
-     * @param string        $expected
-     * @param string        $attributeName
-     * @param string|object $classOrObject
-     * @param string        $message
-     */
-    public static function assertAttributeNotInternalType($expected, $attributeName, $classOrObject, $message = '')
-    {
-        static::assertNotInternalType(
-            $expected,
-            static::readAttribute($classOrObject, $attributeName),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a string matches a given regular expression.
-     *
-     * @param string $pattern
-     * @param string $string
-     * @param string $message
-     */
-    public static function assertRegExp($pattern, $string, $message = '')
-    {
-        if (!\is_string($pattern)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        if (!\is_string($string)) {
-            throw InvalidArgumentHelper::factory(2, 'string');
-        }
-
-        $constraint = new RegularExpression($pattern);
-
-        static::assertThat($string, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a string does not match a given regular expression.
-     *
-     * @param string $pattern
-     * @param string $string
-     * @param string $message
-     */
-    public static function assertNotRegExp($pattern, $string, $message = '')
-    {
-        if (!\is_string($pattern)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        if (!\is_string($string)) {
-            throw InvalidArgumentHelper::factory(2, 'string');
-        }
-
-        $constraint = new LogicalNot(
-            new RegularExpression($pattern)
-        );
-
-        static::assertThat($string, $constraint, $message);
-    }
-
-    /**
-     * Assert that the size of two arrays (or `Countable` or `Traversable` objects)
-     * is the same.
-     *
-     * @param array|\Countable|\Traversable $expected
-     * @param array|\Countable|\Traversable $actual
-     * @param string                        $message
-     */
-    public static function assertSameSize($expected, $actual, $message = '')
-    {
-        if (!$expected instanceof Countable &&
-            !$expected instanceof Traversable &&
-            !\is_array($expected)) {
-            throw InvalidArgumentHelper::factory(1, 'countable or traversable');
-        }
-
-        if (!$actual instanceof Countable &&
-            !$actual instanceof Traversable &&
-            !\is_array($actual)) {
-            throw InvalidArgumentHelper::factory(2, 'countable or traversable');
-        }
-
-        static::assertThat(
-            $actual,
-            new SameSize($expected),
-            $message
-        );
-    }
-
-    /**
-     * Assert that the size of two arrays (or `Countable` or `Traversable` objects)
-     * is not the same.
-     *
-     * @param array|\Countable|\Traversable $expected
-     * @param array|\Countable|\Traversable $actual
-     * @param string                        $message
-     */
-    public static function assertNotSameSize($expected, $actual, $message = '')
-    {
-        if (!$expected instanceof Countable &&
-            !$expected instanceof Traversable &&
-            !\is_array($expected)) {
-            throw InvalidArgumentHelper::factory(1, 'countable or traversable');
-        }
-
-        if (!$actual instanceof Countable &&
-            !$actual instanceof Traversable &&
-            !\is_array($actual)) {
-            throw InvalidArgumentHelper::factory(2, 'countable or traversable');
-        }
-
-        $constraint = new LogicalNot(
-            new SameSize($expected)
-        );
-
-        static::assertThat($actual, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a string matches a given format string.
-     *
-     * @param string $format
-     * @param string $string
-     * @param string $message
-     */
-    public static function assertStringMatchesFormat($format, $string, $message = '')
-    {
-        if (!\is_string($format)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        if (!\is_string($string)) {
-            throw InvalidArgumentHelper::factory(2, 'string');
-        }
-
-        $constraint = new StringMatchesFormatDescription($format);
-
-        static::assertThat($string, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a string does not match a given format string.
-     *
-     * @param string $format
-     * @param string $string
-     * @param string $message
-     */
-    public static function assertStringNotMatchesFormat($format, $string, $message = '')
-    {
-        if (!\is_string($format)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        if (!\is_string($string)) {
-            throw InvalidArgumentHelper::factory(2, 'string');
-        }
-
-        $constraint = new LogicalNot(
-            new StringMatchesFormatDescription($format)
-        );
-
-        static::assertThat($string, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a string matches a given format file.
-     *
-     * @param string $formatFile
-     * @param string $string
-     * @param string $message
-     */
-    public static function assertStringMatchesFormatFile($formatFile, $string, $message = '')
-    {
-        static::assertFileExists($formatFile, $message);
-
-        if (!\is_string($string)) {
-            throw InvalidArgumentHelper::factory(2, 'string');
-        }
-
-        $constraint = new StringMatchesFormatDescription(
-            \file_get_contents($formatFile)
-        );
-
-        static::assertThat($string, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a string does not match a given format string.
-     *
-     * @param string $formatFile
-     * @param string $string
-     * @param string $message
-     */
-    public static function assertStringNotMatchesFormatFile($formatFile, $string, $message = '')
-    {
-        static::assertFileExists($formatFile, $message);
-
-        if (!\is_string($string)) {
-            throw InvalidArgumentHelper::factory(2, 'string');
-        }
-
-        $constraint = new LogicalNot(
-            new StringMatchesFormatDescription(
-                \file_get_contents($formatFile)
-            )
-        );
-
-        static::assertThat($string, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a string starts with a given prefix.
-     *
-     * @param string $prefix
-     * @param string $string
-     * @param string $message
-     */
-    public static function assertStringStartsWith($prefix, $string, $message = '')
-    {
-        if (!\is_string($prefix)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        if (!\is_string($string)) {
-            throw InvalidArgumentHelper::factory(2, 'string');
-        }
-
-        $constraint = new StringStartsWith(
-            $prefix
-        );
-
-        static::assertThat($string, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a string starts not with a given prefix.
-     *
-     * @param string $prefix
-     * @param string $string
-     * @param string $message
-     */
-    public static function assertStringStartsNotWith($prefix, $string, $message = '')
-    {
-        if (!\is_string($prefix)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        if (!\is_string($string)) {
-            throw InvalidArgumentHelper::factory(2, 'string');
-        }
-
-        $constraint = new LogicalNot(
-            new StringStartsWith($prefix)
-        );
-
-        static::assertThat($string, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a string ends with a given suffix.
-     *
-     * @param string $suffix
-     * @param string $string
-     * @param string $message
-     */
-    public static function assertStringEndsWith($suffix, $string, $message = '')
-    {
-        if (!\is_string($suffix)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        if (!\is_string($string)) {
-            throw InvalidArgumentHelper::factory(2, 'string');
-        }
-
-        $constraint = new StringEndsWith($suffix);
-
-        static::assertThat($string, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a string ends not with a given suffix.
-     *
-     * @param string $suffix
-     * @param string $string
-     * @param string $message
-     */
-    public static function assertStringEndsNotWith($suffix, $string, $message = '')
-    {
-        if (!\is_string($suffix)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        if (!\is_string($string)) {
-            throw InvalidArgumentHelper::factory(2, 'string');
-        }
-
-        $constraint = new LogicalNot(
-            new StringEndsWith($suffix)
-        );
-
-        static::assertThat($string, $constraint, $message);
-    }
-
-    /**
-     * Asserts that two XML files are equal.
-     *
-     * @param string $expectedFile
-     * @param string $actualFile
-     * @param string $message
-     */
-    public static function assertXmlFileEqualsXmlFile($expectedFile, $actualFile, $message = '')
-    {
-        $expected = Xml::loadFile($expectedFile);
-        $actual   = Xml::loadFile($actualFile);
-
-        static::assertEquals($expected, $actual, $message);
-    }
-
-    /**
-     * Asserts that two XML files are not equal.
-     *
-     * @param string $expectedFile
-     * @param string $actualFile
-     * @param string $message
-     */
-    public static function assertXmlFileNotEqualsXmlFile($expectedFile, $actualFile, $message = '')
-    {
-        $expected = Xml::loadFile($expectedFile);
-        $actual   = Xml::loadFile($actualFile);
-
-        static::assertNotEquals($expected, $actual, $message);
-    }
-
-    /**
-     * Asserts that two XML documents are equal.
-     *
-     * @param string             $expectedFile
-     * @param string|DOMDocument $actualXml
-     * @param string             $message
-     */
-    public static function assertXmlStringEqualsXmlFile($expectedFile, $actualXml, $message = '')
-    {
-        $expected = Xml::loadFile($expectedFile);
-        $actual   = Xml::load($actualXml);
-
-        static::assertEquals($expected, $actual, $message);
-    }
-
-    /**
-     * Asserts that two XML documents are not equal.
-     *
-     * @param string             $expectedFile
-     * @param string|DOMDocument $actualXml
-     * @param string             $message
-     */
-    public static function assertXmlStringNotEqualsXmlFile($expectedFile, $actualXml, $message = '')
-    {
-        $expected = Xml::loadFile($expectedFile);
-        $actual   = Xml::load($actualXml);
-
-        static::assertNotEquals($expected, $actual, $message);
-    }
-
-    /**
-     * Asserts that two XML documents are equal.
-     *
-     * @param string|DOMDocument $expectedXml
-     * @param string|DOMDocument $actualXml
-     * @param string             $message
-     */
-    public static function assertXmlStringEqualsXmlString($expectedXml, $actualXml, $message = '')
-    {
-        $expected = Xml::load($expectedXml);
-        $actual   = Xml::load($actualXml);
-
-        static::assertEquals($expected, $actual, $message);
-    }
-
-    /**
-     * Asserts that two XML documents are not equal.
-     *
-     * @param string|DOMDocument $expectedXml
-     * @param string|DOMDocument $actualXml
-     * @param string             $message
-     */
-    public static function assertXmlStringNotEqualsXmlString($expectedXml, $actualXml, $message = '')
-    {
-        $expected = Xml::load($expectedXml);
-        $actual   = Xml::load($actualXml);
-
-        static::assertNotEquals($expected, $actual, $message);
-    }
-
-    /**
-     * Asserts that a hierarchy of DOMElements matches.
-     *
-     * @param DOMElement $expectedElement
-     * @param DOMElement $actualElement
-     * @param bool       $checkAttributes
-     * @param string     $message
-     */
-    public static function assertEqualXMLStructure(DOMElement $expectedElement, DOMElement $actualElement, $checkAttributes = false, $message = '')
-    {
-        $tmp             = new DOMDocument;
-        $expectedElement = $tmp->importNode($expectedElement, true);
-
-        $tmp           = new DOMDocument;
-        $actualElement = $tmp->importNode($actualElement, true);
-
-        unset($tmp);
-
-        static::assertEquals(
-            $expectedElement->tagName,
-            $actualElement->tagName,
-            $message
-        );
-
-        if ($checkAttributes) {
-            static::assertEquals(
-                $expectedElement->attributes->length,
-                $actualElement->attributes->length,
-                \sprintf(
-                    '%s%sNumber of attributes on node "%s" does not match',
-                    $message,
-                    !empty($message) ? "\n" : '',
-                    $expectedElement->tagName
-                )
-            );
-
-            for ($i = 0; $i < $expectedElement->attributes->length; $i++) {
-                $expectedAttribute = $expectedElement->attributes->item($i);
-                $actualAttribute   = $actualElement->attributes->getNamedItem(
-                    $expectedAttribute->name
-                );
-
-                if (!$actualAttribute) {
-                    static::fail(
-                        \sprintf(
-                            '%s%sCould not find attribute "%s" on node "%s"',
-                            $message,
-                            !empty($message) ? "\n" : '',
-                            $expectedAttribute->name,
-                            $expectedElement->tagName
-                        )
-                    );
-                }
-            }
-        }
-
-        Xml::removeCharacterDataNodes($expectedElement);
-        Xml::removeCharacterDataNodes($actualElement);
-
-        static::assertEquals(
-            $expectedElement->childNodes->length,
-            $actualElement->childNodes->length,
-            \sprintf(
-                '%s%sNumber of child nodes of "%s" differs',
-                $message,
-                !empty($message) ? "\n" : '',
-                $expectedElement->tagName
-            )
-        );
-
-        for ($i = 0; $i < $expectedElement->childNodes->length; $i++) {
-            static::assertEqualXMLStructure(
-                $expectedElement->childNodes->item($i),
-                $actualElement->childNodes->item($i),
-                $checkAttributes,
-                $message
-            );
-        }
-    }
-
-    /**
-     * Evaluates a PHPUnit\Framework\Constraint matcher object.
-     *
-     * @param mixed      $value
-     * @param Constraint $constraint
-     * @param string     $message
-     */
-    public static function assertThat($value, Constraint $constraint, $message = '')
-    {
-        self::$count += \count($constraint);
-
-        $constraint->evaluate($value, $message);
-    }
-
-    /**
-     * Asserts that a string is a valid JSON string.
-     *
-     * @param string $actualJson
-     * @param string $message
-     */
-    public static function assertJson($actualJson, $message = '')
-    {
-        if (!\is_string($actualJson)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        static::assertThat($actualJson, static::isJson(), $message);
-    }
-
-    /**
-     * Asserts that two given JSON encoded objects or arrays are equal.
-     *
-     * @param string $expectedJson
-     * @param string $actualJson
-     * @param string $message
-     */
-    public static function assertJsonStringEqualsJsonString($expectedJson, $actualJson, $message = '')
-    {
-        static::assertJson($expectedJson, $message);
-        static::assertJson($actualJson, $message);
-
-        $constraint = new JsonMatches(
-            $expectedJson
-        );
-
-        static::assertThat($actualJson, $constraint, $message);
-    }
-
-    /**
-     * Asserts that two given JSON encoded objects or arrays are not equal.
-     *
-     * @param string $expectedJson
-     * @param string $actualJson
-     * @param string $message
-     */
-    public static function assertJsonStringNotEqualsJsonString($expectedJson, $actualJson, $message = '')
-    {
-        static::assertJson($expectedJson, $message);
-        static::assertJson($actualJson, $message);
-
-        $constraint = new JsonMatches(
-            $expectedJson
-        );
-
-        static::assertThat($actualJson, new LogicalNot($constraint), $message);
-    }
-
-    /**
-     * Asserts that the generated JSON encoded object and the content of the given file are equal.
-     *
-     * @param string $expectedFile
-     * @param string $actualJson
-     * @param string $message
-     */
-    public static function assertJsonStringEqualsJsonFile($expectedFile, $actualJson, $message = '')
-    {
-        static::assertFileExists($expectedFile, $message);
-        $expectedJson = \file_get_contents($expectedFile);
-
-        static::assertJson($expectedJson, $message);
-        static::assertJson($actualJson, $message);
-
-        $constraint = new JsonMatches(
-            $expectedJson
-        );
-
-        static::assertThat($actualJson, $constraint, $message);
-    }
-
-    /**
-     * Asserts that the generated JSON encoded object and the content of the given file are not equal.
-     *
-     * @param string $expectedFile
-     * @param string $actualJson
-     * @param string $message
-     */
-    public static function assertJsonStringNotEqualsJsonFile($expectedFile, $actualJson, $message = '')
-    {
-        static::assertFileExists($expectedFile, $message);
-        $expectedJson = \file_get_contents($expectedFile);
-
-        static::assertJson($expectedJson, $message);
-        static::assertJson($actualJson, $message);
-
-        $constraint = new JsonMatches(
-            $expectedJson
-        );
-
-        static::assertThat($actualJson, new LogicalNot($constraint), $message);
-    }
-
-    /**
-     * Asserts that two JSON files are equal.
-     *
-     * @param string $expectedFile
-     * @param string $actualFile
-     * @param string $message
-     */
-    public static function assertJsonFileEqualsJsonFile($expectedFile, $actualFile, $message = '')
-    {
-        static::assertFileExists($expectedFile, $message);
-        static::assertFileExists($actualFile, $message);
-
-        $actualJson   = \file_get_contents($actualFile);
-        $expectedJson = \file_get_contents($expectedFile);
-
-        static::assertJson($expectedJson, $message);
-        static::assertJson($actualJson, $message);
-
-        $constraintExpected = new JsonMatches(
-            $expectedJson
-        );
-
-        $constraintActual = new JsonMatches($actualJson);
-
-        static::assertThat($expectedJson, $constraintActual, $message);
-        static::assertThat($actualJson, $constraintExpected, $message);
-    }
-
-    /**
-     * Asserts that two JSON files are not equal.
-     *
-     * @param string $expectedFile
-     * @param string $actualFile
-     * @param string $message
-     */
-    public static function assertJsonFileNotEqualsJsonFile($expectedFile, $actualFile, $message = '')
-    {
-        static::assertFileExists($expectedFile, $message);
-        static::assertFileExists($actualFile, $message);
-
-        $actualJson   = \file_get_contents($actualFile);
-        $expectedJson = \file_get_contents($expectedFile);
-
-        static::assertJson($expectedJson, $message);
-        static::assertJson($actualJson, $message);
-
-        $constraintExpected = new JsonMatches(
-            $expectedJson
-        );
-
-        $constraintActual = new JsonMatches($actualJson);
-
-        static::assertThat($expectedJson, new LogicalNot($constraintActual), $message);
-        static::assertThat($actualJson, new LogicalNot($constraintExpected), $message);
-    }
-
-    /**
-     * @return LogicalAnd
-     */
-    public static function logicalAnd()
-    {
-        $constraints = \func_get_args();
-
-        $constraint = new LogicalAnd;
-        $constraint->setConstraints($constraints);
-
-        return $constraint;
-    }
-
-    /**
-     * @return LogicalOr
-     */
-    public static function logicalOr()
-    {
-        $constraints = \func_get_args();
-
-        $constraint = new LogicalOr;
-        $constraint->setConstraints($constraints);
-
-        return $constraint;
-    }
-
-    /**
-     * @param Constraint $constraint
-     *
-     * @return LogicalNot
-     */
-    public static function logicalNot(Constraint $constraint)
-    {
-        return new LogicalNot($constraint);
-    }
-
-    /**
-     * @return LogicalXor
-     */
-    public static function logicalXor()
-    {
-        $constraints = \func_get_args();
-
-        $constraint = new LogicalXor;
-        $constraint->setConstraints($constraints);
-
-        return $constraint;
-    }
-
-    /**
-     * @return IsAnything
-     */
-    public static function anything()
-    {
-        return new IsAnything;
-    }
-
-    /**
-     * @return IsTrue
-     */
-    public static function isTrue()
-    {
-        return new IsTrue;
-    }
-
-    /**
-     * @param callable $callback
-     *
-     * @return Callback
-     */
-    public static function callback($callback)
-    {
-        return new Callback($callback);
-    }
-
-    /**
-     * @return IsFalse
-     */
-    public static function isFalse()
-    {
-        return new IsFalse;
-    }
-
-    /**
-     * @return IsJson
-     */
-    public static function isJson()
-    {
-        return new IsJson;
-    }
-
-    /**
-     * @return IsNull
-     */
-    public static function isNull()
-    {
-        return new IsNull;
-    }
-
-    /**
-     * @return IsFinite
-     */
-    public static function isFinite()
-    {
-        return new IsFinite;
-    }
-
-    /**
-     * @return IsInfinite
-     */
-    public static function isInfinite()
-    {
-        return new IsInfinite;
-    }
-
-    /**
-     * @return IsNan
-     */
-    public static function isNan()
-    {
-        return new IsNan;
-    }
-
-    /**
-     * @param Constraint $constraint
-     * @param string     $attributeName
-     *
-     * @return Attribute
-     */
-    public static function attribute(Constraint $constraint, $attributeName)
-    {
-        return new Attribute(
-            $constraint,
-            $attributeName
-        );
-    }
-
-    /**
-     * @param mixed $value
-     * @param bool  $checkForObjectIdentity
-     * @param bool  $checkForNonObjectIdentity
-     *
-     * @return TraversableContains
-     */
-    public static function contains($value, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
-    {
-        return new TraversableContains($value, $checkForObjectIdentity, $checkForNonObjectIdentity);
-    }
-
-    /**
-     * @param string $type
-     *
-     * @return TraversableContainsOnly
-     */
-    public static function containsOnly($type)
-    {
-        return new TraversableContainsOnly($type);
-    }
-
-    /**
-     * @param string $classname
-     *
-     * @return TraversableContainsOnly
-     */
-    public static function containsOnlyInstancesOf($classname)
-    {
-        return new TraversableContainsOnly($classname, false);
-    }
-
-    /**
-     * @param mixed $key
-     *
-     * @return ArrayHasKey
-     */
-    public static function arrayHasKey($key)
-    {
-        return new ArrayHasKey($key);
-    }
-
-    /**
-     * @param mixed $value
-     * @param float $delta
-     * @param int   $maxDepth
-     * @param bool  $canonicalize
-     * @param bool  $ignoreCase
-     *
-     * @return IsEqual
-     */
-    public static function equalTo($value, $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
-    {
-        return new IsEqual(
-            $value,
-            $delta,
-            $maxDepth,
-            $canonicalize,
-            $ignoreCase
-        );
-    }
-
-    /**
-     * @param string $attributeName
-     * @param mixed  $value
-     * @param float  $delta
-     * @param int    $maxDepth
-     * @param bool   $canonicalize
-     * @param bool   $ignoreCase
-     *
-     * @return Attribute
-     */
-    public static function attributeEqualTo($attributeName, $value, $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
-    {
-        return static::attribute(
-            static::equalTo(
-                $value,
-                $delta,
-                $maxDepth,
-                $canonicalize,
-                $ignoreCase
-            ),
-            $attributeName
-        );
-    }
-
-    /**
-     * @return IsEmpty
-     */
-    public static function isEmpty()
-    {
-        return new IsEmpty;
-    }
-
-    /**
-     * @return IsWritable
-     */
-    public static function isWritable()
-    {
-        return new IsWritable;
-    }
-
-    /**
-     * @return IsReadable
-     */
-    public static function isReadable()
-    {
-        return new IsReadable;
-    }
-
-    /**
-     * @return DirectoryExists
-     */
-    public static function directoryExists()
-    {
-        return new DirectoryExists;
-    }
-
-    /**
-     * @return FileExists
-     */
-    public static function fileExists()
-    {
-        return new FileExists;
-    }
-
-    /**
-     * @param mixed $value
-     *
-     * @return GreaterThan
-     */
-    public static function greaterThan($value)
-    {
-        return new GreaterThan($value);
-    }
-
-    /**
-     * @param mixed $value
-     *
-     * @return LogicalOr
-     */
-    public static function greaterThanOrEqual($value)
-    {
-        return static::logicalOr(
-            new IsEqual($value),
-            new GreaterThan($value)
-        );
-    }
-
-    /**
-     * @param string $attributeName
-     *
-     * @return ClassHasAttribute
-     */
-    public static function classHasAttribute($attributeName)
-    {
-        return new ClassHasAttribute(
-            $attributeName
-        );
-    }
-
-    /**
-     * @param string $attributeName
-     *
-     * @return ClassHasStaticAttribute
-     */
-    public static function classHasStaticAttribute($attributeName)
-    {
-        return new ClassHasStaticAttribute(
-            $attributeName
-        );
-    }
-
-    /**
-     * @param string $attributeName
-     *
-     * @return ObjectHasAttribute
-     */
-    public static function objectHasAttribute($attributeName)
-    {
-        return new ObjectHasAttribute(
-            $attributeName
-        );
-    }
-
-    /**
-     * @param mixed $value
-     *
-     * @return IsIdentical
-     */
-    public static function identicalTo($value)
-    {
-        return new IsIdentical($value);
-    }
-
-    /**
-     * @param string $className
-     *
-     * @return IsInstanceOf
-     */
-    public static function isInstanceOf($className)
-    {
-        return new IsInstanceOf($className);
-    }
-
-    /**
-     * @param string $type
-     *
-     * @return IsType
-     */
-    public static function isType($type)
-    {
-        return new IsType($type);
-    }
-
-    /**
-     * @param mixed $value
-     *
-     * @return LessThan
-     */
-    public static function lessThan($value)
-    {
-        return new LessThan($value);
-    }
-
-    /**
-     * @param mixed $value
-     *
-     * @return LogicalOr
-     */
-    public static function lessThanOrEqual($value)
-    {
-        return static::logicalOr(
-            new IsEqual($value),
-            new LessThan($value)
-        );
-    }
-
-    /**
-     * @param string $pattern
-     *
-     * @return RegularExpression
-     */
-    public static function matchesRegularExpression($pattern)
-    {
-        return new RegularExpression($pattern);
-    }
-
-    /**
-     * @param string $string
-     *
-     * @return StringMatchesFormatDescription
-     */
-    public static function matches($string)
-    {
-        return new StringMatchesFormatDescription($string);
-    }
-
-    /**
-     * @param mixed $prefix
-     *
-     * @return StringStartsWith
-     */
-    public static function stringStartsWith($prefix)
-    {
-        return new StringStartsWith($prefix);
-    }
-
-    /**
-     * @param string $string
-     * @param bool   $case
-     *
-     * @return StringContains
-     */
-    public static function stringContains($string, $case = true)
-    {
-        return new StringContains($string, $case);
-    }
-
-    /**
-     * @param mixed $suffix
-     *
-     * @return StringEndsWith
-     */
-    public static function stringEndsWith($suffix)
-    {
-        return new StringEndsWith($suffix);
-    }
-
-    /**
-     * @param int $count
-     *
-     * @return Count
-     */
-    public static function countOf($count)
-    {
-        return new Count($count);
-    }
-
-    /**
-     * Fails a test with the given message.
-     *
-     * @param string $message
-     *
-     * @throws AssertionFailedError
-     */
-    public static function fail($message = '')
-    {
-        self::$count++;
-
-        throw new AssertionFailedError($message);
-    }
-
-    /**
-     * Returns the value of an attribute of a class or an object.
-     * This also works for attributes that are declared protected or private.
-     *
-     * @param string|object $classOrObject
-     * @param string        $attributeName
-     *
-     * @return mixed
-     *
-     * @throws Exception
-     */
-    public static function readAttribute($classOrObject, $attributeName)
-    {
-        if (!\is_string($attributeName)) {
-            throw InvalidArgumentHelper::factory(2, 'string');
-        }
-
-        if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
-            throw InvalidArgumentHelper::factory(2, 'valid attribute name');
-        }
-
-        if (\is_string($classOrObject)) {
-            if (!\class_exists($classOrObject)) {
-                throw InvalidArgumentHelper::factory(
-                    1,
-                    'class name'
-                );
-            }
-
-            return static::getStaticAttribute(
-                $classOrObject,
-                $attributeName
-            );
-        }
-
-        if (\is_object($classOrObject)) {
-            return static::getObjectAttribute(
-                $classOrObject,
-                $attributeName
-            );
-        }
-
-        throw InvalidArgumentHelper::factory(
-            1,
-            'class name or object'
-        );
-    }
-
-    /**
-     * Returns the value of a static attribute.
-     * This also works for attributes that are declared protected or private.
-     *
-     * @param string $className
-     * @param string $attributeName
-     *
-     * @return mixed
-     *
-     * @throws Exception
-     */
-    public static function getStaticAttribute($className, $attributeName)
-    {
-        if (!\is_string($className)) {
-            throw InvalidArgumentHelper::factory(1, 'string');
-        }
-
-        if (!\class_exists($className)) {
-            throw InvalidArgumentHelper::factory(1, 'class name');
-        }
-
-        if (!\is_string($attributeName)) {
-            throw InvalidArgumentHelper::factory(2, 'string');
-        }
-
-        if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
-            throw InvalidArgumentHelper::factory(2, 'valid attribute name');
-        }
-
-        $class = new ReflectionClass($className);
-
-        while ($class) {
-            $attributes = $class->getStaticProperties();
-
-            if (\array_key_exists($attributeName, $attributes)) {
-                return $attributes[$attributeName];
-            }
-
-            $class = $class->getParentClass();
-        }
-
-        throw new Exception(
-            \sprintf(
-                'Attribute "%s" not found in class.',
-                $attributeName
-            )
-        );
-    }
-
-    /**
-     * Returns the value of an object's attribute.
-     * This also works for attributes that are declared protected or private.
-     *
-     * @param object $object
-     * @param string $attributeName
-     *
-     * @return mixed
-     *
-     * @throws Exception
-     */
-    public static function getObjectAttribute($object, $attributeName)
-    {
-        if (!\is_object($object)) {
-            throw InvalidArgumentHelper::factory(1, 'object');
-        }
-
-        if (!\is_string($attributeName)) {
-            throw InvalidArgumentHelper::factory(2, 'string');
-        }
-
-        if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
-            throw InvalidArgumentHelper::factory(2, 'valid attribute name');
-        }
-
-        try {
-            $attribute = new ReflectionProperty($object, $attributeName);
-        } catch (ReflectionException $e) {
-            $reflector = new ReflectionObject($object);
-
-            while ($reflector = $reflector->getParentClass()) {
-                try {
-                    $attribute = $reflector->getProperty($attributeName);
-
-                    break;
-                } catch (ReflectionException $e) {
-                }
-            }
-        }
-
-        if (isset($attribute)) {
-            if (!$attribute || $attribute->isPublic()) {
-                return $object->$attributeName;
-            }
-
-            $attribute->setAccessible(true);
-            $value = $attribute->getValue($object);
-            $attribute->setAccessible(false);
-
-            return $value;
-        }
-
-        throw new Exception(
-            \sprintf(
-                'Attribute "%s" not found in object.',
-                $attributeName
-            )
-        );
-    }
-
-    /**
-     * Mark the test as incomplete.
-     *
-     * @param string $message
-     *
-     * @throws IncompleteTestError
-     */
-    public static function markTestIncomplete($message = '')
-    {
-        throw new IncompleteTestError($message);
-    }
-
-    /**
-     * Mark the test as skipped.
-     *
-     * @param string $message
-     *
-     * @throws SkippedTestError
-     */
-    public static function markTestSkipped($message = '')
-    {
-        throw new SkippedTestError($message);
-    }
-
-    /**
-     * Return the current assertion count.
-     *
-     * @return int
-     */
-    public static function getCount()
-    {
-        return self::$count;
-    }
-
-    /**
-     * Reset the assertion counter.
-     */
-    public static function resetCount()
-    {
-        self::$count = 0;
-    }
+	/**
+	 * @var int
+	 */
+	private static $count = 0;
+
+	/**
+	 * Asserts that an array has a specified key.
+	 *
+	 * @param mixed             $key
+	 * @param array|ArrayAccess $array
+	 * @param string            $message
+	 */
+	public static function assertArrayHasKey($key, $array, $message = '')
+	{
+		if (!(\is_int($key) || \is_string($key))) {
+			throw InvalidArgumentHelper::factory(
+				1,
+				'integer or string'
+			);
+		}
+
+		if (!(\is_array($array) || $array instanceof ArrayAccess)) {
+			throw InvalidArgumentHelper::factory(
+				2,
+				'array or ArrayAccess'
+			);
+		}
+
+		$constraint = new ArrayHasKey($key);
+
+		static::assertThat($array, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that an array has a specified subset.
+	 *
+	 * @param array|ArrayAccess $subset
+	 * @param array|ArrayAccess $array
+	 * @param bool              $strict  Check for object identity
+	 * @param string            $message
+	 */
+	public static function assertArraySubset($subset, $array, $strict = false, $message = '')
+	{
+		if (!(\is_array($subset) || $subset instanceof ArrayAccess)) {
+			throw InvalidArgumentHelper::factory(
+				1,
+				'array or ArrayAccess'
+			);
+		}
+
+		if (!(\is_array($array) || $array instanceof ArrayAccess)) {
+			throw InvalidArgumentHelper::factory(
+				2,
+				'array or ArrayAccess'
+			);
+		}
+
+		$constraint = new ArraySubset($subset, $strict);
+
+		static::assertThat($array, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that an array does not have a specified key.
+	 *
+	 * @param mixed             $key
+	 * @param array|ArrayAccess $array
+	 * @param string            $message
+	 */
+	public static function assertArrayNotHasKey($key, $array, $message = '')
+	{
+		if (!(\is_int($key) || \is_string($key))) {
+			throw InvalidArgumentHelper::factory(
+				1,
+				'integer or string'
+			);
+		}
+
+		if (!(\is_array($array) || $array instanceof ArrayAccess)) {
+			throw InvalidArgumentHelper::factory(
+				2,
+				'array or ArrayAccess'
+			);
+		}
+
+		$constraint = new LogicalNot(
+			new ArrayHasKey($key)
+		);
+
+		static::assertThat($array, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a haystack contains a needle.
+	 *
+	 * @param mixed  $needle
+	 * @param mixed  $haystack
+	 * @param string $message
+	 * @param bool   $ignoreCase
+	 * @param bool   $checkForObjectIdentity
+	 * @param bool   $checkForNonObjectIdentity
+	 */
+	public static function assertContains($needle, $haystack, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
+	{
+		if (\is_array($haystack) ||
+			(\is_object($haystack) && $haystack instanceof Traversable)) {
+			$constraint = new TraversableContains(
+				$needle,
+				$checkForObjectIdentity,
+				$checkForNonObjectIdentity
+			);
+		} elseif (\is_string($haystack)) {
+			if (!\is_string($needle)) {
+				throw InvalidArgumentHelper::factory(
+					1,
+					'string'
+				);
+			}
+
+			$constraint = new StringContains(
+				$needle,
+				$ignoreCase
+			);
+		} else {
+			throw InvalidArgumentHelper::factory(
+				2,
+				'array, traversable or string'
+			);
+		}
+
+		static::assertThat($haystack, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a haystack that is stored in a static attribute of a class
+	 * or an attribute of an object contains a needle.
+	 *
+	 * @param mixed         $needle
+	 * @param string        $haystackAttributeName
+	 * @param string|object $haystackClassOrObject
+	 * @param string        $message
+	 * @param bool          $ignoreCase
+	 * @param bool          $checkForObjectIdentity
+	 * @param bool          $checkForNonObjectIdentity
+	 */
+	public static function assertAttributeContains($needle, $haystackAttributeName, $haystackClassOrObject, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
+	{
+		static::assertContains(
+			$needle,
+			static::readAttribute($haystackClassOrObject, $haystackAttributeName),
+			$message,
+			$ignoreCase,
+			$checkForObjectIdentity,
+			$checkForNonObjectIdentity
+		);
+	}
+
+	/**
+	 * Asserts that a haystack does not contain a needle.
+	 *
+	 * @param mixed  $needle
+	 * @param mixed  $haystack
+	 * @param string $message
+	 * @param bool   $ignoreCase
+	 * @param bool   $checkForObjectIdentity
+	 * @param bool   $checkForNonObjectIdentity
+	 */
+	public static function assertNotContains($needle, $haystack, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
+	{
+		if (\is_array($haystack) ||
+			(\is_object($haystack) && $haystack instanceof Traversable)) {
+			$constraint = new LogicalNot(
+				new TraversableContains(
+					$needle,
+					$checkForObjectIdentity,
+					$checkForNonObjectIdentity
+				)
+			);
+		} elseif (\is_string($haystack)) {
+			if (!\is_string($needle)) {
+				throw InvalidArgumentHelper::factory(
+					1,
+					'string'
+				);
+			}
+
+			$constraint = new LogicalNot(
+				new StringContains(
+					$needle,
+					$ignoreCase
+				)
+			);
+		} else {
+			throw InvalidArgumentHelper::factory(
+				2,
+				'array, traversable or string'
+			);
+		}
+
+		static::assertThat($haystack, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a haystack that is stored in a static attribute of a class
+	 * or an attribute of an object does not contain a needle.
+	 *
+	 * @param mixed         $needle
+	 * @param string        $haystackAttributeName
+	 * @param string|object $haystackClassOrObject
+	 * @param string        $message
+	 * @param bool          $ignoreCase
+	 * @param bool          $checkForObjectIdentity
+	 * @param bool          $checkForNonObjectIdentity
+	 */
+	public static function assertAttributeNotContains($needle, $haystackAttributeName, $haystackClassOrObject, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
+	{
+		static::assertNotContains(
+			$needle,
+			static::readAttribute($haystackClassOrObject, $haystackAttributeName),
+			$message,
+			$ignoreCase,
+			$checkForObjectIdentity,
+			$checkForNonObjectIdentity
+		);
+	}
+
+	/**
+	 * Asserts that a haystack contains only values of a given type.
+	 *
+	 * @param string $type
+	 * @param mixed  $haystack
+	 * @param bool   $isNativeType
+	 * @param string $message
+	 */
+	public static function assertContainsOnly($type, $haystack, $isNativeType = null, $message = '')
+	{
+		if (!\is_array($haystack) &&
+			!(\is_object($haystack) && $haystack instanceof Traversable)) {
+			throw InvalidArgumentHelper::factory(
+				2,
+				'array or traversable'
+			);
+		}
+
+		if ($isNativeType == null) {
+			$isNativeType = Type::isType($type);
+		}
+
+		static::assertThat(
+			$haystack,
+			new TraversableContainsOnly(
+				$type,
+				$isNativeType
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a haystack contains only instances of a given classname
+	 *
+	 * @param string             $classname
+	 * @param array|\Traversable $haystack
+	 * @param string             $message
+	 */
+	public static function assertContainsOnlyInstancesOf($classname, $haystack, $message = '')
+	{
+		if (!\is_array($haystack) &&
+			!(\is_object($haystack) && $haystack instanceof Traversable)) {
+			throw InvalidArgumentHelper::factory(
+				2,
+				'array or traversable'
+			);
+		}
+
+		static::assertThat(
+			$haystack,
+			new TraversableContainsOnly(
+				$classname,
+				false
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a haystack that is stored in a static attribute of a class
+	 * or an attribute of an object contains only values of a given type.
+	 *
+	 * @param string        $type
+	 * @param string        $haystackAttributeName
+	 * @param string|object $haystackClassOrObject
+	 * @param bool          $isNativeType
+	 * @param string        $message
+	 */
+	public static function assertAttributeContainsOnly($type, $haystackAttributeName, $haystackClassOrObject, $isNativeType = null, $message = '')
+	{
+		static::assertContainsOnly(
+			$type,
+			static::readAttribute($haystackClassOrObject, $haystackAttributeName),
+			$isNativeType,
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a haystack does not contain only values of a given type.
+	 *
+	 * @param string $type
+	 * @param mixed  $haystack
+	 * @param bool   $isNativeType
+	 * @param string $message
+	 */
+	public static function assertNotContainsOnly($type, $haystack, $isNativeType = null, $message = '')
+	{
+		if (!\is_array($haystack) &&
+			!(\is_object($haystack) && $haystack instanceof Traversable)) {
+			throw InvalidArgumentHelper::factory(
+				2,
+				'array or traversable'
+			);
+		}
+
+		if ($isNativeType == null) {
+			$isNativeType = Type::isType($type);
+		}
+
+		static::assertThat(
+			$haystack,
+			new LogicalNot(
+				new TraversableContainsOnly(
+					$type,
+					$isNativeType
+				)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a haystack that is stored in a static attribute of a class
+	 * or an attribute of an object does not contain only values of a given
+	 * type.
+	 *
+	 * @param string        $type
+	 * @param string        $haystackAttributeName
+	 * @param string|object $haystackClassOrObject
+	 * @param bool          $isNativeType
+	 * @param string        $message
+	 */
+	public static function assertAttributeNotContainsOnly($type, $haystackAttributeName, $haystackClassOrObject, $isNativeType = null, $message = '')
+	{
+		static::assertNotContainsOnly(
+			$type,
+			static::readAttribute($haystackClassOrObject, $haystackAttributeName),
+			$isNativeType,
+			$message
+		);
+	}
+
+	/**
+	 * Asserts the number of elements of an array, Countable or Traversable.
+	 *
+	 * @param int    $expectedCount
+	 * @param mixed  $haystack
+	 * @param string $message
+	 */
+	public static function assertCount($expectedCount, $haystack, $message = '')
+	{
+		if (!\is_int($expectedCount)) {
+			throw InvalidArgumentHelper::factory(1, 'integer');
+		}
+
+		if (!$haystack instanceof Countable &&
+			!$haystack instanceof Traversable &&
+			!\is_array($haystack)) {
+			throw InvalidArgumentHelper::factory(2, 'countable or traversable');
+		}
+
+		static::assertThat(
+			$haystack,
+			new Count($expectedCount),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts the number of elements of an array, Countable or Traversable
+	 * that is stored in an attribute.
+	 *
+	 * @param int           $expectedCount
+	 * @param string        $haystackAttributeName
+	 * @param string|object $haystackClassOrObject
+	 * @param string        $message
+	 */
+	public static function assertAttributeCount($expectedCount, $haystackAttributeName, $haystackClassOrObject, $message = '')
+	{
+		static::assertCount(
+			$expectedCount,
+			static::readAttribute($haystackClassOrObject, $haystackAttributeName),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts the number of elements of an array, Countable or Traversable.
+	 *
+	 * @param int    $expectedCount
+	 * @param mixed  $haystack
+	 * @param string $message
+	 */
+	public static function assertNotCount($expectedCount, $haystack, $message = '')
+	{
+		if (!\is_int($expectedCount)) {
+			throw InvalidArgumentHelper::factory(1, 'integer');
+		}
+
+		if (!$haystack instanceof Countable &&
+			!$haystack instanceof Traversable &&
+			!\is_array($haystack)) {
+			throw InvalidArgumentHelper::factory(2, 'countable or traversable');
+		}
+
+		$constraint = new LogicalNot(
+			new Count($expectedCount)
+		);
+
+		static::assertThat($haystack, $constraint, $message);
+	}
+
+	/**
+	 * Asserts the number of elements of an array, Countable or Traversable
+	 * that is stored in an attribute.
+	 *
+	 * @param int           $expectedCount
+	 * @param string        $haystackAttributeName
+	 * @param string|object $haystackClassOrObject
+	 * @param string        $message
+	 */
+	public static function assertAttributeNotCount($expectedCount, $haystackAttributeName, $haystackClassOrObject, $message = '')
+	{
+		static::assertNotCount(
+			$expectedCount,
+			static::readAttribute($haystackClassOrObject, $haystackAttributeName),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that two variables are equal.
+	 *
+	 * @param mixed  $expected
+	 * @param mixed  $actual
+	 * @param string $message
+	 * @param float  $delta
+	 * @param int    $maxDepth
+	 * @param bool   $canonicalize
+	 * @param bool   $ignoreCase
+	 */
+	public static function assertEquals($expected, $actual, $message = '', $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
+	{
+		$constraint = new IsEqual(
+			$expected,
+			$delta,
+			$maxDepth,
+			$canonicalize,
+			$ignoreCase
+		);
+
+		static::assertThat($actual, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a variable is equal to an attribute of an object.
+	 *
+	 * @param mixed         $expected
+	 * @param string        $actualAttributeName
+	 * @param string|object $actualClassOrObject
+	 * @param string        $message
+	 * @param float         $delta
+	 * @param int           $maxDepth
+	 * @param bool          $canonicalize
+	 * @param bool          $ignoreCase
+	 */
+	public static function assertAttributeEquals($expected, $actualAttributeName, $actualClassOrObject, $message = '', $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
+	{
+		static::assertEquals(
+			$expected,
+			static::readAttribute($actualClassOrObject, $actualAttributeName),
+			$message,
+			$delta,
+			$maxDepth,
+			$canonicalize,
+			$ignoreCase
+		);
+	}
+
+	/**
+	 * Asserts that two variables are not equal.
+	 *
+	 * @param mixed  $expected
+	 * @param mixed  $actual
+	 * @param string $message
+	 * @param float  $delta
+	 * @param int    $maxDepth
+	 * @param bool   $canonicalize
+	 * @param bool   $ignoreCase
+	 */
+	public static function assertNotEquals($expected, $actual, $message = '', $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
+	{
+		$constraint = new LogicalNot(
+			new IsEqual(
+				$expected,
+				$delta,
+				$maxDepth,
+				$canonicalize,
+				$ignoreCase
+			)
+		);
+
+		static::assertThat($actual, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a variable is not equal to an attribute of an object.
+	 *
+	 * @param mixed         $expected
+	 * @param string        $actualAttributeName
+	 * @param string|object $actualClassOrObject
+	 * @param string        $message
+	 * @param float         $delta
+	 * @param int           $maxDepth
+	 * @param bool          $canonicalize
+	 * @param bool          $ignoreCase
+	 */
+	public static function assertAttributeNotEquals($expected, $actualAttributeName, $actualClassOrObject, $message = '', $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
+	{
+		static::assertNotEquals(
+			$expected,
+			static::readAttribute($actualClassOrObject, $actualAttributeName),
+			$message,
+			$delta,
+			$maxDepth,
+			$canonicalize,
+			$ignoreCase
+		);
+	}
+
+	/**
+	 * Asserts that a variable is empty.
+	 *
+	 * @param mixed  $actual
+	 * @param string $message
+	 *
+	 * @throws AssertionFailedError
+	 */
+	public static function assertEmpty($actual, $message = '')
+	{
+		static::assertThat($actual, static::isEmpty(), $message);
+	}
+
+	/**
+	 * Asserts that a static attribute of a class or an attribute of an object
+	 * is empty.
+	 *
+	 * @param string        $haystackAttributeName
+	 * @param string|object $haystackClassOrObject
+	 * @param string        $message
+	 */
+	public static function assertAttributeEmpty($haystackAttributeName, $haystackClassOrObject, $message = '')
+	{
+		static::assertEmpty(
+			static::readAttribute($haystackClassOrObject, $haystackAttributeName),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is not empty.
+	 *
+	 * @param mixed  $actual
+	 * @param string $message
+	 *
+	 * @throws AssertionFailedError
+	 */
+	public static function assertNotEmpty($actual, $message = '')
+	{
+		static::assertThat($actual, static::logicalNot(static::isEmpty()), $message);
+	}
+
+	/**
+	 * Asserts that a static attribute of a class or an attribute of an object
+	 * is not empty.
+	 *
+	 * @param string        $haystackAttributeName
+	 * @param string|object $haystackClassOrObject
+	 * @param string        $message
+	 */
+	public static function assertAttributeNotEmpty($haystackAttributeName, $haystackClassOrObject, $message = '')
+	{
+		static::assertNotEmpty(
+			static::readAttribute($haystackClassOrObject, $haystackAttributeName),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a value is greater than another value.
+	 *
+	 * @param mixed  $expected
+	 * @param mixed  $actual
+	 * @param string $message
+	 */
+	public static function assertGreaterThan($expected, $actual, $message = '')
+	{
+		static::assertThat($actual, static::greaterThan($expected), $message);
+	}
+
+	/**
+	 * Asserts that an attribute is greater than another value.
+	 *
+	 * @param mixed         $expected
+	 * @param string        $actualAttributeName
+	 * @param string|object $actualClassOrObject
+	 * @param string        $message
+	 */
+	public static function assertAttributeGreaterThan($expected, $actualAttributeName, $actualClassOrObject, $message = '')
+	{
+		static::assertGreaterThan(
+			$expected,
+			static::readAttribute($actualClassOrObject, $actualAttributeName),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a value is greater than or equal to another value.
+	 *
+	 * @param mixed  $expected
+	 * @param mixed  $actual
+	 * @param string $message
+	 */
+	public static function assertGreaterThanOrEqual($expected, $actual, $message = '')
+	{
+		static::assertThat(
+			$actual,
+			static::greaterThanOrEqual($expected),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that an attribute is greater than or equal to another value.
+	 *
+	 * @param mixed         $expected
+	 * @param string        $actualAttributeName
+	 * @param string|object $actualClassOrObject
+	 * @param string        $message
+	 */
+	public static function assertAttributeGreaterThanOrEqual($expected, $actualAttributeName, $actualClassOrObject, $message = '')
+	{
+		static::assertGreaterThanOrEqual(
+			$expected,
+			static::readAttribute($actualClassOrObject, $actualAttributeName),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a value is smaller than another value.
+	 *
+	 * @param mixed  $expected
+	 * @param mixed  $actual
+	 * @param string $message
+	 */
+	public static function assertLessThan($expected, $actual, $message = '')
+	{
+		static::assertThat($actual, static::lessThan($expected), $message);
+	}
+
+	/**
+	 * Asserts that an attribute is smaller than another value.
+	 *
+	 * @param mixed         $expected
+	 * @param string        $actualAttributeName
+	 * @param string|object $actualClassOrObject
+	 * @param string        $message
+	 */
+	public static function assertAttributeLessThan($expected, $actualAttributeName, $actualClassOrObject, $message = '')
+	{
+		static::assertLessThan(
+			$expected,
+			static::readAttribute($actualClassOrObject, $actualAttributeName),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a value is smaller than or equal to another value.
+	 *
+	 * @param mixed  $expected
+	 * @param mixed  $actual
+	 * @param string $message
+	 */
+	public static function assertLessThanOrEqual($expected, $actual, $message = '')
+	{
+		static::assertThat($actual, static::lessThanOrEqual($expected), $message);
+	}
+
+	/**
+	 * Asserts that an attribute is smaller than or equal to another value.
+	 *
+	 * @param mixed         $expected
+	 * @param string        $actualAttributeName
+	 * @param string|object $actualClassOrObject
+	 * @param string        $message
+	 */
+	public static function assertAttributeLessThanOrEqual($expected, $actualAttributeName, $actualClassOrObject, $message = '')
+	{
+		static::assertLessThanOrEqual(
+			$expected,
+			static::readAttribute($actualClassOrObject, $actualAttributeName),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that the contents of one file is equal to the contents of another
+	 * file.
+	 *
+	 * @param string $expected
+	 * @param string $actual
+	 * @param string $message
+	 * @param bool   $canonicalize
+	 * @param bool   $ignoreCase
+	 */
+	public static function assertFileEquals($expected, $actual, $message = '', $canonicalize = false, $ignoreCase = false)
+	{
+		static::assertFileExists($expected, $message);
+		static::assertFileExists($actual, $message);
+
+		static::assertEquals(
+			\file_get_contents($expected),
+			\file_get_contents($actual),
+			$message,
+			0,
+			10,
+			$canonicalize,
+			$ignoreCase
+		);
+	}
+
+	/**
+	 * Asserts that the contents of one file is not equal to the contents of
+	 * another file.
+	 *
+	 * @param string $expected
+	 * @param string $actual
+	 * @param string $message
+	 * @param bool   $canonicalize
+	 * @param bool   $ignoreCase
+	 */
+	public static function assertFileNotEquals($expected, $actual, $message = '', $canonicalize = false, $ignoreCase = false)
+	{
+		static::assertFileExists($expected, $message);
+		static::assertFileExists($actual, $message);
+
+		static::assertNotEquals(
+			\file_get_contents($expected),
+			\file_get_contents($actual),
+			$message,
+			0,
+			10,
+			$canonicalize,
+			$ignoreCase
+		);
+	}
+
+	/**
+	 * Asserts that the contents of a string is equal
+	 * to the contents of a file.
+	 *
+	 * @param string $expectedFile
+	 * @param string $actualString
+	 * @param string $message
+	 * @param bool   $canonicalize
+	 * @param bool   $ignoreCase
+	 */
+	public static function assertStringEqualsFile($expectedFile, $actualString, $message = '', $canonicalize = false, $ignoreCase = false)
+	{
+		static::assertFileExists($expectedFile, $message);
+
+		static::assertEquals(
+			\file_get_contents($expectedFile),
+			$actualString,
+			$message,
+			0,
+			10,
+			$canonicalize,
+			$ignoreCase
+		);
+	}
+
+	/**
+	 * Asserts that the contents of a string is not equal
+	 * to the contents of a file.
+	 *
+	 * @param string $expectedFile
+	 * @param string $actualString
+	 * @param string $message
+	 * @param bool   $canonicalize
+	 * @param bool   $ignoreCase
+	 */
+	public static function assertStringNotEqualsFile($expectedFile, $actualString, $message = '', $canonicalize = false, $ignoreCase = false)
+	{
+		static::assertFileExists($expectedFile, $message);
+
+		static::assertNotEquals(
+			\file_get_contents($expectedFile),
+			$actualString,
+			$message,
+			0,
+			10,
+			$canonicalize,
+			$ignoreCase
+		);
+	}
+
+	/**
+	 * Asserts that a file/dir is readable.
+	 *
+	 * @param string $filename
+	 * @param string $message
+	 */
+	public static function assertIsReadable($filename, $message = '')
+	{
+		if (!\is_string($filename)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		$constraint = new IsReadable;
+
+		static::assertThat($filename, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a file/dir exists and is not readable.
+	 *
+	 * @param string $filename
+	 * @param string $message
+	 */
+	public static function assertNotIsReadable($filename, $message = '')
+	{
+		if (!\is_string($filename)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		$constraint = new LogicalNot(
+			new IsReadable
+		);
+
+		static::assertThat($filename, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a file/dir exists and is writable.
+	 *
+	 * @param string $filename
+	 * @param string $message
+	 */
+	public static function assertIsWritable($filename, $message = '')
+	{
+		if (!\is_string($filename)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		$constraint = new IsWritable;
+
+		static::assertThat($filename, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a file/dir exists and is not writable.
+	 *
+	 * @param string $filename
+	 * @param string $message
+	 */
+	public static function assertNotIsWritable($filename, $message = '')
+	{
+		if (!\is_string($filename)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		$constraint = new LogicalNot(
+			new IsWritable
+		);
+
+		static::assertThat($filename, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a directory exists.
+	 *
+	 * @param string $directory
+	 * @param string $message
+	 */
+	public static function assertDirectoryExists($directory, $message = '')
+	{
+		if (!\is_string($directory)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		$constraint = new DirectoryExists;
+
+		static::assertThat($directory, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a directory does not exist.
+	 *
+	 * @param string $directory
+	 * @param string $message
+	 */
+	public static function assertDirectoryNotExists($directory, $message = '')
+	{
+		if (!\is_string($directory)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		$constraint = new LogicalNot(
+			new DirectoryExists
+		);
+
+		static::assertThat($directory, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a directory exists and is readable.
+	 *
+	 * @param string $directory
+	 * @param string $message
+	 */
+	public static function assertDirectoryIsReadable($directory, $message = '')
+	{
+		self::assertDirectoryExists($directory, $message);
+		self::assertIsReadable($directory, $message);
+	}
+
+	/**
+	 * Asserts that a directory exists and is not readable.
+	 *
+	 * @param string $directory
+	 * @param string $message
+	 */
+	public static function assertDirectoryNotIsReadable($directory, $message = '')
+	{
+		self::assertDirectoryExists($directory, $message);
+		self::assertNotIsReadable($directory, $message);
+	}
+
+	/**
+	 * Asserts that a directory exists and is writable.
+	 *
+	 * @param string $directory
+	 * @param string $message
+	 */
+	public static function assertDirectoryIsWritable($directory, $message = '')
+	{
+		self::assertDirectoryExists($directory, $message);
+		self::assertIsWritable($directory, $message);
+	}
+
+	/**
+	 * Asserts that a directory exists and is not writable.
+	 *
+	 * @param string $directory
+	 * @param string $message
+	 */
+	public static function assertDirectoryNotIsWritable($directory, $message = '')
+	{
+		self::assertDirectoryExists($directory, $message);
+		self::assertNotIsWritable($directory, $message);
+	}
+
+	/**
+	 * Asserts that a file exists.
+	 *
+	 * @param string $filename
+	 * @param string $message
+	 */
+	public static function assertFileExists($filename, $message = '')
+	{
+		if (!\is_string($filename)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		$constraint = new FileExists;
+
+		static::assertThat($filename, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a file does not exist.
+	 *
+	 * @param string $filename
+	 * @param string $message
+	 */
+	public static function assertFileNotExists($filename, $message = '')
+	{
+		if (!\is_string($filename)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		$constraint = new LogicalNot(
+			new FileExists
+		);
+
+		static::assertThat($filename, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a file exists and is readable.
+	 *
+	 * @param string $file
+	 * @param string $message
+	 */
+	public static function assertFileIsReadable($file, $message = '')
+	{
+		self::assertFileExists($file, $message);
+		self::assertIsReadable($file, $message);
+	}
+
+	/**
+	 * Asserts that a file exists and is not readable.
+	 *
+	 * @param string $file
+	 * @param string $message
+	 */
+	public static function assertFileNotIsReadable($file, $message = '')
+	{
+		self::assertFileExists($file, $message);
+		self::assertNotIsReadable($file, $message);
+	}
+
+	/**
+	 * Asserts that a file exists and is writable.
+	 *
+	 * @param string $file
+	 * @param string $message
+	 */
+	public static function assertFileIsWritable($file, $message = '')
+	{
+		self::assertFileExists($file, $message);
+		self::assertIsWritable($file, $message);
+	}
+
+	/**
+	 * Asserts that a file exists and is not writable.
+	 *
+	 * @param string $file
+	 * @param string $message
+	 */
+	public static function assertFileNotIsWritable($file, $message = '')
+	{
+		self::assertFileExists($file, $message);
+		self::assertNotIsWritable($file, $message);
+	}
+
+	/**
+	 * Asserts that a condition is true.
+	 *
+	 * @param bool   $condition
+	 * @param string $message
+	 *
+	 * @throws AssertionFailedError
+	 */
+	public static function assertTrue($condition, $message = '')
+	{
+		static::assertThat($condition, static::isTrue(), $message);
+	}
+
+	/**
+	 * Asserts that a condition is not true.
+	 *
+	 * @param bool   $condition
+	 * @param string $message
+	 *
+	 * @throws AssertionFailedError
+	 */
+	public static function assertNotTrue($condition, $message = '')
+	{
+		static::assertThat($condition, static::logicalNot(static::isTrue()), $message);
+	}
+
+	/**
+	 * Asserts that a condition is false.
+	 *
+	 * @param bool   $condition
+	 * @param string $message
+	 *
+	 * @throws AssertionFailedError
+	 */
+	public static function assertFalse($condition, $message = '')
+	{
+		static::assertThat($condition, static::isFalse(), $message);
+	}
+
+	/**
+	 * Asserts that a condition is not false.
+	 *
+	 * @param bool   $condition
+	 * @param string $message
+	 *
+	 * @throws AssertionFailedError
+	 */
+	public static function assertNotFalse($condition, $message = '')
+	{
+		static::assertThat($condition, static::logicalNot(static::isFalse()), $message);
+	}
+
+	/**
+	 * Asserts that a variable is null.
+	 *
+	 * @param mixed  $actual
+	 * @param string $message
+	 */
+	public static function assertNull($actual, $message = '')
+	{
+		static::assertThat($actual, static::isNull(), $message);
+	}
+
+	/**
+	 * Asserts that a variable is not null.
+	 *
+	 * @param mixed  $actual
+	 * @param string $message
+	 */
+	public static function assertNotNull($actual, $message = '')
+	{
+		static::assertThat($actual, static::logicalNot(static::isNull()), $message);
+	}
+
+	/**
+	 * Asserts that a variable is finite.
+	 *
+	 * @param mixed  $actual
+	 * @param string $message
+	 */
+	public static function assertFinite($actual, $message = '')
+	{
+		static::assertThat($actual, static::isFinite(), $message);
+	}
+
+	/**
+	 * Asserts that a variable is infinite.
+	 *
+	 * @param mixed  $actual
+	 * @param string $message
+	 */
+	public static function assertInfinite($actual, $message = '')
+	{
+		static::assertThat($actual, static::isInfinite(), $message);
+	}
+
+	/**
+	 * Asserts that a variable is nan.
+	 *
+	 * @param mixed  $actual
+	 * @param string $message
+	 */
+	public static function assertNan($actual, $message = '')
+	{
+		static::assertThat($actual, static::isNan(), $message);
+	}
+
+	/**
+	 * Asserts that a class has a specified attribute.
+	 *
+	 * @param string $attributeName
+	 * @param string $className
+	 * @param string $message
+	 */
+	public static function assertClassHasAttribute($attributeName, $className, $message = '')
+	{
+		if (!\is_string($attributeName)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
+			throw InvalidArgumentHelper::factory(1, 'valid attribute name');
+		}
+
+		if (!\is_string($className) || !\class_exists($className)) {
+			throw InvalidArgumentHelper::factory(2, 'class name', $className);
+		}
+
+		$constraint = new ClassHasAttribute(
+			$attributeName
+		);
+
+		static::assertThat($className, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a class does not have a specified attribute.
+	 *
+	 * @param string $attributeName
+	 * @param string $className
+	 * @param string $message
+	 */
+	public static function assertClassNotHasAttribute($attributeName, $className, $message = '')
+	{
+		if (!\is_string($attributeName)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
+			throw InvalidArgumentHelper::factory(1, 'valid attribute name');
+		}
+
+		if (!\is_string($className) || !\class_exists($className)) {
+			throw InvalidArgumentHelper::factory(2, 'class name', $className);
+		}
+
+		$constraint = new LogicalNot(
+			new ClassHasAttribute($attributeName)
+		);
+
+		static::assertThat($className, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a class has a specified static attribute.
+	 *
+	 * @param string $attributeName
+	 * @param string $className
+	 * @param string $message
+	 */
+	public static function assertClassHasStaticAttribute($attributeName, $className, $message = '')
+	{
+		if (!\is_string($attributeName)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
+			throw InvalidArgumentHelper::factory(1, 'valid attribute name');
+		}
+
+		if (!\is_string($className) || !\class_exists($className)) {
+			throw InvalidArgumentHelper::factory(2, 'class name', $className);
+		}
+
+		$constraint = new ClassHasStaticAttribute(
+			$attributeName
+		);
+
+		static::assertThat($className, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a class does not have a specified static attribute.
+	 *
+	 * @param string $attributeName
+	 * @param string $className
+	 * @param string $message
+	 */
+	public static function assertClassNotHasStaticAttribute($attributeName, $className, $message = '')
+	{
+		if (!\is_string($attributeName)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
+			throw InvalidArgumentHelper::factory(1, 'valid attribute name');
+		}
+
+		if (!\is_string($className) || !\class_exists($className)) {
+			throw InvalidArgumentHelper::factory(2, 'class name', $className);
+		}
+
+		$constraint = new LogicalNot(
+			new ClassHasStaticAttribute(
+				$attributeName
+			)
+		);
+
+		static::assertThat($className, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that an object has a specified attribute.
+	 *
+	 * @param string $attributeName
+	 * @param object $object
+	 * @param string $message
+	 */
+	public static function assertObjectHasAttribute($attributeName, $object, $message = '')
+	{
+		if (!\is_string($attributeName)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
+			throw InvalidArgumentHelper::factory(1, 'valid attribute name');
+		}
+
+		if (!\is_object($object)) {
+			throw InvalidArgumentHelper::factory(2, 'object');
+		}
+
+		$constraint = new ObjectHasAttribute(
+			$attributeName
+		);
+
+		static::assertThat($object, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that an object does not have a specified attribute.
+	 *
+	 * @param string $attributeName
+	 * @param object $object
+	 * @param string $message
+	 */
+	public static function assertObjectNotHasAttribute($attributeName, $object, $message = '')
+	{
+		if (!\is_string($attributeName)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
+			throw InvalidArgumentHelper::factory(1, 'valid attribute name');
+		}
+
+		if (!\is_object($object)) {
+			throw InvalidArgumentHelper::factory(2, 'object');
+		}
+
+		$constraint = new LogicalNot(
+			new ObjectHasAttribute($attributeName)
+		);
+
+		static::assertThat($object, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that two variables have the same type and value.
+	 * Used on objects, it asserts that two variables reference
+	 * the same object.
+	 *
+	 * @param mixed  $expected
+	 * @param mixed  $actual
+	 * @param string $message
+	 */
+	public static function assertSame($expected, $actual, $message = '')
+	{
+		if (\is_bool($expected) && \is_bool($actual)) {
+			static::assertEquals($expected, $actual, $message);
+		} else {
+			$constraint = new IsIdentical(
+				$expected
+			);
+
+			static::assertThat($actual, $constraint, $message);
+		}
+	}
+
+	/**
+	 * Asserts that a variable and an attribute of an object have the same type
+	 * and value.
+	 *
+	 * @param mixed         $expected
+	 * @param string        $actualAttributeName
+	 * @param string|object $actualClassOrObject
+	 * @param string        $message
+	 */
+	public static function assertAttributeSame($expected, $actualAttributeName, $actualClassOrObject, $message = '')
+	{
+		static::assertSame(
+			$expected,
+			static::readAttribute($actualClassOrObject, $actualAttributeName),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that two variables do not have the same type and value.
+	 * Used on objects, it asserts that two variables do not reference
+	 * the same object.
+	 *
+	 * @param mixed  $expected
+	 * @param mixed  $actual
+	 * @param string $message
+	 */
+	public static function assertNotSame($expected, $actual, $message = '')
+	{
+		if (\is_bool($expected) && \is_bool($actual)) {
+			static::assertNotEquals($expected, $actual, $message);
+		} else {
+			$constraint = new LogicalNot(
+				new IsIdentical($expected)
+			);
+
+			static::assertThat($actual, $constraint, $message);
+		}
+	}
+
+	/**
+	 * Asserts that a variable and an attribute of an object do not have the
+	 * same type and value.
+	 *
+	 * @param mixed         $expected
+	 * @param string        $actualAttributeName
+	 * @param string|object $actualClassOrObject
+	 * @param string        $message
+	 */
+	public static function assertAttributeNotSame($expected, $actualAttributeName, $actualClassOrObject, $message = '')
+	{
+		static::assertNotSame(
+			$expected,
+			static::readAttribute($actualClassOrObject, $actualAttributeName),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is of a given type.
+	 *
+	 * @param string $expected
+	 * @param mixed  $actual
+	 * @param string $message
+	 */
+	public static function assertInstanceOf($expected, $actual, $message = '')
+	{
+		if (!(\is_string($expected) && (\class_exists($expected) || \interface_exists($expected)))) {
+			throw InvalidArgumentHelper::factory(1, 'class or interface name');
+		}
+
+		$constraint = new IsInstanceOf(
+			$expected
+		);
+
+		static::assertThat($actual, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that an attribute is of a given type.
+	 *
+	 * @param string        $expected
+	 * @param string        $attributeName
+	 * @param string|object $classOrObject
+	 * @param string        $message
+	 */
+	public static function assertAttributeInstanceOf($expected, $attributeName, $classOrObject, $message = '')
+	{
+		static::assertInstanceOf(
+			$expected,
+			static::readAttribute($classOrObject, $attributeName),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is not of a given type.
+	 *
+	 * @param string $expected
+	 * @param mixed  $actual
+	 * @param string $message
+	 */
+	public static function assertNotInstanceOf($expected, $actual, $message = '')
+	{
+		if (!(\is_string($expected) && (\class_exists($expected) || \interface_exists($expected)))) {
+			throw InvalidArgumentHelper::factory(1, 'class or interface name');
+		}
+
+		$constraint = new LogicalNot(
+			new IsInstanceOf($expected)
+		);
+
+		static::assertThat($actual, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that an attribute is of a given type.
+	 *
+	 * @param string        $expected
+	 * @param string        $attributeName
+	 * @param string|object $classOrObject
+	 * @param string        $message
+	 */
+	public static function assertAttributeNotInstanceOf($expected, $attributeName, $classOrObject, $message = '')
+	{
+		static::assertNotInstanceOf(
+			$expected,
+			static::readAttribute($classOrObject, $attributeName),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is of a given type.
+	 *
+	 * @param string $expected
+	 * @param mixed  $actual
+	 * @param string $message
+	 */
+	public static function assertInternalType($expected, $actual, $message = '')
+	{
+		if (!\is_string($expected)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		$constraint = new IsType(
+			$expected
+		);
+
+		static::assertThat($actual, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that an attribute is of a given type.
+	 *
+	 * @param string        $expected
+	 * @param string        $attributeName
+	 * @param string|object $classOrObject
+	 * @param string        $message
+	 */
+	public static function assertAttributeInternalType($expected, $attributeName, $classOrObject, $message = '')
+	{
+		static::assertInternalType(
+			$expected,
+			static::readAttribute($classOrObject, $attributeName),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is not of a given type.
+	 *
+	 * @param string $expected
+	 * @param mixed  $actual
+	 * @param string $message
+	 */
+	public static function assertNotInternalType($expected, $actual, $message = '')
+	{
+		if (!\is_string($expected)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		$constraint = new LogicalNot(
+			new IsType($expected)
+		);
+
+		static::assertThat($actual, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that an attribute is of a given type.
+	 *
+	 * @param string        $expected
+	 * @param string        $attributeName
+	 * @param string|object $classOrObject
+	 * @param string        $message
+	 */
+	public static function assertAttributeNotInternalType($expected, $attributeName, $classOrObject, $message = '')
+	{
+		static::assertNotInternalType(
+			$expected,
+			static::readAttribute($classOrObject, $attributeName),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a string matches a given regular expression.
+	 *
+	 * @param string $pattern
+	 * @param string $string
+	 * @param string $message
+	 */
+	public static function assertRegExp($pattern, $string, $message = '')
+	{
+		if (!\is_string($pattern)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		if (!\is_string($string)) {
+			throw InvalidArgumentHelper::factory(2, 'string');
+		}
+
+		$constraint = new RegularExpression($pattern);
+
+		static::assertThat($string, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a string does not match a given regular expression.
+	 *
+	 * @param string $pattern
+	 * @param string $string
+	 * @param string $message
+	 */
+	public static function assertNotRegExp($pattern, $string, $message = '')
+	{
+		if (!\is_string($pattern)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		if (!\is_string($string)) {
+			throw InvalidArgumentHelper::factory(2, 'string');
+		}
+
+		$constraint = new LogicalNot(
+			new RegularExpression($pattern)
+		);
+
+		static::assertThat($string, $constraint, $message);
+	}
+
+	/**
+	 * Assert that the size of two arrays (or `Countable` or `Traversable` objects)
+	 * is the same.
+	 *
+	 * @param array|\Countable|\Traversable $expected
+	 * @param array|\Countable|\Traversable $actual
+	 * @param string                        $message
+	 */
+	public static function assertSameSize($expected, $actual, $message = '')
+	{
+		if (!$expected instanceof Countable &&
+			!$expected instanceof Traversable &&
+			!\is_array($expected)) {
+			throw InvalidArgumentHelper::factory(1, 'countable or traversable');
+		}
+
+		if (!$actual instanceof Countable &&
+			!$actual instanceof Traversable &&
+			!\is_array($actual)) {
+			throw InvalidArgumentHelper::factory(2, 'countable or traversable');
+		}
+
+		static::assertThat(
+			$actual,
+			new SameSize($expected),
+			$message
+		);
+	}
+
+	/**
+	 * Assert that the size of two arrays (or `Countable` or `Traversable` objects)
+	 * is not the same.
+	 *
+	 * @param array|\Countable|\Traversable $expected
+	 * @param array|\Countable|\Traversable $actual
+	 * @param string                        $message
+	 */
+	public static function assertNotSameSize($expected, $actual, $message = '')
+	{
+		if (!$expected instanceof Countable &&
+			!$expected instanceof Traversable &&
+			!\is_array($expected)) {
+			throw InvalidArgumentHelper::factory(1, 'countable or traversable');
+		}
+
+		if (!$actual instanceof Countable &&
+			!$actual instanceof Traversable &&
+			!\is_array($actual)) {
+			throw InvalidArgumentHelper::factory(2, 'countable or traversable');
+		}
+
+		$constraint = new LogicalNot(
+			new SameSize($expected)
+		);
+
+		static::assertThat($actual, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a string matches a given format string.
+	 *
+	 * @param string $format
+	 * @param string $string
+	 * @param string $message
+	 */
+	public static function assertStringMatchesFormat($format, $string, $message = '')
+	{
+		if (!\is_string($format)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		if (!\is_string($string)) {
+			throw InvalidArgumentHelper::factory(2, 'string');
+		}
+
+		$constraint = new StringMatchesFormatDescription($format);
+
+		static::assertThat($string, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a string does not match a given format string.
+	 *
+	 * @param string $format
+	 * @param string $string
+	 * @param string $message
+	 */
+	public static function assertStringNotMatchesFormat($format, $string, $message = '')
+	{
+		if (!\is_string($format)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		if (!\is_string($string)) {
+			throw InvalidArgumentHelper::factory(2, 'string');
+		}
+
+		$constraint = new LogicalNot(
+			new StringMatchesFormatDescription($format)
+		);
+
+		static::assertThat($string, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a string matches a given format file.
+	 *
+	 * @param string $formatFile
+	 * @param string $string
+	 * @param string $message
+	 */
+	public static function assertStringMatchesFormatFile($formatFile, $string, $message = '')
+	{
+		static::assertFileExists($formatFile, $message);
+
+		if (!\is_string($string)) {
+			throw InvalidArgumentHelper::factory(2, 'string');
+		}
+
+		$constraint = new StringMatchesFormatDescription(
+			\file_get_contents($formatFile)
+		);
+
+		static::assertThat($string, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a string does not match a given format string.
+	 *
+	 * @param string $formatFile
+	 * @param string $string
+	 * @param string $message
+	 */
+	public static function assertStringNotMatchesFormatFile($formatFile, $string, $message = '')
+	{
+		static::assertFileExists($formatFile, $message);
+
+		if (!\is_string($string)) {
+			throw InvalidArgumentHelper::factory(2, 'string');
+		}
+
+		$constraint = new LogicalNot(
+			new StringMatchesFormatDescription(
+				\file_get_contents($formatFile)
+			)
+		);
+
+		static::assertThat($string, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a string starts with a given prefix.
+	 *
+	 * @param string $prefix
+	 * @param string $string
+	 * @param string $message
+	 */
+	public static function assertStringStartsWith($prefix, $string, $message = '')
+	{
+		if (!\is_string($prefix)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		if (!\is_string($string)) {
+			throw InvalidArgumentHelper::factory(2, 'string');
+		}
+
+		$constraint = new StringStartsWith(
+			$prefix
+		);
+
+		static::assertThat($string, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a string starts not with a given prefix.
+	 *
+	 * @param string $prefix
+	 * @param string $string
+	 * @param string $message
+	 */
+	public static function assertStringStartsNotWith($prefix, $string, $message = '')
+	{
+		if (!\is_string($prefix)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		if (!\is_string($string)) {
+			throw InvalidArgumentHelper::factory(2, 'string');
+		}
+
+		$constraint = new LogicalNot(
+			new StringStartsWith($prefix)
+		);
+
+		static::assertThat($string, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a string ends with a given suffix.
+	 *
+	 * @param string $suffix
+	 * @param string $string
+	 * @param string $message
+	 */
+	public static function assertStringEndsWith($suffix, $string, $message = '')
+	{
+		if (!\is_string($suffix)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		if (!\is_string($string)) {
+			throw InvalidArgumentHelper::factory(2, 'string');
+		}
+
+		$constraint = new StringEndsWith($suffix);
+
+		static::assertThat($string, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a string ends not with a given suffix.
+	 *
+	 * @param string $suffix
+	 * @param string $string
+	 * @param string $message
+	 */
+	public static function assertStringEndsNotWith($suffix, $string, $message = '')
+	{
+		if (!\is_string($suffix)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		if (!\is_string($string)) {
+			throw InvalidArgumentHelper::factory(2, 'string');
+		}
+
+		$constraint = new LogicalNot(
+			new StringEndsWith($suffix)
+		);
+
+		static::assertThat($string, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that two XML files are equal.
+	 *
+	 * @param string $expectedFile
+	 * @param string $actualFile
+	 * @param string $message
+	 */
+	public static function assertXmlFileEqualsXmlFile($expectedFile, $actualFile, $message = '')
+	{
+		$expected = Xml::loadFile($expectedFile);
+		$actual   = Xml::loadFile($actualFile);
+
+		static::assertEquals($expected, $actual, $message);
+	}
+
+	/**
+	 * Asserts that two XML files are not equal.
+	 *
+	 * @param string $expectedFile
+	 * @param string $actualFile
+	 * @param string $message
+	 */
+	public static function assertXmlFileNotEqualsXmlFile($expectedFile, $actualFile, $message = '')
+	{
+		$expected = Xml::loadFile($expectedFile);
+		$actual   = Xml::loadFile($actualFile);
+
+		static::assertNotEquals($expected, $actual, $message);
+	}
+
+	/**
+	 * Asserts that two XML documents are equal.
+	 *
+	 * @param string             $expectedFile
+	 * @param string|DOMDocument $actualXml
+	 * @param string             $message
+	 */
+	public static function assertXmlStringEqualsXmlFile($expectedFile, $actualXml, $message = '')
+	{
+		$expected = Xml::loadFile($expectedFile);
+		$actual   = Xml::load($actualXml);
+
+		static::assertEquals($expected, $actual, $message);
+	}
+
+	/**
+	 * Asserts that two XML documents are not equal.
+	 *
+	 * @param string             $expectedFile
+	 * @param string|DOMDocument $actualXml
+	 * @param string             $message
+	 */
+	public static function assertXmlStringNotEqualsXmlFile($expectedFile, $actualXml, $message = '')
+	{
+		$expected = Xml::loadFile($expectedFile);
+		$actual   = Xml::load($actualXml);
+
+		static::assertNotEquals($expected, $actual, $message);
+	}
+
+	/**
+	 * Asserts that two XML documents are equal.
+	 *
+	 * @param string|DOMDocument $expectedXml
+	 * @param string|DOMDocument $actualXml
+	 * @param string             $message
+	 */
+	public static function assertXmlStringEqualsXmlString($expectedXml, $actualXml, $message = '')
+	{
+		$expected = Xml::load($expectedXml);
+		$actual   = Xml::load($actualXml);
+
+		static::assertEquals($expected, $actual, $message);
+	}
+
+	/**
+	 * Asserts that two XML documents are not equal.
+	 *
+	 * @param string|DOMDocument $expectedXml
+	 * @param string|DOMDocument $actualXml
+	 * @param string             $message
+	 */
+	public static function assertXmlStringNotEqualsXmlString($expectedXml, $actualXml, $message = '')
+	{
+		$expected = Xml::load($expectedXml);
+		$actual   = Xml::load($actualXml);
+
+		static::assertNotEquals($expected, $actual, $message);
+	}
+
+	/**
+	 * Asserts that a hierarchy of DOMElements matches.
+	 *
+	 * @param DOMElement $expectedElement
+	 * @param DOMElement $actualElement
+	 * @param bool       $checkAttributes
+	 * @param string     $message
+	 */
+	public static function assertEqualXMLStructure(DOMElement $expectedElement, DOMElement $actualElement, $checkAttributes = false, $message = '')
+	{
+		$tmp             = new DOMDocument;
+		$expectedElement = $tmp->importNode($expectedElement, true);
+
+		$tmp           = new DOMDocument;
+		$actualElement = $tmp->importNode($actualElement, true);
+
+		unset($tmp);
+
+		static::assertEquals(
+			$expectedElement->tagName,
+			$actualElement->tagName,
+			$message
+		);
+
+		if ($checkAttributes) {
+			static::assertEquals(
+				$expectedElement->attributes->length,
+				$actualElement->attributes->length,
+				\sprintf(
+					'%s%sNumber of attributes on node "%s" does not match',
+					$message,
+					!empty($message) ? "\n" : '',
+					$expectedElement->tagName
+				)
+			);
+
+			for ($i = 0; $i < $expectedElement->attributes->length; $i++) {
+				$expectedAttribute = $expectedElement->attributes->item($i);
+				$actualAttribute   = $actualElement->attributes->getNamedItem(
+					$expectedAttribute->name
+				);
+
+				if (!$actualAttribute) {
+					static::fail(
+						\sprintf(
+							'%s%sCould not find attribute "%s" on node "%s"',
+							$message,
+							!empty($message) ? "\n" : '',
+							$expectedAttribute->name,
+							$expectedElement->tagName
+						)
+					);
+				}
+			}
+		}
+
+		Xml::removeCharacterDataNodes($expectedElement);
+		Xml::removeCharacterDataNodes($actualElement);
+
+		static::assertEquals(
+			$expectedElement->childNodes->length,
+			$actualElement->childNodes->length,
+			\sprintf(
+				'%s%sNumber of child nodes of "%s" differs',
+				$message,
+				!empty($message) ? "\n" : '',
+				$expectedElement->tagName
+			)
+		);
+
+		for ($i = 0; $i < $expectedElement->childNodes->length; $i++) {
+			static::assertEqualXMLStructure(
+				$expectedElement->childNodes->item($i),
+				$actualElement->childNodes->item($i),
+				$checkAttributes,
+				$message
+			);
+		}
+	}
+
+	/**
+	 * Evaluates a PHPUnit\Framework\Constraint matcher object.
+	 *
+	 * @param mixed      $value
+	 * @param Constraint $constraint
+	 * @param string     $message
+	 */
+	public static function assertThat($value, Constraint $constraint, $message = '')
+	{
+		self::$count += \count($constraint);
+
+		$constraint->evaluate($value, $message);
+	}
+
+	/**
+	 * Asserts that a string is a valid JSON string.
+	 *
+	 * @param string $actualJson
+	 * @param string $message
+	 */
+	public static function assertJson($actualJson, $message = '')
+	{
+		if (!\is_string($actualJson)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		static::assertThat($actualJson, static::isJson(), $message);
+	}
+
+	/**
+	 * Asserts that two given JSON encoded objects or arrays are equal.
+	 *
+	 * @param string $expectedJson
+	 * @param string $actualJson
+	 * @param string $message
+	 */
+	public static function assertJsonStringEqualsJsonString($expectedJson, $actualJson, $message = '')
+	{
+		static::assertJson($expectedJson, $message);
+		static::assertJson($actualJson, $message);
+
+		$constraint = new JsonMatches(
+			$expectedJson
+		);
+
+		static::assertThat($actualJson, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that two given JSON encoded objects or arrays are not equal.
+	 *
+	 * @param string $expectedJson
+	 * @param string $actualJson
+	 * @param string $message
+	 */
+	public static function assertJsonStringNotEqualsJsonString($expectedJson, $actualJson, $message = '')
+	{
+		static::assertJson($expectedJson, $message);
+		static::assertJson($actualJson, $message);
+
+		$constraint = new JsonMatches(
+			$expectedJson
+		);
+
+		static::assertThat($actualJson, new LogicalNot($constraint), $message);
+	}
+
+	/**
+	 * Asserts that the generated JSON encoded object and the content of the given file are equal.
+	 *
+	 * @param string $expectedFile
+	 * @param string $actualJson
+	 * @param string $message
+	 */
+	public static function assertJsonStringEqualsJsonFile($expectedFile, $actualJson, $message = '')
+	{
+		static::assertFileExists($expectedFile, $message);
+		$expectedJson = \file_get_contents($expectedFile);
+
+		static::assertJson($expectedJson, $message);
+		static::assertJson($actualJson, $message);
+
+		$constraint = new JsonMatches(
+			$expectedJson
+		);
+
+		static::assertThat($actualJson, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that the generated JSON encoded object and the content of the given file are not equal.
+	 *
+	 * @param string $expectedFile
+	 * @param string $actualJson
+	 * @param string $message
+	 */
+	public static function assertJsonStringNotEqualsJsonFile($expectedFile, $actualJson, $message = '')
+	{
+		static::assertFileExists($expectedFile, $message);
+		$expectedJson = \file_get_contents($expectedFile);
+
+		static::assertJson($expectedJson, $message);
+		static::assertJson($actualJson, $message);
+
+		$constraint = new JsonMatches(
+			$expectedJson
+		);
+
+		static::assertThat($actualJson, new LogicalNot($constraint), $message);
+	}
+
+	/**
+	 * Asserts that two JSON files are equal.
+	 *
+	 * @param string $expectedFile
+	 * @param string $actualFile
+	 * @param string $message
+	 */
+	public static function assertJsonFileEqualsJsonFile($expectedFile, $actualFile, $message = '')
+	{
+		static::assertFileExists($expectedFile, $message);
+		static::assertFileExists($actualFile, $message);
+
+		$actualJson   = \file_get_contents($actualFile);
+		$expectedJson = \file_get_contents($expectedFile);
+
+		static::assertJson($expectedJson, $message);
+		static::assertJson($actualJson, $message);
+
+		$constraintExpected = new JsonMatches(
+			$expectedJson
+		);
+
+		$constraintActual = new JsonMatches($actualJson);
+
+		static::assertThat($expectedJson, $constraintActual, $message);
+		static::assertThat($actualJson, $constraintExpected, $message);
+	}
+
+	/**
+	 * Asserts that two JSON files are not equal.
+	 *
+	 * @param string $expectedFile
+	 * @param string $actualFile
+	 * @param string $message
+	 */
+	public static function assertJsonFileNotEqualsJsonFile($expectedFile, $actualFile, $message = '')
+	{
+		static::assertFileExists($expectedFile, $message);
+		static::assertFileExists($actualFile, $message);
+
+		$actualJson   = \file_get_contents($actualFile);
+		$expectedJson = \file_get_contents($expectedFile);
+
+		static::assertJson($expectedJson, $message);
+		static::assertJson($actualJson, $message);
+
+		$constraintExpected = new JsonMatches(
+			$expectedJson
+		);
+
+		$constraintActual = new JsonMatches($actualJson);
+
+		static::assertThat($expectedJson, new LogicalNot($constraintActual), $message);
+		static::assertThat($actualJson, new LogicalNot($constraintExpected), $message);
+	}
+
+	/**
+	 * @return LogicalAnd
+	 */
+	public static function logicalAnd()
+	{
+		$constraints = \func_get_args();
+
+		$constraint = new LogicalAnd;
+		$constraint->setConstraints($constraints);
+
+		return $constraint;
+	}
+
+	/**
+	 * @return LogicalOr
+	 */
+	public static function logicalOr()
+	{
+		$constraints = \func_get_args();
+
+		$constraint = new LogicalOr;
+		$constraint->setConstraints($constraints);
+
+		return $constraint;
+	}
+
+	/**
+	 * @param Constraint $constraint
+	 *
+	 * @return LogicalNot
+	 */
+	public static function logicalNot(Constraint $constraint)
+	{
+		return new LogicalNot($constraint);
+	}
+
+	/**
+	 * @return LogicalXor
+	 */
+	public static function logicalXor()
+	{
+		$constraints = \func_get_args();
+
+		$constraint = new LogicalXor;
+		$constraint->setConstraints($constraints);
+
+		return $constraint;
+	}
+
+	/**
+	 * @return IsAnything
+	 */
+	public static function anything()
+	{
+		return new IsAnything;
+	}
+
+	/**
+	 * @return IsTrue
+	 */
+	public static function isTrue()
+	{
+		return new IsTrue;
+	}
+
+	/**
+	 * @param callable $callback
+	 *
+	 * @return Callback
+	 */
+	public static function callback($callback)
+	{
+		return new Callback($callback);
+	}
+
+	/**
+	 * @return IsFalse
+	 */
+	public static function isFalse()
+	{
+		return new IsFalse;
+	}
+
+	/**
+	 * @return IsJson
+	 */
+	public static function isJson()
+	{
+		return new IsJson;
+	}
+
+	/**
+	 * @return IsNull
+	 */
+	public static function isNull()
+	{
+		return new IsNull;
+	}
+
+	/**
+	 * @return IsFinite
+	 */
+	public static function isFinite()
+	{
+		return new IsFinite;
+	}
+
+	/**
+	 * @return IsInfinite
+	 */
+	public static function isInfinite()
+	{
+		return new IsInfinite;
+	}
+
+	/**
+	 * @return IsNan
+	 */
+	public static function isNan()
+	{
+		return new IsNan;
+	}
+
+	/**
+	 * @param Constraint $constraint
+	 * @param string     $attributeName
+	 *
+	 * @return Attribute
+	 */
+	public static function attribute(Constraint $constraint, $attributeName)
+	{
+		return new Attribute(
+			$constraint,
+			$attributeName
+		);
+	}
+
+	/**
+	 * @param mixed $value
+	 * @param bool  $checkForObjectIdentity
+	 * @param bool  $checkForNonObjectIdentity
+	 *
+	 * @return TraversableContains
+	 */
+	public static function contains($value, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
+	{
+		return new TraversableContains($value, $checkForObjectIdentity, $checkForNonObjectIdentity);
+	}
+
+	/**
+	 * @param string $type
+	 *
+	 * @return TraversableContainsOnly
+	 */
+	public static function containsOnly($type)
+	{
+		return new TraversableContainsOnly($type);
+	}
+
+	/**
+	 * @param string $classname
+	 *
+	 * @return TraversableContainsOnly
+	 */
+	public static function containsOnlyInstancesOf($classname)
+	{
+		return new TraversableContainsOnly($classname, false);
+	}
+
+	/**
+	 * @param mixed $key
+	 *
+	 * @return ArrayHasKey
+	 */
+	public static function arrayHasKey($key)
+	{
+		return new ArrayHasKey($key);
+	}
+
+	/**
+	 * @param mixed $value
+	 * @param float $delta
+	 * @param int   $maxDepth
+	 * @param bool  $canonicalize
+	 * @param bool  $ignoreCase
+	 *
+	 * @return IsEqual
+	 */
+	public static function equalTo($value, $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
+	{
+		return new IsEqual(
+			$value,
+			$delta,
+			$maxDepth,
+			$canonicalize,
+			$ignoreCase
+		);
+	}
+
+	/**
+	 * @param string $attributeName
+	 * @param mixed  $value
+	 * @param float  $delta
+	 * @param int    $maxDepth
+	 * @param bool   $canonicalize
+	 * @param bool   $ignoreCase
+	 *
+	 * @return Attribute
+	 */
+	public static function attributeEqualTo($attributeName, $value, $delta = 0.0, $maxDepth = 10, $canonicalize = false, $ignoreCase = false)
+	{
+		return static::attribute(
+			static::equalTo(
+				$value,
+				$delta,
+				$maxDepth,
+				$canonicalize,
+				$ignoreCase
+			),
+			$attributeName
+		);
+	}
+
+	/**
+	 * @return IsEmpty
+	 */
+	public static function isEmpty()
+	{
+		return new IsEmpty;
+	}
+
+	/**
+	 * @return IsWritable
+	 */
+	public static function isWritable()
+	{
+		return new IsWritable;
+	}
+
+	/**
+	 * @return IsReadable
+	 */
+	public static function isReadable()
+	{
+		return new IsReadable;
+	}
+
+	/**
+	 * @return DirectoryExists
+	 */
+	public static function directoryExists()
+	{
+		return new DirectoryExists;
+	}
+
+	/**
+	 * @return FileExists
+	 */
+	public static function fileExists()
+	{
+		return new FileExists;
+	}
+
+	/**
+	 * @param mixed $value
+	 *
+	 * @return GreaterThan
+	 */
+	public static function greaterThan($value)
+	{
+		return new GreaterThan($value);
+	}
+
+	/**
+	 * @param mixed $value
+	 *
+	 * @return LogicalOr
+	 */
+	public static function greaterThanOrEqual($value)
+	{
+		return static::logicalOr(
+			new IsEqual($value),
+			new GreaterThan($value)
+		);
+	}
+
+	/**
+	 * @param string $attributeName
+	 *
+	 * @return ClassHasAttribute
+	 */
+	public static function classHasAttribute($attributeName)
+	{
+		return new ClassHasAttribute(
+			$attributeName
+		);
+	}
+
+	/**
+	 * @param string $attributeName
+	 *
+	 * @return ClassHasStaticAttribute
+	 */
+	public static function classHasStaticAttribute($attributeName)
+	{
+		return new ClassHasStaticAttribute(
+			$attributeName
+		);
+	}
+
+	/**
+	 * @param string $attributeName
+	 *
+	 * @return ObjectHasAttribute
+	 */
+	public static function objectHasAttribute($attributeName)
+	{
+		return new ObjectHasAttribute(
+			$attributeName
+		);
+	}
+
+	/**
+	 * @param mixed $value
+	 *
+	 * @return IsIdentical
+	 */
+	public static function identicalTo($value)
+	{
+		return new IsIdentical($value);
+	}
+
+	/**
+	 * @param string $className
+	 *
+	 * @return IsInstanceOf
+	 */
+	public static function isInstanceOf($className)
+	{
+		return new IsInstanceOf($className);
+	}
+
+	/**
+	 * @param string $type
+	 *
+	 * @return IsType
+	 */
+	public static function isType($type)
+	{
+		return new IsType($type);
+	}
+
+	/**
+	 * @param mixed $value
+	 *
+	 * @return LessThan
+	 */
+	public static function lessThan($value)
+	{
+		return new LessThan($value);
+	}
+
+	/**
+	 * @param mixed $value
+	 *
+	 * @return LogicalOr
+	 */
+	public static function lessThanOrEqual($value)
+	{
+		return static::logicalOr(
+			new IsEqual($value),
+			new LessThan($value)
+		);
+	}
+
+	/**
+	 * @param string $pattern
+	 *
+	 * @return RegularExpression
+	 */
+	public static function matchesRegularExpression($pattern)
+	{
+		return new RegularExpression($pattern);
+	}
+
+	/**
+	 * @param string $string
+	 *
+	 * @return StringMatchesFormatDescription
+	 */
+	public static function matches($string)
+	{
+		return new StringMatchesFormatDescription($string);
+	}
+
+	/**
+	 * @param mixed $prefix
+	 *
+	 * @return StringStartsWith
+	 */
+	public static function stringStartsWith($prefix)
+	{
+		return new StringStartsWith($prefix);
+	}
+
+	/**
+	 * @param string $string
+	 * @param bool   $case
+	 *
+	 * @return StringContains
+	 */
+	public static function stringContains($string, $case = true)
+	{
+		return new StringContains($string, $case);
+	}
+
+	/**
+	 * @param mixed $suffix
+	 *
+	 * @return StringEndsWith
+	 */
+	public static function stringEndsWith($suffix)
+	{
+		return new StringEndsWith($suffix);
+	}
+
+	/**
+	 * @param int $count
+	 *
+	 * @return Count
+	 */
+	public static function countOf($count)
+	{
+		return new Count($count);
+	}
+
+	/**
+	 * Fails a test with the given message.
+	 *
+	 * @param string $message
+	 *
+	 * @throws AssertionFailedError
+	 */
+	public static function fail($message = '')
+	{
+		self::$count++;
+
+		throw new AssertionFailedError($message);
+	}
+
+	/**
+	 * Returns the value of an attribute of a class or an object.
+	 * This also works for attributes that are declared protected or private.
+	 *
+	 * @param string|object $classOrObject
+	 * @param string        $attributeName
+	 *
+	 * @return mixed
+	 *
+	 * @throws Exception
+	 */
+	public static function readAttribute($classOrObject, $attributeName)
+	{
+		if (!\is_string($attributeName)) {
+			throw InvalidArgumentHelper::factory(2, 'string');
+		}
+
+		if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
+			throw InvalidArgumentHelper::factory(2, 'valid attribute name');
+		}
+
+		if (\is_string($classOrObject)) {
+			if (!\class_exists($classOrObject)) {
+				throw InvalidArgumentHelper::factory(
+					1,
+					'class name'
+				);
+			}
+
+			return static::getStaticAttribute(
+				$classOrObject,
+				$attributeName
+			);
+		}
+
+		if (\is_object($classOrObject)) {
+			return static::getObjectAttribute(
+				$classOrObject,
+				$attributeName
+			);
+		}
+
+		throw InvalidArgumentHelper::factory(
+			1,
+			'class name or object'
+		);
+	}
+
+	/**
+	 * Returns the value of a static attribute.
+	 * This also works for attributes that are declared protected or private.
+	 *
+	 * @param string $className
+	 * @param string $attributeName
+	 *
+	 * @return mixed
+	 *
+	 * @throws Exception
+	 */
+	public static function getStaticAttribute($className, $attributeName)
+	{
+		if (!\is_string($className)) {
+			throw InvalidArgumentHelper::factory(1, 'string');
+		}
+
+		if (!\class_exists($className)) {
+			throw InvalidArgumentHelper::factory(1, 'class name');
+		}
+
+		if (!\is_string($attributeName)) {
+			throw InvalidArgumentHelper::factory(2, 'string');
+		}
+
+		if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
+			throw InvalidArgumentHelper::factory(2, 'valid attribute name');
+		}
+
+		$class = new ReflectionClass($className);
+
+		while ($class) {
+			$attributes = $class->getStaticProperties();
+
+			if (\array_key_exists($attributeName, $attributes)) {
+				return $attributes[$attributeName];
+			}
+
+			$class = $class->getParentClass();
+		}
+
+		throw new Exception(
+			\sprintf(
+				'Attribute "%s" not found in class.',
+				$attributeName
+			)
+		);
+	}
+
+	/**
+	 * Returns the value of an object's attribute.
+	 * This also works for attributes that are declared protected or private.
+	 *
+	 * @param object $object
+	 * @param string $attributeName
+	 *
+	 * @return mixed
+	 *
+	 * @throws Exception
+	 */
+	public static function getObjectAttribute($object, $attributeName)
+	{
+		if (!\is_object($object)) {
+			throw InvalidArgumentHelper::factory(1, 'object');
+		}
+
+		if (!\is_string($attributeName)) {
+			throw InvalidArgumentHelper::factory(2, 'string');
+		}
+
+		if (!\preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName)) {
+			throw InvalidArgumentHelper::factory(2, 'valid attribute name');
+		}
+
+		try {
+			$attribute = new ReflectionProperty($object, $attributeName);
+		} catch (ReflectionException $e) {
+			$reflector = new ReflectionObject($object);
+
+			while ($reflector = $reflector->getParentClass()) {
+				try {
+					$attribute = $reflector->getProperty($attributeName);
+
+					break;
+				} catch (ReflectionException $e) {
+				}
+			}
+		}
+
+		if (isset($attribute)) {
+			if (!$attribute || $attribute->isPublic()) {
+				return $object->$attributeName;
+			}
+
+			$attribute->setAccessible(true);
+			$value = $attribute->getValue($object);
+			$attribute->setAccessible(false);
+
+			return $value;
+		}
+
+		throw new Exception(
+			\sprintf(
+				'Attribute "%s" not found in object.',
+				$attributeName
+			)
+		);
+	}
+
+	/**
+	 * Mark the test as incomplete.
+	 *
+	 * @param string $message
+	 *
+	 * @throws IncompleteTestError
+	 */
+	public static function markTestIncomplete($message = '')
+	{
+		throw new IncompleteTestError($message);
+	}
+
+	/**
+	 * Mark the test as skipped.
+	 *
+	 * @param string $message
+	 *
+	 * @throws SkippedTestError
+	 */
+	public static function markTestSkipped($message = '')
+	{
+		throw new SkippedTestError($message);
+	}
+
+	/**
+	 * Return the current assertion count.
+	 *
+	 * @return int
+	 */
+	public static function getCount()
+	{
+		return self::$count;
+	}
+
+	/**
+	 * Reset the assertion counter.
+	 */
+	public static function resetCount()
+	{
+		self::$count = 0;
+	}
 }

vendor/phpunit/phpunit/src/Framework/TestResult.php

Indentation +1273 added lines, -1273 removed lines

@@ -34,1277 +34,1277 @@
  */
 class TestResult implements Countable
 {
-    /**
-     * @var array
-     */
-    protected $passed = [];
-
-    /**
-     * @var array
-     */
-    protected $errors = [];
-
-    /**
-     * @var array
-     */
-    protected $failures = [];
-
-    /**
-     * @var array
-     */
-    protected $warnings = [];
-
-    /**
-     * @var array
-     */
-    protected $notImplemented = [];
-
-    /**
-     * @var array
-     */
-    protected $risky = [];
-
-    /**
-     * @var array
-     */
-    protected $skipped = [];
-
-    /**
-     * @var array
-     */
-    protected $listeners = [];
-
-    /**
-     * @var int
-     */
-    protected $runTests = 0;
-
-    /**
-     * @var float
-     */
-    protected $time = 0;
-
-    /**
-     * @var TestSuite
-     */
-    protected $topTestSuite;
-
-    /**
-     * Code Coverage information.
-     *
-     * @var CodeCoverage
-     */
-    protected $codeCoverage;
-
-    /**
-     * @var bool
-     */
-    protected $convertErrorsToExceptions = true;
-
-    /**
-     * @var bool
-     */
-    protected $stop = false;
-
-    /**
-     * @var bool
-     */
-    protected $stopOnError = false;
-
-    /**
-     * @var bool
-     */
-    protected $stopOnFailure = false;
-
-    /**
-     * @var bool
-     */
-    protected $stopOnWarning = false;
-
-    /**
-     * @var bool
-     */
-    protected $beStrictAboutTestsThatDoNotTestAnything = true;
-
-    /**
-     * @var bool
-     */
-    protected $beStrictAboutOutputDuringTests = false;
-
-    /**
-     * @var bool
-     */
-    protected $beStrictAboutTodoAnnotatedTests = false;
-
-    /**
-     * @var bool
-     */
-    protected $beStrictAboutResourceUsageDuringSmallTests = false;
-
-    /**
-     * @var bool
-     */
-    protected $enforceTimeLimit = false;
-
-    /**
-     * @var int
-     */
-    protected $timeoutForSmallTests = 1;
-
-    /**
-     * @var int
-     */
-    protected $timeoutForMediumTests = 10;
-
-    /**
-     * @var int
-     */
-    protected $timeoutForLargeTests = 60;
-
-    /**
-     * @var bool
-     */
-    protected $stopOnRisky = false;
-
-    /**
-     * @var bool
-     */
-    protected $stopOnIncomplete = false;
-
-    /**
-     * @var bool
-     */
-    protected $stopOnSkipped = false;
-
-    /**
-     * @var bool
-     */
-    protected $lastTestFailed = false;
-
-    /**
-     * @var bool
-     */
-    private $registerMockObjectsFromTestArgumentsRecursively = false;
-
-    /**
-     * Registers a TestListener.
-     *
-     * @param TestListener $listener
-     */
-    public function addListener(TestListener $listener)
-    {
-        $this->listeners[] = $listener;
-    }
-
-    /**
-     * Unregisters a TestListener.
-     *
-     * @param TestListener $listener
-     */
-    public function removeListener(TestListener $listener)
-    {
-        foreach ($this->listeners as $key => $_listener) {
-            if ($listener === $_listener) {
-                unset($this->listeners[$key]);
-            }
-        }
-    }
-
-    /**
-     * Flushes all flushable TestListeners.
-     */
-    public function flushListeners()
-    {
-        foreach ($this->listeners as $listener) {
-            if ($listener instanceof Printer) {
-                $listener->flush();
-            }
-        }
-    }
-
-    /**
-     * Adds an error to the list of errors.
-     *
-     * @param Test      $test
-     * @param Throwable $t
-     * @param float     $time
-     */
-    public function addError(Test $test, Throwable $t, $time)
-    {
-        if ($t instanceof RiskyTest) {
-            $this->risky[] = new TestFailure($test, $t);
-            $notifyMethod  = 'addRiskyTest';
-
-            if ($test instanceof TestCase) {
-                $test->markAsRisky();
-            }
-
-            if ($this->stopOnRisky) {
-                $this->stop();
-            }
-        } elseif ($t instanceof IncompleteTest) {
-            $this->notImplemented[] = new TestFailure($test, $t);
-            $notifyMethod           = 'addIncompleteTest';
-
-            if ($this->stopOnIncomplete) {
-                $this->stop();
-            }
-        } elseif ($t instanceof SkippedTest) {
-            $this->skipped[] = new TestFailure($test, $t);
-            $notifyMethod    = 'addSkippedTest';
-
-            if ($this->stopOnSkipped) {
-                $this->stop();
-            }
-        } else {
-            $this->errors[] = new TestFailure($test, $t);
-            $notifyMethod   = 'addError';
-
-            if ($this->stopOnError || $this->stopOnFailure) {
-                $this->stop();
-            }
-        }
-
-        // @see https://github.com/sebastianbergmann/phpunit/issues/1953
-        if ($t instanceof Error) {
-            $t = new ExceptionWrapper($t);
-        }
-
-        foreach ($this->listeners as $listener) {
-            $listener->$notifyMethod($test, $t, $time);
-        }
-
-        $this->lastTestFailed = true;
-        $this->time += $time;
-    }
-
-    /**
-     * Adds a warning to the list of warnings.
-     * The passed in exception caused the warning.
-     *
-     * @param Test    $test
-     * @param Warning $e
-     * @param float   $time
-     */
-    public function addWarning(Test $test, Warning $e, $time)
-    {
-        if ($this->stopOnWarning) {
-            $this->stop();
-        }
-
-        $this->warnings[] = new TestFailure($test, $e);
-
-        foreach ($this->listeners as $listener) {
-            $listener->addWarning($test, $e, $time);
-        }
-
-        $this->time += $time;
-    }
-
-    /**
-     * Adds a failure to the list of failures.
-     * The passed in exception caused the failure.
-     *
-     * @param Test                 $test
-     * @param AssertionFailedError $e
-     * @param float                $time
-     */
-    public function addFailure(Test $test, AssertionFailedError $e, $time)
-    {
-        if ($e instanceof RiskyTest || $e instanceof OutputError) {
-            $this->risky[] = new TestFailure($test, $e);
-            $notifyMethod  = 'addRiskyTest';
-
-            if ($test instanceof TestCase) {
-                $test->markAsRisky();
-            }
-
-            if ($this->stopOnRisky) {
-                $this->stop();
-            }
-        } elseif ($e instanceof IncompleteTest) {
-            $this->notImplemented[] = new TestFailure($test, $e);
-            $notifyMethod           = 'addIncompleteTest';
-
-            if ($this->stopOnIncomplete) {
-                $this->stop();
-            }
-        } elseif ($e instanceof SkippedTest) {
-            $this->skipped[] = new TestFailure($test, $e);
-            $notifyMethod    = 'addSkippedTest';
-
-            if ($this->stopOnSkipped) {
-                $this->stop();
-            }
-        } else {
-            $this->failures[] = new TestFailure($test, $e);
-            $notifyMethod     = 'addFailure';
-
-            if ($this->stopOnFailure) {
-                $this->stop();
-            }
-        }
-
-        foreach ($this->listeners as $listener) {
-            $listener->$notifyMethod($test, $e, $time);
-        }
-
-        $this->lastTestFailed = true;
-        $this->time += $time;
-    }
-
-    /**
-     * Informs the result that a testsuite will be started.
-     *
-     * @param TestSuite $suite
-     */
-    public function startTestSuite(TestSuite $suite)
-    {
-        if ($this->topTestSuite === null) {
-            $this->topTestSuite = $suite;
-        }
-
-        foreach ($this->listeners as $listener) {
-            $listener->startTestSuite($suite);
-        }
-    }
-
-    /**
-     * Informs the result that a testsuite was completed.
-     *
-     * @param TestSuite $suite
-     */
-    public function endTestSuite(TestSuite $suite)
-    {
-        foreach ($this->listeners as $listener) {
-            $listener->endTestSuite($suite);
-        }
-    }
-
-    /**
-     * Informs the result that a test will be started.
-     *
-     * @param Test $test
-     */
-    public function startTest(Test $test)
-    {
-        $this->lastTestFailed = false;
-        $this->runTests += \count($test);
-
-        foreach ($this->listeners as $listener) {
-            $listener->startTest($test);
-        }
-    }
-
-    /**
-     * Informs the result that a test was completed.
-     *
-     * @param Test  $test
-     * @param float $time
-     */
-    public function endTest(Test $test, $time)
-    {
-        foreach ($this->listeners as $listener) {
-            $listener->endTest($test, $time);
-        }
-
-        if (!$this->lastTestFailed && $test instanceof TestCase) {
-            $class = \get_class($test);
-            $key   = $class . '::' . $test->getName();
-
-            $this->passed[$key] = [
-                'result' => $test->getResult(),
-                'size'   => \PHPUnit\Util\Test::getSize(
-                    $class,
-                    $test->getName(false)
-                )
-            ];
-
-            $this->time += $time;
-        }
-    }
-
-    /**
-     * Returns true if no risky test occurred.
-     *
-     * @return bool
-     */
-    public function allHarmless()
-    {
-        return $this->riskyCount() == 0;
-    }
-
-    /**
-     * Gets the number of risky tests.
-     *
-     * @return int
-     */
-    public function riskyCount()
-    {
-        return \count($this->risky);
-    }
-
-    /**
-     * Returns true if no incomplete test occurred.
-     *
-     * @return bool
-     */
-    public function allCompletelyImplemented()
-    {
-        return $this->notImplementedCount() == 0;
-    }
-
-    /**
-     * Gets the number of incomplete tests.
-     *
-     * @return int
-     */
-    public function notImplementedCount()
-    {
-        return \count($this->notImplemented);
-    }
-
-    /**
-     * Returns an Enumeration for the risky tests.
-     *
-     * @return array
-     */
-    public function risky()
-    {
-        return $this->risky;
-    }
-
-    /**
-     * Returns an Enumeration for the incomplete tests.
-     *
-     * @return array
-     */
-    public function notImplemented()
-    {
-        return $this->notImplemented;
-    }
-
-    /**
-     * Returns true if no test has been skipped.
-     *
-     * @return bool
-     */
-    public function noneSkipped()
-    {
-        return $this->skippedCount() == 0;
-    }
-
-    /**
-     * Gets the number of skipped tests.
-     *
-     * @return int
-     */
-    public function skippedCount()
-    {
-        return \count($this->skipped);
-    }
-
-    /**
-     * Returns an Enumeration for the skipped tests.
-     *
-     * @return array
-     */
-    public function skipped()
-    {
-        return $this->skipped;
-    }
-
-    /**
-     * Gets the number of detected errors.
-     *
-     * @return int
-     */
-    public function errorCount()
-    {
-        return \count($this->errors);
-    }
-
-    /**
-     * Returns an Enumeration for the errors.
-     *
-     * @return array
-     */
-    public function errors()
-    {
-        return $this->errors;
-    }
-
-    /**
-     * Gets the number of detected failures.
-     *
-     * @return int
-     */
-    public function failureCount()
-    {
-        return \count($this->failures);
-    }
-
-    /**
-     * Returns an Enumeration for the failures.
-     *
-     * @return array
-     */
-    public function failures()
-    {
-        return $this->failures;
-    }
-
-    /**
-     * Gets the number of detected warnings.
-     *
-     * @return int
-     */
-    public function warningCount()
-    {
-        return \count($this->warnings);
-    }
-
-    /**
-     * Returns an Enumeration for the warnings.
-     *
-     * @return array
-     */
-    public function warnings()
-    {
-        return $this->warnings;
-    }
-
-    /**
-     * Returns the names of the tests that have passed.
-     *
-     * @return array
-     */
-    public function passed()
-    {
-        return $this->passed;
-    }
-
-    /**
-     * Returns the (top) test suite.
-     *
-     * @return TestSuite
-     */
-    public function topTestSuite()
-    {
-        return $this->topTestSuite;
-    }
-
-    /**
-     * Returns whether code coverage information should be collected.
-     *
-     * @return bool If code coverage should be collected
-     */
-    public function getCollectCodeCoverageInformation()
-    {
-        return $this->codeCoverage !== null;
-    }
-
-    /**
-     * Runs a TestCase.
-     *
-     * @param Test $test
-     */
-    public function run(Test $test)
-    {
-        Assert::resetCount();
-
-        $coversNothing = false;
-
-        if ($test instanceof TestCase) {
-            $test->setRegisterMockObjectsFromTestArgumentsRecursively(
-                $this->registerMockObjectsFromTestArgumentsRecursively
-            );
-
-            $annotations = $test->getAnnotations();
-
-            if (isset($annotations['class']['coversNothing']) || isset($annotations['method']['coversNothing'])) {
-                $coversNothing = true;
-            }
-        }
-
-        $error      = false;
-        $failure    = false;
-        $warning    = false;
-        $incomplete = false;
-        $risky      = false;
-        $skipped    = false;
-
-        $this->startTest($test);
-
-        $errorHandlerSet = false;
-
-        if ($this->convertErrorsToExceptions) {
-            $oldErrorHandler = \set_error_handler(
-                [\PHPUnit\Util\ErrorHandler::class, 'handleError'],
-                E_ALL | E_STRICT
-            );
-
-            if ($oldErrorHandler === null) {
-                $errorHandlerSet = true;
-            } else {
-                \restore_error_handler();
-            }
-        }
-
-        $collectCodeCoverage = $this->codeCoverage !== null &&
-                               !$test instanceof WarningTestCase &&
-                               !$coversNothing;
-
-        if ($collectCodeCoverage) {
-            $this->codeCoverage->start($test);
-        }
-
-        $monitorFunctions = $this->beStrictAboutResourceUsageDuringSmallTests &&
-            !$test instanceof WarningTestCase &&
-            $test->getSize() == \PHPUnit\Util\Test::SMALL &&
-            \function_exists('xdebug_start_function_monitor');
-
-        if ($monitorFunctions) {
-            \xdebug_start_function_monitor(ResourceOperations::getFunctions());
-        }
-
-        PHP_Timer::start();
-
-        try {
-            if (!$test instanceof WarningTestCase &&
-                $test->getSize() != \PHPUnit\Util\Test::UNKNOWN &&
-                $this->enforceTimeLimit &&
-                \extension_loaded('pcntl') && \class_exists('PHP_Invoker')) {
-                switch ($test->getSize()) {
-                    case \PHPUnit\Util\Test::SMALL:
-                        $_timeout = $this->timeoutForSmallTests;
-
-                        break;
-
-                    case \PHPUnit\Util\Test::MEDIUM:
-                        $_timeout = $this->timeoutForMediumTests;
-
-                        break;
-
-                    case \PHPUnit\Util\Test::LARGE:
-                        $_timeout = $this->timeoutForLargeTests;
-
-                        break;
-                }
-
-                $invoker = new PHP_Invoker;
-                $invoker->invoke([$test, 'runBare'], [], $_timeout);
-            } else {
-                $test->runBare();
-            }
-        } catch (PHP_Invoker_TimeoutException $e) {
-            $this->addFailure(
-                $test,
-                new RiskyTestError(
-                    $e->getMessage()
-                ),
-                $_timeout
-            );
-
-            $risky = true;
-        } catch (PHPUnit_Framework_MockObject_Exception $e) {
-            $e = new Warning(
-                $e->getMessage()
-            );
-
-            $warning = true;
-        } catch (AssertionFailedError $e) {
-            $failure = true;
-
-            if ($e instanceof RiskyTestError) {
-                $risky = true;
-            } elseif ($e instanceof IncompleteTestError) {
-                $incomplete = true;
-            } elseif ($e instanceof SkippedTestError) {
-                $skipped = true;
-            }
-        } catch (AssertionError $e) {
-            $test->addToAssertionCount(1);
-
-            $failure = true;
-            $frame   = $e->getTrace()[0];
-
-            $e = new AssertionFailedError(
-                \sprintf(
-                    '%s in %s:%s',
-                    $e->getMessage(),
-                    $frame['file'],
-                    $frame['line']
-                )
-            );
-        } catch (Warning $e) {
-            $warning = true;
-        } catch (Exception $e) {
-            $error = true;
-        } catch (Throwable $e) {
-            $e     = new ExceptionWrapper($e);
-            $error = true;
-        }
-
-        $time = PHP_Timer::stop();
-        $test->addToAssertionCount(Assert::getCount());
-
-        if ($monitorFunctions) {
-            $blacklist = new Blacklist;
-            $functions = \xdebug_get_monitored_functions();
-            \xdebug_stop_function_monitor();
-
-            foreach ($functions as $function) {
-                if (!$blacklist->isBlacklisted($function['filename'])) {
-                    $this->addFailure(
-                        $test,
-                        new RiskyTestError(
-                            \sprintf(
-                                '%s() used in %s:%s',
-                                $function['function'],
-                                $function['filename'],
-                                $function['lineno']
-                            )
-                        ),
-                        $time
-                    );
-                }
-            }
-        }
-
-        if ($this->beStrictAboutTestsThatDoNotTestAnything &&
-            $test->getNumAssertions() == 0) {
-            $risky = true;
-        }
-
-        if ($collectCodeCoverage) {
-            $append           = !$risky && !$incomplete && !$skipped;
-            $linesToBeCovered = [];
-            $linesToBeUsed    = [];
-
-            if ($append && $test instanceof TestCase) {
-                try {
-                    $linesToBeCovered = \PHPUnit\Util\Test::getLinesToBeCovered(
-                        \get_class($test),
-                        $test->getName(false)
-                    );
-
-                    $linesToBeUsed = \PHPUnit\Util\Test::getLinesToBeUsed(
-                        \get_class($test),
-                        $test->getName(false)
-                    );
-                } catch (InvalidCoversTargetException $cce) {
-                    $this->addWarning(
-                        $test,
-                        new Warning(
-                            $cce->getMessage()
-                        ),
-                        $time
-                    );
-                }
-            }
-
-            try {
-                $this->codeCoverage->stop(
-                    $append,
-                    $linesToBeCovered,
-                    $linesToBeUsed
-                );
-            } catch (UnintentionallyCoveredCodeException $cce) {
-                $this->addFailure(
-                    $test,
-                    new UnintentionallyCoveredCodeError(
-                        'This test executed code that is not listed as code to be covered or used:' .
-                        PHP_EOL . $cce->getMessage()
-                    ),
-                    $time
-                );
-            } catch (OriginalCoveredCodeNotExecutedException $cce) {
-                $this->addFailure(
-                    $test,
-                    new CoveredCodeNotExecutedException(
-                        'This test did not execute all the code that is listed as code to be covered:' .
-                        PHP_EOL . $cce->getMessage()
-                    ),
-                    $time
-                );
-            } catch (OriginalMissingCoversAnnotationException $cce) {
-                if ($linesToBeCovered !== false) {
-                    $this->addFailure(
-                        $test,
-                        new MissingCoversAnnotationException(
-                            'This test does not have a @covers annotation but is expected to have one'
-                        ),
-                        $time
-                    );
-                }
-            } catch (OriginalCodeCoverageException $cce) {
-                $error = true;
-
-                if (!isset($e)) {
-                    $e = $cce;
-                }
-            }
-        }
-
-        if ($errorHandlerSet === true) {
-            \restore_error_handler();
-        }
-
-        if ($error === true) {
-            $this->addError($test, $e, $time);
-        } elseif ($failure === true) {
-            $this->addFailure($test, $e, $time);
-        } elseif ($warning === true) {
-            $this->addWarning($test, $e, $time);
-        } elseif ($this->beStrictAboutTestsThatDoNotTestAnything &&
-            !$test->doesNotPerformAssertions() &&
-            $test->getNumAssertions() == 0) {
-            $this->addFailure(
-                $test,
-                new RiskyTestError(
-                    'This test did not perform any assertions'
-                ),
-                $time
-            );
-        } elseif ($this->beStrictAboutOutputDuringTests && $test->hasOutput()) {
-            $this->addFailure(
-                $test,
-                new OutputError(
-                    \sprintf(
-                        'This test printed output: %s',
-                        $test->getActualOutput()
-                    )
-                ),
-                $time
-            );
-        } elseif ($this->beStrictAboutTodoAnnotatedTests && $test instanceof TestCase) {
-            $annotations = $test->getAnnotations();
-
-            if (isset($annotations['method']['todo'])) {
-                $this->addFailure(
-                    $test,
-                    new RiskyTestError(
-                        'Test method is annotated with @todo'
-                    ),
-                    $time
-                );
-            }
-        }
-
-        $this->endTest($test, $time);
-    }
-
-    /**
-     * Gets the number of run tests.
-     *
-     * @return int
-     */
-    public function count()
-    {
-        return $this->runTests;
-    }
-
-    /**
-     * Checks whether the test run should stop.
-     *
-     * @return bool
-     */
-    public function shouldStop()
-    {
-        return $this->stop;
-    }
-
-    /**
-     * Marks that the test run should stop.
-     */
-    public function stop()
-    {
-        $this->stop = true;
-    }
-
-    /**
-     * Returns the code coverage object.
-     *
-     * @return CodeCoverage
-     */
-    public function getCodeCoverage()
-    {
-        return $this->codeCoverage;
-    }
-
-    /**
-     * Sets the code coverage object.
-     *
-     * @param CodeCoverage $codeCoverage
-     */
-    public function setCodeCoverage(CodeCoverage $codeCoverage)
-    {
-        $this->codeCoverage = $codeCoverage;
-    }
-
-    /**
-     * Enables or disables the error-to-exception conversion.
-     *
-     * @param bool $flag
-     *
-     * @throws Exception
-     */
-    public function convertErrorsToExceptions($flag)
-    {
-        if (!\is_bool($flag)) {
-            throw InvalidArgumentHelper::factory(1, 'boolean');
-        }
-
-        $this->convertErrorsToExceptions = $flag;
-    }
-
-    /**
-     * Returns the error-to-exception conversion setting.
-     *
-     * @return bool
-     */
-    public function getConvertErrorsToExceptions()
-    {
-        return $this->convertErrorsToExceptions;
-    }
-
-    /**
-     * Enables or disables the stopping when an error occurs.
-     *
-     * @param bool $flag
-     *
-     * @throws Exception
-     */
-    public function stopOnError($flag)
-    {
-        if (!\is_bool($flag)) {
-            throw InvalidArgumentHelper::factory(1, 'boolean');
-        }
-
-        $this->stopOnError = $flag;
-    }
-
-    /**
-     * Enables or disables the stopping when a failure occurs.
-     *
-     * @param bool $flag
-     *
-     * @throws Exception
-     */
-    public function stopOnFailure($flag)
-    {
-        if (!\is_bool($flag)) {
-            throw InvalidArgumentHelper::factory(1, 'boolean');
-        }
-
-        $this->stopOnFailure = $flag;
-    }
-
-    /**
-     * Enables or disables the stopping when a warning occurs.
-     *
-     * @param bool $flag
-     *
-     * @throws Exception
-     */
-    public function stopOnWarning($flag)
-    {
-        if (!\is_bool($flag)) {
-            throw InvalidArgumentHelper::factory(1, 'boolean');
-        }
-
-        $this->stopOnWarning = $flag;
-    }
-
-    /**
-     * @param bool $flag
-     *
-     * @throws Exception
-     */
-    public function beStrictAboutTestsThatDoNotTestAnything($flag)
-    {
-        if (!\is_bool($flag)) {
-            throw InvalidArgumentHelper::factory(1, 'boolean');
-        }
-
-        $this->beStrictAboutTestsThatDoNotTestAnything = $flag;
-    }
-
-    /**
-     * @return bool
-     */
-    public function isStrictAboutTestsThatDoNotTestAnything()
-    {
-        return $this->beStrictAboutTestsThatDoNotTestAnything;
-    }
-
-    /**
-     * @param bool $flag
-     *
-     * @throws Exception
-     */
-    public function beStrictAboutOutputDuringTests($flag)
-    {
-        if (!\is_bool($flag)) {
-            throw InvalidArgumentHelper::factory(1, 'boolean');
-        }
-
-        $this->beStrictAboutOutputDuringTests = $flag;
-    }
-
-    /**
-     * @return bool
-     */
-    public function isStrictAboutOutputDuringTests()
-    {
-        return $this->beStrictAboutOutputDuringTests;
-    }
-
-    /**
-     * @param bool $flag
-     *
-     * @throws Exception
-     */
-    public function beStrictAboutResourceUsageDuringSmallTests($flag)
-    {
-        if (!\is_bool($flag)) {
-            throw InvalidArgumentHelper::factory(1, 'boolean');
-        }
-
-        $this->beStrictAboutResourceUsageDuringSmallTests = $flag;
-    }
-
-    /**
-     * @return bool
-     */
-    public function isStrictAboutResourceUsageDuringSmallTests()
-    {
-        return $this->beStrictAboutResourceUsageDuringSmallTests;
-    }
-
-    /**
-     * @param bool $flag
-     *
-     * @throws Exception
-     */
-    public function enforceTimeLimit($flag)
-    {
-        if (!\is_bool($flag)) {
-            throw InvalidArgumentHelper::factory(1, 'boolean');
-        }
-
-        $this->enforceTimeLimit = $flag;
-    }
-
-    /**
-     * @return bool
-     */
-    public function enforcesTimeLimit()
-    {
-        return $this->enforceTimeLimit;
-    }
-
-    /**
-     * @param bool $flag
-     *
-     * @throws Exception
-     */
-    public function beStrictAboutTodoAnnotatedTests($flag)
-    {
-        if (!\is_bool($flag)) {
-            throw InvalidArgumentHelper::factory(1, 'boolean');
-        }
-
-        $this->beStrictAboutTodoAnnotatedTests = $flag;
-    }
-
-    /**
-     * @return bool
-     */
-    public function isStrictAboutTodoAnnotatedTests()
-    {
-        return $this->beStrictAboutTodoAnnotatedTests;
-    }
-
-    /**
-     * Enables or disables the stopping for risky tests.
-     *
-     * @param bool $flag
-     *
-     * @throws Exception
-     */
-    public function stopOnRisky($flag)
-    {
-        if (!\is_bool($flag)) {
-            throw InvalidArgumentHelper::factory(1, 'boolean');
-        }
-
-        $this->stopOnRisky = $flag;
-    }
-
-    /**
-     * Enables or disables the stopping for incomplete tests.
-     *
-     * @param bool $flag
-     *
-     * @throws Exception
-     */
-    public function stopOnIncomplete($flag)
-    {
-        if (!\is_bool($flag)) {
-            throw InvalidArgumentHelper::factory(1, 'boolean');
-        }
-
-        $this->stopOnIncomplete = $flag;
-    }
-
-    /**
-     * Enables or disables the stopping for skipped tests.
-     *
-     * @param bool $flag
-     *
-     * @throws Exception
-     */
-    public function stopOnSkipped($flag)
-    {
-        if (!\is_bool($flag)) {
-            throw InvalidArgumentHelper::factory(1, 'boolean');
-        }
-
-        $this->stopOnSkipped = $flag;
-    }
-
-    /**
-     * Returns the time spent running the tests.
-     *
-     * @return float
-     */
-    public function time()
-    {
-        return $this->time;
-    }
-
-    /**
-     * Returns whether the entire test was successful or not.
-     *
-     * @return bool
-     */
-    public function wasSuccessful()
-    {
-        return empty($this->errors) && empty($this->failures) && empty($this->warnings);
-    }
-
-    /**
-     * Sets the timeout for small tests.
-     *
-     * @param int $timeout
-     *
-     * @throws Exception
-     */
-    public function setTimeoutForSmallTests($timeout)
-    {
-        if (!\is_int($timeout)) {
-            throw InvalidArgumentHelper::factory(1, 'integer');
-        }
-
-        $this->timeoutForSmallTests = $timeout;
-    }
-
-    /**
-     * Sets the timeout for medium tests.
-     *
-     * @param int $timeout
-     *
-     * @throws Exception
-     */
-    public function setTimeoutForMediumTests($timeout)
-    {
-        if (!\is_int($timeout)) {
-            throw InvalidArgumentHelper::factory(1, 'integer');
-        }
-
-        $this->timeoutForMediumTests = $timeout;
-    }
-
-    /**
-     * Sets the timeout for large tests.
-     *
-     * @param int $timeout
-     *
-     * @throws Exception
-     */
-    public function setTimeoutForLargeTests($timeout)
-    {
-        if (!\is_int($timeout)) {
-            throw InvalidArgumentHelper::factory(1, 'integer');
-        }
-
-        $this->timeoutForLargeTests = $timeout;
-    }
-
-    /**
-     * Returns the set timeout for large tests.
-     *
-     * @return int
-     */
-    public function getTimeoutForLargeTests()
-    {
-        return $this->timeoutForLargeTests;
-    }
-
-    /**
-     * @param bool $flag
-     */
-    public function setRegisterMockObjectsFromTestArgumentsRecursively($flag)
-    {
-        if (!\is_bool($flag)) {
-            throw InvalidArgumentHelper::factory(1, 'boolean');
-        }
-
-        $this->registerMockObjectsFromTestArgumentsRecursively = $flag;
-    }
-
-    /**
-     * Returns the class hierarchy for a given class.
-     *
-     * @param string $className
-     * @param bool   $asReflectionObjects
-     *
-     * @return array
-     */
-    protected function getHierarchy($className, $asReflectionObjects = false)
-    {
-        if ($asReflectionObjects) {
-            $classes = [new ReflectionClass($className)];
-        } else {
-            $classes = [$className];
-        }
-
-        $done = false;
-
-        while (!$done) {
-            if ($asReflectionObjects) {
-                $class = new ReflectionClass(
-                    $classes[\count($classes) - 1]->getName()
-                );
-            } else {
-                $class = new ReflectionClass($classes[\count($classes) - 1]);
-            }
-
-            $parent = $class->getParentClass();
-
-            if ($parent !== false) {
-                if ($asReflectionObjects) {
-                    $classes[] = $parent;
-                } else {
-                    $classes[] = $parent->getName();
-                }
-            } else {
-                $done = true;
-            }
-        }
-
-        return $classes;
-    }
+	/**
+	 * @var array
+	 */
+	protected $passed = [];
+
+	/**
+	 * @var array
+	 */
+	protected $errors = [];
+
+	/**
+	 * @var array
+	 */
+	protected $failures = [];
+
+	/**
+	 * @var array
+	 */
+	protected $warnings = [];
+
+	/**
+	 * @var array
+	 */
+	protected $notImplemented = [];
+
+	/**
+	 * @var array
+	 */
+	protected $risky = [];
+
+	/**
+	 * @var array
+	 */
+	protected $skipped = [];
+
+	/**
+	 * @var array
+	 */
+	protected $listeners = [];
+
+	/**
+	 * @var int
+	 */
+	protected $runTests = 0;
+
+	/**
+	 * @var float
+	 */
+	protected $time = 0;
+
+	/**
+	 * @var TestSuite
+	 */
+	protected $topTestSuite;
+
+	/**
+	 * Code Coverage information.
+	 *
+	 * @var CodeCoverage
+	 */
+	protected $codeCoverage;
+
+	/**
+	 * @var bool
+	 */
+	protected $convertErrorsToExceptions = true;
+
+	/**
+	 * @var bool
+	 */
+	protected $stop = false;
+
+	/**
+	 * @var bool
+	 */
+	protected $stopOnError = false;
+
+	/**
+	 * @var bool
+	 */
+	protected $stopOnFailure = false;
+
+	/**
+	 * @var bool
+	 */
+	protected $stopOnWarning = false;
+
+	/**
+	 * @var bool
+	 */
+	protected $beStrictAboutTestsThatDoNotTestAnything = true;
+
+	/**
+	 * @var bool
+	 */
+	protected $beStrictAboutOutputDuringTests = false;
+
+	/**
+	 * @var bool
+	 */
+	protected $beStrictAboutTodoAnnotatedTests = false;
+
+	/**
+	 * @var bool
+	 */
+	protected $beStrictAboutResourceUsageDuringSmallTests = false;
+
+	/**
+	 * @var bool
+	 */
+	protected $enforceTimeLimit = false;
+
+	/**
+	 * @var int
+	 */
+	protected $timeoutForSmallTests = 1;
+
+	/**
+	 * @var int
+	 */
+	protected $timeoutForMediumTests = 10;
+
+	/**
+	 * @var int
+	 */
+	protected $timeoutForLargeTests = 60;
+
+	/**
+	 * @var bool
+	 */
+	protected $stopOnRisky = false;
+
+	/**
+	 * @var bool
+	 */
+	protected $stopOnIncomplete = false;
+
+	/**
+	 * @var bool
+	 */
+	protected $stopOnSkipped = false;
+
+	/**
+	 * @var bool
+	 */
+	protected $lastTestFailed = false;
+
+	/**
+	 * @var bool
+	 */
+	private $registerMockObjectsFromTestArgumentsRecursively = false;
+
+	/**
+	 * Registers a TestListener.
+	 *
+	 * @param TestListener $listener
+	 */
+	public function addListener(TestListener $listener)
+	{
+		$this->listeners[] = $listener;
+	}
+
+	/**
+	 * Unregisters a TestListener.
+	 *
+	 * @param TestListener $listener
+	 */
+	public function removeListener(TestListener $listener)
+	{
+		foreach ($this->listeners as $key => $_listener) {
+			if ($listener === $_listener) {
+				unset($this->listeners[$key]);
+			}
+		}
+	}
+
+	/**
+	 * Flushes all flushable TestListeners.
+	 */
+	public function flushListeners()
+	{
+		foreach ($this->listeners as $listener) {
+			if ($listener instanceof Printer) {
+				$listener->flush();
+			}
+		}
+	}
+
+	/**
+	 * Adds an error to the list of errors.
+	 *
+	 * @param Test      $test
+	 * @param Throwable $t
+	 * @param float     $time
+	 */
+	public function addError(Test $test, Throwable $t, $time)
+	{
+		if ($t instanceof RiskyTest) {
+			$this->risky[] = new TestFailure($test, $t);
+			$notifyMethod  = 'addRiskyTest';
+
+			if ($test instanceof TestCase) {
+				$test->markAsRisky();
+			}
+
+			if ($this->stopOnRisky) {
+				$this->stop();
+			}
+		} elseif ($t instanceof IncompleteTest) {
+			$this->notImplemented[] = new TestFailure($test, $t);
+			$notifyMethod           = 'addIncompleteTest';
+
+			if ($this->stopOnIncomplete) {
+				$this->stop();
+			}
+		} elseif ($t instanceof SkippedTest) {
+			$this->skipped[] = new TestFailure($test, $t);
+			$notifyMethod    = 'addSkippedTest';
+
+			if ($this->stopOnSkipped) {
+				$this->stop();
+			}
+		} else {
+			$this->errors[] = new TestFailure($test, $t);
+			$notifyMethod   = 'addError';
+
+			if ($this->stopOnError || $this->stopOnFailure) {
+				$this->stop();
+			}
+		}
+
+		// @see https://github.com/sebastianbergmann/phpunit/issues/1953
+		if ($t instanceof Error) {
+			$t = new ExceptionWrapper($t);
+		}
+
+		foreach ($this->listeners as $listener) {
+			$listener->$notifyMethod($test, $t, $time);
+		}
+
+		$this->lastTestFailed = true;
+		$this->time += $time;
+	}
+
+	/**
+	 * Adds a warning to the list of warnings.
+	 * The passed in exception caused the warning.
+	 *
+	 * @param Test    $test
+	 * @param Warning $e
+	 * @param float   $time
+	 */
+	public function addWarning(Test $test, Warning $e, $time)
+	{
+		if ($this->stopOnWarning) {
+			$this->stop();
+		}
+
+		$this->warnings[] = new TestFailure($test, $e);
+
+		foreach ($this->listeners as $listener) {
+			$listener->addWarning($test, $e, $time);
+		}
+
+		$this->time += $time;
+	}
+
+	/**
+	 * Adds a failure to the list of failures.
+	 * The passed in exception caused the failure.
+	 *
+	 * @param Test                 $test
+	 * @param AssertionFailedError $e
+	 * @param float                $time
+	 */
+	public function addFailure(Test $test, AssertionFailedError $e, $time)
+	{
+		if ($e instanceof RiskyTest || $e instanceof OutputError) {
+			$this->risky[] = new TestFailure($test, $e);
+			$notifyMethod  = 'addRiskyTest';
+
+			if ($test instanceof TestCase) {
+				$test->markAsRisky();
+			}
+
+			if ($this->stopOnRisky) {
+				$this->stop();
+			}
+		} elseif ($e instanceof IncompleteTest) {
+			$this->notImplemented[] = new TestFailure($test, $e);
+			$notifyMethod           = 'addIncompleteTest';
+
+			if ($this->stopOnIncomplete) {
+				$this->stop();
+			}
+		} elseif ($e instanceof SkippedTest) {
+			$this->skipped[] = new TestFailure($test, $e);
+			$notifyMethod    = 'addSkippedTest';
+
+			if ($this->stopOnSkipped) {
+				$this->stop();
+			}
+		} else {
+			$this->failures[] = new TestFailure($test, $e);
+			$notifyMethod     = 'addFailure';
+
+			if ($this->stopOnFailure) {
+				$this->stop();
+			}
+		}
+
+		foreach ($this->listeners as $listener) {
+			$listener->$notifyMethod($test, $e, $time);
+		}
+
+		$this->lastTestFailed = true;
+		$this->time += $time;
+	}
+
+	/**
+	 * Informs the result that a testsuite will be started.
+	 *
+	 * @param TestSuite $suite
+	 */
+	public function startTestSuite(TestSuite $suite)
+	{
+		if ($this->topTestSuite === null) {
+			$this->topTestSuite = $suite;
+		}
+
+		foreach ($this->listeners as $listener) {
+			$listener->startTestSuite($suite);
+		}
+	}
+
+	/**
+	 * Informs the result that a testsuite was completed.
+	 *
+	 * @param TestSuite $suite
+	 */
+	public function endTestSuite(TestSuite $suite)
+	{
+		foreach ($this->listeners as $listener) {
+			$listener->endTestSuite($suite);
+		}
+	}
+
+	/**
+	 * Informs the result that a test will be started.
+	 *
+	 * @param Test $test
+	 */
+	public function startTest(Test $test)
+	{
+		$this->lastTestFailed = false;
+		$this->runTests += \count($test);
+
+		foreach ($this->listeners as $listener) {
+			$listener->startTest($test);
+		}
+	}
+
+	/**
+	 * Informs the result that a test was completed.
+	 *
+	 * @param Test  $test
+	 * @param float $time
+	 */
+	public function endTest(Test $test, $time)
+	{
+		foreach ($this->listeners as $listener) {
+			$listener->endTest($test, $time);
+		}
+
+		if (!$this->lastTestFailed && $test instanceof TestCase) {
+			$class = \get_class($test);
+			$key   = $class . '::' . $test->getName();
+
+			$this->passed[$key] = [
+				'result' => $test->getResult(),
+				'size'   => \PHPUnit\Util\Test::getSize(
+					$class,
+					$test->getName(false)
+				)
+			];
+
+			$this->time += $time;
+		}
+	}
+
+	/**
+	 * Returns true if no risky test occurred.
+	 *
+	 * @return bool
+	 */
+	public function allHarmless()
+	{
+		return $this->riskyCount() == 0;
+	}
+
+	/**
+	 * Gets the number of risky tests.
+	 *
+	 * @return int
+	 */
+	public function riskyCount()
+	{
+		return \count($this->risky);
+	}
+
+	/**
+	 * Returns true if no incomplete test occurred.
+	 *
+	 * @return bool
+	 */
+	public function allCompletelyImplemented()
+	{
+		return $this->notImplementedCount() == 0;
+	}
+
+	/**
+	 * Gets the number of incomplete tests.
+	 *
+	 * @return int
+	 */
+	public function notImplementedCount()
+	{
+		return \count($this->notImplemented);
+	}
+
+	/**
+	 * Returns an Enumeration for the risky tests.
+	 *
+	 * @return array
+	 */
+	public function risky()
+	{
+		return $this->risky;
+	}
+
+	/**
+	 * Returns an Enumeration for the incomplete tests.
+	 *
+	 * @return array
+	 */
+	public function notImplemented()
+	{
+		return $this->notImplemented;
+	}
+
+	/**
+	 * Returns true if no test has been skipped.
+	 *
+	 * @return bool
+	 */
+	public function noneSkipped()
+	{
+		return $this->skippedCount() == 0;
+	}
+
+	/**
+	 * Gets the number of skipped tests.
+	 *
+	 * @return int
+	 */
+	public function skippedCount()
+	{
+		return \count($this->skipped);
+	}
+
+	/**
+	 * Returns an Enumeration for the skipped tests.
+	 *
+	 * @return array
+	 */
+	public function skipped()
+	{
+		return $this->skipped;
+	}
+
+	/**
+	 * Gets the number of detected errors.
+	 *
+	 * @return int
+	 */
+	public function errorCount()
+	{
+		return \count($this->errors);
+	}
+
+	/**
+	 * Returns an Enumeration for the errors.
+	 *
+	 * @return array
+	 */
+	public function errors()
+	{
+		return $this->errors;
+	}
+
+	/**
+	 * Gets the number of detected failures.
+	 *
+	 * @return int
+	 */
+	public function failureCount()
+	{
+		return \count($this->failures);
+	}
+
+	/**
+	 * Returns an Enumeration for the failures.
+	 *
+	 * @return array
+	 */
+	public function failures()
+	{
+		return $this->failures;
+	}
+
+	/**
+	 * Gets the number of detected warnings.
+	 *
+	 * @return int
+	 */
+	public function warningCount()
+	{
+		return \count($this->warnings);
+	}
+
+	/**
+	 * Returns an Enumeration for the warnings.
+	 *
+	 * @return array
+	 */
+	public function warnings()
+	{
+		return $this->warnings;
+	}
+
+	/**
+	 * Returns the names of the tests that have passed.
+	 *
+	 * @return array
+	 */
+	public function passed()
+	{
+		return $this->passed;
+	}
+
+	/**
+	 * Returns the (top) test suite.
+	 *
+	 * @return TestSuite
+	 */
+	public function topTestSuite()
+	{
+		return $this->topTestSuite;
+	}
+
+	/**
+	 * Returns whether code coverage information should be collected.
+	 *
+	 * @return bool If code coverage should be collected
+	 */
+	public function getCollectCodeCoverageInformation()
+	{
+		return $this->codeCoverage !== null;
+	}
+
+	/**
+	 * Runs a TestCase.
+	 *
+	 * @param Test $test
+	 */
+	public function run(Test $test)
+	{
+		Assert::resetCount();
+
+		$coversNothing = false;
+
+		if ($test instanceof TestCase) {
+			$test->setRegisterMockObjectsFromTestArgumentsRecursively(
+				$this->registerMockObjectsFromTestArgumentsRecursively
+			);
+
+			$annotations = $test->getAnnotations();
+
+			if (isset($annotations['class']['coversNothing']) || isset($annotations['method']['coversNothing'])) {
+				$coversNothing = true;
+			}
+		}
+
+		$error      = false;
+		$failure    = false;
+		$warning    = false;
+		$incomplete = false;
+		$risky      = false;
+		$skipped    = false;
+
+		$this->startTest($test);
+
+		$errorHandlerSet = false;
+
+		if ($this->convertErrorsToExceptions) {
+			$oldErrorHandler = \set_error_handler(
+				[\PHPUnit\Util\ErrorHandler::class, 'handleError'],
+				E_ALL | E_STRICT
+			);
+
+			if ($oldErrorHandler === null) {
+				$errorHandlerSet = true;
+			} else {
+				\restore_error_handler();
+			}
+		}
+
+		$collectCodeCoverage = $this->codeCoverage !== null &&
+							   !$test instanceof WarningTestCase &&
+							   !$coversNothing;
+
+		if ($collectCodeCoverage) {
+			$this->codeCoverage->start($test);
+		}
+
+		$monitorFunctions = $this->beStrictAboutResourceUsageDuringSmallTests &&
+			!$test instanceof WarningTestCase &&
+			$test->getSize() == \PHPUnit\Util\Test::SMALL &&
+			\function_exists('xdebug_start_function_monitor');
+
+		if ($monitorFunctions) {
+			\xdebug_start_function_monitor(ResourceOperations::getFunctions());
+		}
+
+		PHP_Timer::start();
+
+		try {
+			if (!$test instanceof WarningTestCase &&
+				$test->getSize() != \PHPUnit\Util\Test::UNKNOWN &&
+				$this->enforceTimeLimit &&
+				\extension_loaded('pcntl') && \class_exists('PHP_Invoker')) {
+				switch ($test->getSize()) {
+					case \PHPUnit\Util\Test::SMALL:
+						$_timeout = $this->timeoutForSmallTests;
+
+						break;
+
+					case \PHPUnit\Util\Test::MEDIUM:
+						$_timeout = $this->timeoutForMediumTests;
+
+						break;
+
+					case \PHPUnit\Util\Test::LARGE:
+						$_timeout = $this->timeoutForLargeTests;
+
+						break;
+				}
+
+				$invoker = new PHP_Invoker;
+				$invoker->invoke([$test, 'runBare'], [], $_timeout);
+			} else {
+				$test->runBare();
+			}
+		} catch (PHP_Invoker_TimeoutException $e) {
+			$this->addFailure(
+				$test,
+				new RiskyTestError(
+					$e->getMessage()
+				),
+				$_timeout
+			);
+
+			$risky = true;
+		} catch (PHPUnit_Framework_MockObject_Exception $e) {
+			$e = new Warning(
+				$e->getMessage()
+			);
+
+			$warning = true;
+		} catch (AssertionFailedError $e) {
+			$failure = true;
+
+			if ($e instanceof RiskyTestError) {
+				$risky = true;
+			} elseif ($e instanceof IncompleteTestError) {
+				$incomplete = true;
+			} elseif ($e instanceof SkippedTestError) {
+				$skipped = true;
+			}
+		} catch (AssertionError $e) {
+			$test->addToAssertionCount(1);
+
+			$failure = true;
+			$frame   = $e->getTrace()[0];
+
+			$e = new AssertionFailedError(
+				\sprintf(
+					'%s in %s:%s',
+					$e->getMessage(),
+					$frame['file'],
+					$frame['line']
+				)
+			);
+		} catch (Warning $e) {
+			$warning = true;
+		} catch (Exception $e) {
+			$error = true;
+		} catch (Throwable $e) {
+			$e     = new ExceptionWrapper($e);
+			$error = true;
+		}
+
+		$time = PHP_Timer::stop();
+		$test->addToAssertionCount(Assert::getCount());
+
+		if ($monitorFunctions) {
+			$blacklist = new Blacklist;
+			$functions = \xdebug_get_monitored_functions();
+			\xdebug_stop_function_monitor();
+
+			foreach ($functions as $function) {
+				if (!$blacklist->isBlacklisted($function['filename'])) {
+					$this->addFailure(
+						$test,
+						new RiskyTestError(
+							\sprintf(
+								'%s() used in %s:%s',
+								$function['function'],
+								$function['filename'],
+								$function['lineno']
+							)
+						),
+						$time
+					);
+				}
+			}
+		}
+
+		if ($this->beStrictAboutTestsThatDoNotTestAnything &&
+			$test->getNumAssertions() == 0) {
+			$risky = true;
+		}
+
+		if ($collectCodeCoverage) {
+			$append           = !$risky && !$incomplete && !$skipped;
+			$linesToBeCovered = [];
+			$linesToBeUsed    = [];
+
+			if ($append && $test instanceof TestCase) {
+				try {
+					$linesToBeCovered = \PHPUnit\Util\Test::getLinesToBeCovered(
+						\get_class($test),
+						$test->getName(false)
+					);
+
+					$linesToBeUsed = \PHPUnit\Util\Test::getLinesToBeUsed(
+						\get_class($test),
+						$test->getName(false)
+					);
+				} catch (InvalidCoversTargetException $cce) {
+					$this->addWarning(
+						$test,
+						new Warning(
+							$cce->getMessage()
+						),
+						$time
+					);
+				}
+			}
+
+			try {
+				$this->codeCoverage->stop(
+					$append,
+					$linesToBeCovered,
+					$linesToBeUsed
+				);
+			} catch (UnintentionallyCoveredCodeException $cce) {
+				$this->addFailure(
+					$test,
+					new UnintentionallyCoveredCodeError(
+						'This test executed code that is not listed as code to be covered or used:' .
+						PHP_EOL . $cce->getMessage()
+					),
+					$time
+				);
+			} catch (OriginalCoveredCodeNotExecutedException $cce) {
+				$this->addFailure(
+					$test,
+					new CoveredCodeNotExecutedException(
+						'This test did not execute all the code that is listed as code to be covered:' .
+						PHP_EOL . $cce->getMessage()
+					),
+					$time
+				);
+			} catch (OriginalMissingCoversAnnotationException $cce) {
+				if ($linesToBeCovered !== false) {
+					$this->addFailure(
+						$test,
+						new MissingCoversAnnotationException(
+							'This test does not have a @covers annotation but is expected to have one'
+						),
+						$time
+					);
+				}
+			} catch (OriginalCodeCoverageException $cce) {
+				$error = true;
+
+				if (!isset($e)) {
+					$e = $cce;
+				}
+			}
+		}
+
+		if ($errorHandlerSet === true) {
+			\restore_error_handler();
+		}
+
+		if ($error === true) {
+			$this->addError($test, $e, $time);
+		} elseif ($failure === true) {
+			$this->addFailure($test, $e, $time);
+		} elseif ($warning === true) {
+			$this->addWarning($test, $e, $time);
+		} elseif ($this->beStrictAboutTestsThatDoNotTestAnything &&
+			!$test->doesNotPerformAssertions() &&
+			$test->getNumAssertions() == 0) {
+			$this->addFailure(
+				$test,
+				new RiskyTestError(
+					'This test did not perform any assertions'
+				),
+				$time
+			);
+		} elseif ($this->beStrictAboutOutputDuringTests && $test->hasOutput()) {
+			$this->addFailure(
+				$test,
+				new OutputError(
+					\sprintf(
+						'This test printed output: %s',
+						$test->getActualOutput()
+					)
+				),
+				$time
+			);
+		} elseif ($this->beStrictAboutTodoAnnotatedTests && $test instanceof TestCase) {
+			$annotations = $test->getAnnotations();
+
+			if (isset($annotations['method']['todo'])) {
+				$this->addFailure(
+					$test,
+					new RiskyTestError(
+						'Test method is annotated with @todo'
+					),
+					$time
+				);
+			}
+		}
+
+		$this->endTest($test, $time);
+	}
+
+	/**
+	 * Gets the number of run tests.
+	 *
+	 * @return int
+	 */
+	public function count()
+	{
+		return $this->runTests;
+	}
+
+	/**
+	 * Checks whether the test run should stop.
+	 *
+	 * @return bool
+	 */
+	public function shouldStop()
+	{
+		return $this->stop;
+	}
+
+	/**
+	 * Marks that the test run should stop.
+	 */
+	public function stop()
+	{
+		$this->stop = true;
+	}
+
+	/**
+	 * Returns the code coverage object.
+	 *
+	 * @return CodeCoverage
+	 */
+	public function getCodeCoverage()
+	{
+		return $this->codeCoverage;
+	}
+
+	/**
+	 * Sets the code coverage object.
+	 *
+	 * @param CodeCoverage $codeCoverage
+	 */
+	public function setCodeCoverage(CodeCoverage $codeCoverage)
+	{
+		$this->codeCoverage = $codeCoverage;
+	}
+
+	/**
+	 * Enables or disables the error-to-exception conversion.
+	 *
+	 * @param bool $flag
+	 *
+	 * @throws Exception
+	 */
+	public function convertErrorsToExceptions($flag)
+	{
+		if (!\is_bool($flag)) {
+			throw InvalidArgumentHelper::factory(1, 'boolean');
+		}
+
+		$this->convertErrorsToExceptions = $flag;
+	}
+
+	/**
+	 * Returns the error-to-exception conversion setting.
+	 *
+	 * @return bool
+	 */
+	public function getConvertErrorsToExceptions()
+	{
+		return $this->convertErrorsToExceptions;
+	}
+
+	/**
+	 * Enables or disables the stopping when an error occurs.
+	 *
+	 * @param bool $flag
+	 *
+	 * @throws Exception
+	 */
+	public function stopOnError($flag)
+	{
+		if (!\is_bool($flag)) {
+			throw InvalidArgumentHelper::factory(1, 'boolean');
+		}
+
+		$this->stopOnError = $flag;
+	}
+
+	/**
+	 * Enables or disables the stopping when a failure occurs.
+	 *
+	 * @param bool $flag
+	 *
+	 * @throws Exception
+	 */
+	public function stopOnFailure($flag)
+	{
+		if (!\is_bool($flag)) {
+			throw InvalidArgumentHelper::factory(1, 'boolean');
+		}
+
+		$this->stopOnFailure = $flag;
+	}
+
+	/**
+	 * Enables or disables the stopping when a warning occurs.
+	 *
+	 * @param bool $flag
+	 *
+	 * @throws Exception
+	 */
+	public function stopOnWarning($flag)
+	{
+		if (!\is_bool($flag)) {
+			throw InvalidArgumentHelper::factory(1, 'boolean');
+		}
+
+		$this->stopOnWarning = $flag;
+	}
+
+	/**
+	 * @param bool $flag
+	 *
+	 * @throws Exception
+	 */
+	public function beStrictAboutTestsThatDoNotTestAnything($flag)
+	{
+		if (!\is_bool($flag)) {
+			throw InvalidArgumentHelper::factory(1, 'boolean');
+		}
+
+		$this->beStrictAboutTestsThatDoNotTestAnything = $flag;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isStrictAboutTestsThatDoNotTestAnything()
+	{
+		return $this->beStrictAboutTestsThatDoNotTestAnything;
+	}
+
+	/**
+	 * @param bool $flag
+	 *
+	 * @throws Exception
+	 */
+	public function beStrictAboutOutputDuringTests($flag)
+	{
+		if (!\is_bool($flag)) {
+			throw InvalidArgumentHelper::factory(1, 'boolean');
+		}
+
+		$this->beStrictAboutOutputDuringTests = $flag;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isStrictAboutOutputDuringTests()
+	{
+		return $this->beStrictAboutOutputDuringTests;
+	}
+
+	/**
+	 * @param bool $flag
+	 *
+	 * @throws Exception
+	 */
+	public function beStrictAboutResourceUsageDuringSmallTests($flag)
+	{
+		if (!\is_bool($flag)) {
+			throw InvalidArgumentHelper::factory(1, 'boolean');
+		}
+
+		$this->beStrictAboutResourceUsageDuringSmallTests = $flag;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isStrictAboutResourceUsageDuringSmallTests()
+	{
+		return $this->beStrictAboutResourceUsageDuringSmallTests;
+	}
+
+	/**
+	 * @param bool $flag
+	 *
+	 * @throws Exception
+	 */
+	public function enforceTimeLimit($flag)
+	{
+		if (!\is_bool($flag)) {
+			throw InvalidArgumentHelper::factory(1, 'boolean');
+		}
+
+		$this->enforceTimeLimit = $flag;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function enforcesTimeLimit()
+	{
+		return $this->enforceTimeLimit;
+	}
+
+	/**
+	 * @param bool $flag
+	 *
+	 * @throws Exception
+	 */
+	public function beStrictAboutTodoAnnotatedTests($flag)
+	{
+		if (!\is_bool($flag)) {
+			throw InvalidArgumentHelper::factory(1, 'boolean');
+		}
+
+		$this->beStrictAboutTodoAnnotatedTests = $flag;
+	}
+
+	/**
+	 * @return bool
+	 */
+	public function isStrictAboutTodoAnnotatedTests()
+	{
+		return $this->beStrictAboutTodoAnnotatedTests;
+	}
+
+	/**
+	 * Enables or disables the stopping for risky tests.
+	 *
+	 * @param bool $flag
+	 *
+	 * @throws Exception
+	 */
+	public function stopOnRisky($flag)
+	{
+		if (!\is_bool($flag)) {
+			throw InvalidArgumentHelper::factory(1, 'boolean');
+		}
+
+		$this->stopOnRisky = $flag;
+	}
+
+	/**
+	 * Enables or disables the stopping for incomplete tests.
+	 *
+	 * @param bool $flag
+	 *
+	 * @throws Exception
+	 */
+	public function stopOnIncomplete($flag)
+	{
+		if (!\is_bool($flag)) {
+			throw InvalidArgumentHelper::factory(1, 'boolean');
+		}
+
+		$this->stopOnIncomplete = $flag;
+	}
+
+	/**
+	 * Enables or disables the stopping for skipped tests.
+	 *
+	 * @param bool $flag
+	 *
+	 * @throws Exception
+	 */
+	public function stopOnSkipped($flag)
+	{
+		if (!\is_bool($flag)) {
+			throw InvalidArgumentHelper::factory(1, 'boolean');
+		}
+
+		$this->stopOnSkipped = $flag;
+	}
+
+	/**
+	 * Returns the time spent running the tests.
+	 *
+	 * @return float
+	 */
+	public function time()
+	{
+		return $this->time;
+	}
+
+	/**
+	 * Returns whether the entire test was successful or not.
+	 *
+	 * @return bool
+	 */
+	public function wasSuccessful()
+	{
+		return empty($this->errors) && empty($this->failures) && empty($this->warnings);
+	}
+
+	/**
+	 * Sets the timeout for small tests.
+	 *
+	 * @param int $timeout
+	 *
+	 * @throws Exception
+	 */
+	public function setTimeoutForSmallTests($timeout)
+	{
+		if (!\is_int($timeout)) {
+			throw InvalidArgumentHelper::factory(1, 'integer');
+		}
+
+		$this->timeoutForSmallTests = $timeout;
+	}
+
+	/**
+	 * Sets the timeout for medium tests.
+	 *
+	 * @param int $timeout
+	 *
+	 * @throws Exception
+	 */
+	public function setTimeoutForMediumTests($timeout)
+	{
+		if (!\is_int($timeout)) {
+			throw InvalidArgumentHelper::factory(1, 'integer');
+		}
+
+		$this->timeoutForMediumTests = $timeout;
+	}
+
+	/**
+	 * Sets the timeout for large tests.
+	 *
+	 * @param int $timeout
+	 *
+	 * @throws Exception
+	 */
+	public function setTimeoutForLargeTests($timeout)
+	{
+		if (!\is_int($timeout)) {
+			throw InvalidArgumentHelper::factory(1, 'integer');
+		}
+
+		$this->timeoutForLargeTests = $timeout;
+	}
+
+	/**
+	 * Returns the set timeout for large tests.
+	 *
+	 * @return int
+	 */
+	public function getTimeoutForLargeTests()
+	{
+		return $this->timeoutForLargeTests;
+	}
+
+	/**
+	 * @param bool $flag
+	 */
+	public function setRegisterMockObjectsFromTestArgumentsRecursively($flag)
+	{
+		if (!\is_bool($flag)) {
+			throw InvalidArgumentHelper::factory(1, 'boolean');
+		}
+
+		$this->registerMockObjectsFromTestArgumentsRecursively = $flag;
+	}
+
+	/**
+	 * Returns the class hierarchy for a given class.
+	 *
+	 * @param string $className
+	 * @param bool   $asReflectionObjects
+	 *
+	 * @return array
+	 */
+	protected function getHierarchy($className, $asReflectionObjects = false)
+	{
+		if ($asReflectionObjects) {
+			$classes = [new ReflectionClass($className)];
+		} else {
+			$classes = [$className];
+		}
+
+		$done = false;
+
+		while (!$done) {
+			if ($asReflectionObjects) {
+				$class = new ReflectionClass(
+					$classes[\count($classes) - 1]->getName()
+				);
+			} else {
+				$class = new ReflectionClass($classes[\count($classes) - 1]);
+			}
+
+			$parent = $class->getParentClass();
+
+			if ($parent !== false) {
+				if ($asReflectionObjects) {
+					$classes[] = $parent;
+				} else {
+					$classes[] = $parent->getName();
+				}
+			} else {
+				$done = true;
+			}
+		}
+
+		return $classes;
+	}
 }

Spacing +5 added lines, -5 removed lines

@@ -410,7 +410,7 @@ 
 
         if (!$this->lastTestFailed && $test instanceof TestCase) {
             $class = \get_class($test);
-            $key   = $class . '::' . $test->getName();
+            $key   = $class.'::'.$test->getName();
 
             $this->passed[$key] = [
                 'result' => $test->getResult(),
@@ -814,8 +814,8 @@ 
                 $this->addFailure(
                     $test,
                     new UnintentionallyCoveredCodeError(
-                        'This test executed code that is not listed as code to be covered or used:' .
-                        PHP_EOL . $cce->getMessage()
+                        'This test executed code that is not listed as code to be covered or used:'.
+                        PHP_EOL.$cce->getMessage()
                     ),
                     $time
                 );
@@ -823,8 +823,8 @@ 
                 $this->addFailure(
                     $test,
                     new CoveredCodeNotExecutedException(
-                        'This test did not execute all the code that is listed as code to be covered:' .
-                        PHP_EOL . $cce->getMessage()
+                        'This test did not execute all the code that is listed as code to be covered:'.
+                        PHP_EOL.$cce->getMessage()
                     ),
                     $time
                 );

vendor/phpunit/phpunit/src/Framework/Warning.php

Indentation +9 added lines, -9 removed lines

@@ -14,13 +14,13 @@
  */
 class Warning extends Exception implements SelfDescribing
 {
-    /**
-     * Wrapper for getMessage() which is declared as final.
-     *
-     * @return string
-     */
-    public function toString()
-    {
-        return $this->getMessage();
-    }
+	/**
+	 * Wrapper for getMessage() which is declared as final.
+	 *
+	 * @return string
+	 */
+	public function toString()
+	{
+		return $this->getMessage();
+	}
 }

vendor/phpunit/phpunit/src/Framework/IncompleteTestCase.php

Indentation +57 added lines, -57 removed lines

@@ -14,70 +14,70 @@
  */
 class IncompleteTestCase extends TestCase
 {
-    /**
-     * @var string
-     */
-    protected $message = '';
+	/**
+	 * @var string
+	 */
+	protected $message = '';
 
-    /**
-     * @var bool
-     */
-    protected $backupGlobals = false;
+	/**
+	 * @var bool
+	 */
+	protected $backupGlobals = false;
 
-    /**
-     * @var bool
-     */
-    protected $backupStaticAttributes = false;
+	/**
+	 * @var bool
+	 */
+	protected $backupStaticAttributes = false;
 
-    /**
-     * @var bool
-     */
-    protected $runTestInSeparateProcess = false;
+	/**
+	 * @var bool
+	 */
+	protected $runTestInSeparateProcess = false;
 
-    /**
-     * @var bool
-     */
-    protected $useErrorHandler = false;
+	/**
+	 * @var bool
+	 */
+	protected $useErrorHandler = false;
 
-    /**
-     * @var bool
-     */
-    protected $useOutputBuffering = false;
+	/**
+	 * @var bool
+	 */
+	protected $useOutputBuffering = false;
 
-    /**
-     * @param string $className
-     * @param string $methodName
-     * @param string $message
-     */
-    public function __construct($className, $methodName, $message = '')
-    {
-        $this->message = $message;
-        parent::__construct($className . '::' . $methodName);
-    }
+	/**
+	 * @param string $className
+	 * @param string $methodName
+	 * @param string $message
+	 */
+	public function __construct($className, $methodName, $message = '')
+	{
+		$this->message = $message;
+		parent::__construct($className . '::' . $methodName);
+	}
 
-    /**
-     * @throws Exception
-     */
-    protected function runTest()
-    {
-        $this->markTestIncomplete($this->message);
-    }
+	/**
+	 * @throws Exception
+	 */
+	protected function runTest()
+	{
+		$this->markTestIncomplete($this->message);
+	}
 
-    /**
-     * @return string
-     */
-    public function getMessage()
-    {
-        return $this->message;
-    }
+	/**
+	 * @return string
+	 */
+	public function getMessage()
+	{
+		return $this->message;
+	}
 
-    /**
-     * Returns a string representation of the test case.
-     *
-     * @return string
-     */
-    public function toString()
-    {
-        return $this->getName();
-    }
+	/**
+	 * Returns a string representation of the test case.
+	 *
+	 * @return string
+	 */
+	public function toString()
+	{
+		return $this->getName();
+	}
 }

Spacing +1 added lines, -1 removed lines

@@ -52,7 +52,7 @@
     public function __construct($className, $methodName, $message = '')
     {
         $this->message = $message;
-        parent::__construct($className . '::' . $methodName);
+        parent::__construct($className.'::'.$methodName);
     }
 
     /**

vendor/phpunit/phpunit/src/Framework/DataProviderTestSuite.php

Indentation +11 added lines, -11 removed lines

@@ -11,15 +11,15 @@
 
 class DataProviderTestSuite extends TestSuite
 {
-    /**
-     * Sets the dependencies of a TestCase.
-     *
-     * @param string[] $dependencies
-     */
-    public function setDependencies(array $dependencies)
-    {
-        foreach ($this->tests as $test) {
-            $test->setDependencies($dependencies);
-        }
-    }
+	/**
+	 * Sets the dependencies of a TestCase.
+	 *
+	 * @param string[] $dependencies
+	 */
+	public function setDependencies(array $dependencies)
+	{
+		foreach ($this->tests as $test) {
+			$test->setDependencies($dependencies);
+		}
+	}
 }

vendor/phpunit/phpunit/src/Framework/Error/Notice.php

Indentation +1 added lines, -1 removed lines

@@ -11,5 +11,5 @@
 
 class Notice extends Error
 {
-    public static $enabled = true;
+	public static $enabled = true;
 }

vendor/phpunit/phpunit/src/Framework/Error/Deprecated.php

Indentation +1 added lines, -1 removed lines

@@ -11,5 +11,5 @@
 
 class Deprecated extends Error
 {
-    public static $enabled = true;
+	public static $enabled = true;
 }

vendor/phpunit/phpunit/src/Framework/Error/Warning.php

Indentation +1 added lines, -1 removed lines

@@ -11,5 +11,5 @@
 
 class Warning extends Error
 {
-    public static $enabled = true;
+	public static $enabled = true;
 }