eventespresso / event-espresso-core

vendor/phpunit/phpunit/src/TextUI/XmlConfiguration/PHPUnit/Extension.php

Indentation +46 added lines, -46 removed lines

@@ -16,58 +16,58 @@
  */
 final class Extension
 {
-    /**
-     * @var string
-     *
-     * @psalm-var class-string
-     */
-    private $className;
+	/**
+	 * @var string
+	 *
+	 * @psalm-var class-string
+	 */
+	private $className;
 
-    /**
-     * @var string
-     */
-    private $sourceFile;
+	/**
+	 * @var string
+	 */
+	private $sourceFile;
 
-    /**
-     * @var array
-     */
-    private $arguments;
+	/**
+	 * @var array
+	 */
+	private $arguments;
 
-    /**
-     * @psalm-param class-string $className
-     */
-    public function __construct(string $className, string $sourceFile, array $arguments)
-    {
-        $this->className  = $className;
-        $this->sourceFile = $sourceFile;
-        $this->arguments  = $arguments;
-    }
+	/**
+	 * @psalm-param class-string $className
+	 */
+	public function __construct(string $className, string $sourceFile, array $arguments)
+	{
+		$this->className  = $className;
+		$this->sourceFile = $sourceFile;
+		$this->arguments  = $arguments;
+	}
 
-    /**
-     * @psalm-return class-string
-     */
-    public function className(): string
-    {
-        return $this->className;
-    }
+	/**
+	 * @psalm-return class-string
+	 */
+	public function className(): string
+	{
+		return $this->className;
+	}
 
-    public function hasSourceFile(): bool
-    {
-        return $this->sourceFile !== '';
-    }
+	public function hasSourceFile(): bool
+	{
+		return $this->sourceFile !== '';
+	}
 
-    public function sourceFile(): string
-    {
-        return $this->sourceFile;
-    }
+	public function sourceFile(): string
+	{
+		return $this->sourceFile;
+	}
 
-    public function hasArguments(): bool
-    {
-        return !empty($this->arguments);
-    }
+	public function hasArguments(): bool
+	{
+		return !empty($this->arguments);
+	}
 
-    public function arguments(): array
-    {
-        return $this->arguments;
-    }
+	public function arguments(): array
+	{
+		return $this->arguments;
+	}
 }

vendor/phpunit/phpunit/src/Runner/Extension/ExtensionHandler.php

Indentation +79 added lines, -79 removed lines

@@ -24,95 +24,95 @@
  */
 final class ExtensionHandler
 {
-    /**
-     * @throws Exception
-     */
-    public function registerExtension(Extension $extensionConfiguration, TestRunner $runner): void
-    {
-        $extension = $this->createInstance($extensionConfiguration);
+	/**
+	 * @throws Exception
+	 */
+	public function registerExtension(Extension $extensionConfiguration, TestRunner $runner): void
+	{
+		$extension = $this->createInstance($extensionConfiguration);
 
-        if (!$extension instanceof Hook) {
-            throw new Exception(
-                sprintf(
-                    'Class "%s" does not implement a PHPUnit\Runner\Hook interface',
-                    $extensionConfiguration->className()
-                )
-            );
-        }
+		if (!$extension instanceof Hook) {
+			throw new Exception(
+				sprintf(
+					'Class "%s" does not implement a PHPUnit\Runner\Hook interface',
+					$extensionConfiguration->className()
+				)
+			);
+		}
 
-        $runner->addExtension($extension);
-    }
+		$runner->addExtension($extension);
+	}
 
-    /**
-     * @throws Exception
-     *
-     * @deprecated
-     */
-    public function createTestListenerInstance(Extension $listenerConfiguration): TestListener
-    {
-        $listener = $this->createInstance($listenerConfiguration);
+	/**
+	 * @throws Exception
+	 *
+	 * @deprecated
+	 */
+	public function createTestListenerInstance(Extension $listenerConfiguration): TestListener
+	{
+		$listener = $this->createInstance($listenerConfiguration);
 
-        if (!$listener instanceof TestListener) {
-            throw new Exception(
-                sprintf(
-                    'Class "%s" does not implement the PHPUnit\Framework\TestListener interface',
-                    $listenerConfiguration->className()
-                )
-            );
-        }
+		if (!$listener instanceof TestListener) {
+			throw new Exception(
+				sprintf(
+					'Class "%s" does not implement the PHPUnit\Framework\TestListener interface',
+					$listenerConfiguration->className()
+				)
+			);
+		}
 
-        return $listener;
-    }
+		return $listener;
+	}
 
-    /**
-     * @throws Exception
-     */
-    private function createInstance(Extension $extensionConfiguration): object
-    {
-        $this->ensureClassExists($extensionConfiguration);
+	/**
+	 * @throws Exception
+	 */
+	private function createInstance(Extension $extensionConfiguration): object
+	{
+		$this->ensureClassExists($extensionConfiguration);
 
-        try {
-            $reflector = new ReflectionClass($extensionConfiguration->className());
-        } catch (ReflectionException $e) {
-            throw new Exception(
-                $e->getMessage(),
-                (int) $e->getCode(),
-                $e
-            );
-        }
+		try {
+			$reflector = new ReflectionClass($extensionConfiguration->className());
+		} catch (ReflectionException $e) {
+			throw new Exception(
+				$e->getMessage(),
+				(int) $e->getCode(),
+				$e
+			);
+		}
 
-        if (!$extensionConfiguration->hasArguments()) {
-            return $reflector->newInstance();
-        }
+		if (!$extensionConfiguration->hasArguments()) {
+			return $reflector->newInstance();
+		}
 
-        return $reflector->newInstanceArgs($extensionConfiguration->arguments());
-    }
+		return $reflector->newInstanceArgs($extensionConfiguration->arguments());
+	}
 
-    /**
-     * @throws Exception
-     */
-    private function ensureClassExists(Extension $extensionConfiguration): void
-    {
-        if (class_exists($extensionConfiguration->className(), false)) {
-            return;
-        }
+	/**
+	 * @throws Exception
+	 */
+	private function ensureClassExists(Extension $extensionConfiguration): void
+	{
+		if (class_exists($extensionConfiguration->className(), false)) {
+			return;
+		}
 
-        if ($extensionConfiguration->hasSourceFile()) {
-            /**
-             * @noinspection PhpIncludeInspection
-             *
-             * @psalm-suppress UnresolvableInclude
-             */
-            require_once $extensionConfiguration->sourceFile();
-        }
+		if ($extensionConfiguration->hasSourceFile()) {
+			/**
+			 * @noinspection PhpIncludeInspection
+			 *
+			 * @psalm-suppress UnresolvableInclude
+			 */
+			require_once $extensionConfiguration->sourceFile();
+		}
 
-        if (!class_exists($extensionConfiguration->className())) {
-            throw new Exception(
-                sprintf(
-                    'Class "%s" does not exist',
-                    $extensionConfiguration->className()
-                )
-            );
-        }
-    }
+		if (!class_exists($extensionConfiguration->className())) {
+			throw new Exception(
+				sprintf(
+					'Class "%s" does not exist',
+					$extensionConfiguration->className()
+				)
+			);
+		}
+	}
 }

vendor/phpunit/phpunit/src/Runner/Extension/PharLoader.php

Indentation +41 added lines, -41 removed lines

@@ -22,56 +22,56 @@
  */
 final class PharLoader
 {
-    /**
-     * @psalm-return array{loadedExtensions: list<string>, notLoadedExtensions: list<string>}
-     */
-    public function loadPharExtensionsInDirectory(string $directory): array
-    {
-        $loadedExtensions    = [];
-        $notLoadedExtensions = [];
+	/**
+	 * @psalm-return array{loadedExtensions: list<string>, notLoadedExtensions: list<string>}
+	 */
+	public function loadPharExtensionsInDirectory(string $directory): array
+	{
+		$loadedExtensions    = [];
+		$notLoadedExtensions = [];
 
-        foreach ((new FileIteratorFacade)->getFilesAsArray($directory, '.phar') as $file) {
-            if (!is_file('phar://' . $file . '/manifest.xml')) {
-                $notLoadedExtensions[] = $file . ' is not an extension for PHPUnit';
+		foreach ((new FileIteratorFacade)->getFilesAsArray($directory, '.phar') as $file) {
+			if (!is_file('phar://' . $file . '/manifest.xml')) {
+				$notLoadedExtensions[] = $file . ' is not an extension for PHPUnit';
 
-                continue;
-            }
+				continue;
+			}
 
-            try {
-                $applicationName = new ApplicationName('phpunit/phpunit');
-                $version         = new PharIoVersion(Version::series());
-                $manifest        = ManifestLoader::fromFile('phar://' . $file . '/manifest.xml');
+			try {
+				$applicationName = new ApplicationName('phpunit/phpunit');
+				$version         = new PharIoVersion(Version::series());
+				$manifest        = ManifestLoader::fromFile('phar://' . $file . '/manifest.xml');
 
-                if (!$manifest->isExtensionFor($applicationName)) {
-                    $notLoadedExtensions[] = $file . ' is not an extension for PHPUnit';
+				if (!$manifest->isExtensionFor($applicationName)) {
+					$notLoadedExtensions[] = $file . ' is not an extension for PHPUnit';
 
-                    continue;
-                }
+					continue;
+				}
 
-                if (!$manifest->isExtensionFor($applicationName, $version)) {
-                    $notLoadedExtensions[] = $file . ' is not compatible with this version of PHPUnit';
+				if (!$manifest->isExtensionFor($applicationName, $version)) {
+					$notLoadedExtensions[] = $file . ' is not compatible with this version of PHPUnit';
 
-                    continue;
-                }
-            } catch (ManifestException $e) {
-                $notLoadedExtensions[] = $file . ': ' . $e->getMessage();
+					continue;
+				}
+			} catch (ManifestException $e) {
+				$notLoadedExtensions[] = $file . ': ' . $e->getMessage();
 
-                continue;
-            }
+				continue;
+			}
 
-            /**
-             * @noinspection PhpIncludeInspection
-             *
-             * @psalm-suppress UnresolvableInclude
-             */
-            require $file;
+			/**
+			 * @noinspection PhpIncludeInspection
+			 *
+			 * @psalm-suppress UnresolvableInclude
+			 */
+			require $file;
 
-            $loadedExtensions[] = $manifest->getName()->asString() . ' ' . $manifest->getVersion()->getVersionString();
-        }
+			$loadedExtensions[] = $manifest->getName()->asString() . ' ' . $manifest->getVersion()->getVersionString();
+		}
 
-        return [
-            'loadedExtensions'    => $loadedExtensions,
-            'notLoadedExtensions' => $notLoadedExtensions,
-        ];
-    }
+		return [
+			'loadedExtensions'    => $loadedExtensions,
+			'notLoadedExtensions' => $notLoadedExtensions,
+		];
+	}
 }

vendor/phpunit/phpunit/src/Runner/Version.php

Indentation +34 added lines, -34 removed lines

@@ -21,45 +21,45 @@
  */
 final class Version
 {
-    /**
-     * @var string
-     */
-    private static $pharVersion = '';
+	/**
+	 * @var string
+	 */
+	private static $pharVersion = '';
 
-    /**
-     * @var string
-     */
-    private static $version = '';
+	/**
+	 * @var string
+	 */
+	private static $version = '';
 
-    /**
-     * Returns the current version of PHPUnit.
-     */
-    public static function id(): string
-    {
-        if (self::$pharVersion !== '') {
-            return self::$pharVersion;
-        }
+	/**
+	 * Returns the current version of PHPUnit.
+	 */
+	public static function id(): string
+	{
+		if (self::$pharVersion !== '') {
+			return self::$pharVersion;
+		}
 
-        if (self::$version === '') {
-            self::$version = (new VersionId('9.5.25', dirname(__DIR__, 2)))->getVersion();
-        }
+		if (self::$version === '') {
+			self::$version = (new VersionId('9.5.25', dirname(__DIR__, 2)))->getVersion();
+		}
 
-        return self::$version;
-    }
+		return self::$version;
+	}
 
-    public static function series(): string
-    {
-        if (strpos(self::id(), '-')) {
-            $version = explode('-', self::id())[0];
-        } else {
-            $version = self::id();
-        }
+	public static function series(): string
+	{
+		if (strpos(self::id(), '-')) {
+			$version = explode('-', self::id())[0];
+		} else {
+			$version = self::id();
+		}
 
-        return implode('.', array_slice(explode('.', $version), 0, 2));
-    }
+		return implode('.', array_slice(explode('.', $version), 0, 2));
+	}
 
-    public static function getVersionString(): string
-    {
-        return 'PHPUnit ' . self::id() . ' #StandWithUkraine';
-    }
+	public static function getVersionString(): string
+	{
+		return 'PHPUnit ' . self::id() . ' #StandWithUkraine';
+	}
 }

vendor/phpunit/phpunit/src/Framework/MockObject/Invocation.php

Indentation +266 added lines, -266 removed lines

@@ -32,270 +32,270 @@
  */
 final class Invocation implements SelfDescribing
 {
-    /**
-     * @var string
-     */
-    private $className;
-
-    /**
-     * @var string
-     */
-    private $methodName;
-
-    /**
-     * @var array
-     */
-    private $parameters;
-
-    /**
-     * @var string
-     */
-    private $returnType;
-
-    /**
-     * @var bool
-     */
-    private $isReturnTypeNullable = false;
-
-    /**
-     * @var bool
-     */
-    private $proxiedCall;
-
-    /**
-     * @var object
-     */
-    private $object;
-
-    public function __construct(string $className, string $methodName, array $parameters, string $returnType, object $object, bool $cloneObjects = false, bool $proxiedCall = false)
-    {
-        $this->className   = $className;
-        $this->methodName  = $methodName;
-        $this->parameters  = $parameters;
-        $this->object      = $object;
-        $this->proxiedCall = $proxiedCall;
-
-        if (strtolower($methodName) === '__tostring') {
-            $returnType = 'string';
-        }
-
-        if (strpos($returnType, '?') === 0) {
-            $returnType                 = substr($returnType, 1);
-            $this->isReturnTypeNullable = true;
-        }
-
-        $this->returnType = $returnType;
-
-        if (!$cloneObjects) {
-            return;
-        }
-
-        foreach ($this->parameters as $key => $value) {
-            if (is_object($value)) {
-                $this->parameters[$key] = Cloner::clone($value);
-            }
-        }
-    }
-
-    public function getClassName(): string
-    {
-        return $this->className;
-    }
-
-    public function getMethodName(): string
-    {
-        return $this->methodName;
-    }
-
-    public function getParameters(): array
-    {
-        return $this->parameters;
-    }
-
-    /**
-     * @throws RuntimeException
-     *
-     * @return mixed Mocked return value
-     */
-    public function generateReturnValue()
-    {
-        if ($this->isReturnTypeNullable || $this->proxiedCall) {
-            return null;
-        }
-
-        $intersection               = false;
-        $union                      = false;
-        $unionContainsIntersections = false;
-
-        if (strpos($this->returnType, '|') !== false) {
-            $types = explode('|', $this->returnType);
-            $union = true;
-
-            if (strpos($this->returnType, '(') !== false) {
-                $unionContainsIntersections = true;
-            }
-        } elseif (strpos($this->returnType, '&') !== false) {
-            $types        = explode('&', $this->returnType);
-            $intersection = true;
-        } else {
-            $types = [$this->returnType];
-        }
-
-        $types = array_map('strtolower', $types);
-
-        if (!$intersection && !$unionContainsIntersections) {
-            if (in_array('', $types, true) ||
-                in_array('null', $types, true) ||
-                in_array('mixed', $types, true) ||
-                in_array('void', $types, true)) {
-                return null;
-            }
-
-            if (in_array('true', $types, true)) {
-                return true;
-            }
-
-            if (in_array('false', $types, true) ||
-                in_array('bool', $types, true)) {
-                return false;
-            }
-
-            if (in_array('float', $types, true)) {
-                return 0.0;
-            }
-
-            if (in_array('int', $types, true)) {
-                return 0;
-            }
-
-            if (in_array('string', $types, true)) {
-                return '';
-            }
-
-            if (in_array('array', $types, true)) {
-                return [];
-            }
-
-            if (in_array('static', $types, true)) {
-                try {
-                    return (new Instantiator)->instantiate(get_class($this->object));
-                } catch (Throwable $t) {
-                    throw new RuntimeException(
-                        $t->getMessage(),
-                        (int) $t->getCode(),
-                        $t
-                    );
-                }
-            }
-
-            if (in_array('object', $types, true)) {
-                return new stdClass;
-            }
-
-            if (in_array('callable', $types, true) ||
-                in_array('closure', $types, true)) {
-                return static function (): void
-                {
-                };
-            }
-
-            if (in_array('traversable', $types, true) ||
-                in_array('generator', $types, true) ||
-                in_array('iterable', $types, true)) {
-                $generator = static function (): \Generator
-                {
-                    yield from [];
-                };
-
-                return $generator();
-            }
-
-            if (!$union) {
-                try {
-                    return (new Generator)->getMock($this->returnType, [], [], '', false);
-                } catch (Throwable $t) {
-                    if ($t instanceof Exception) {
-                        throw $t;
-                    }
-
-                    throw new RuntimeException(
-                        $t->getMessage(),
-                        (int) $t->getCode(),
-                        $t
-                    );
-                }
-            }
-        }
-
-        if ($intersection && $this->onlyInterfaces($types)) {
-            try {
-                return (new Generator)->getMockForInterfaces($types);
-            } catch (Throwable $t) {
-                throw new RuntimeException(
-                    sprintf(
-                        'Return value for %s::%s() cannot be generated: %s',
-                        $this->className,
-                        $this->methodName,
-                        $t->getMessage(),
-                    ),
-                    (int) $t->getCode(),
-                );
-            }
-        }
-
-        $reason = '';
-
-        if ($union) {
-            $reason = ' because the declared return type is a union';
-        } elseif ($intersection) {
-            $reason = ' because the declared return type is an intersection';
-        }
-
-        throw new RuntimeException(
-            sprintf(
-                'Return value for %s::%s() cannot be generated%s, please configure a return value for this method',
-                $this->className,
-                $this->methodName,
-                $reason
-            )
-        );
-    }
-
-    public function toString(): string
-    {
-        $exporter = new Exporter;
-
-        return sprintf(
-            '%s::%s(%s)%s',
-            $this->className,
-            $this->methodName,
-            implode(
-                ', ',
-                array_map(
-                    [$exporter, 'shortenedExport'],
-                    $this->parameters
-                )
-            ),
-            $this->returnType ? sprintf(': %s', $this->returnType) : ''
-        );
-    }
-
-    public function getObject(): object
-    {
-        return $this->object;
-    }
-
-    /**
-     * @psalm-param non-empty-list<string> $types
-     */
-    private function onlyInterfaces(array $types): bool
-    {
-        foreach ($types as $type) {
-            if (!interface_exists($type)) {
-                return false;
-            }
-        }
-
-        return true;
-    }
+	/**
+	 * @var string
+	 */
+	private $className;
+
+	/**
+	 * @var string
+	 */
+	private $methodName;
+
+	/**
+	 * @var array
+	 */
+	private $parameters;
+
+	/**
+	 * @var string
+	 */
+	private $returnType;
+
+	/**
+	 * @var bool
+	 */
+	private $isReturnTypeNullable = false;
+
+	/**
+	 * @var bool
+	 */
+	private $proxiedCall;
+
+	/**
+	 * @var object
+	 */
+	private $object;
+
+	public function __construct(string $className, string $methodName, array $parameters, string $returnType, object $object, bool $cloneObjects = false, bool $proxiedCall = false)
+	{
+		$this->className   = $className;
+		$this->methodName  = $methodName;
+		$this->parameters  = $parameters;
+		$this->object      = $object;
+		$this->proxiedCall = $proxiedCall;
+
+		if (strtolower($methodName) === '__tostring') {
+			$returnType = 'string';
+		}
+
+		if (strpos($returnType, '?') === 0) {
+			$returnType                 = substr($returnType, 1);
+			$this->isReturnTypeNullable = true;
+		}
+
+		$this->returnType = $returnType;
+
+		if (!$cloneObjects) {
+			return;
+		}
+
+		foreach ($this->parameters as $key => $value) {
+			if (is_object($value)) {
+				$this->parameters[$key] = Cloner::clone($value);
+			}
+		}
+	}
+
+	public function getClassName(): string
+	{
+		return $this->className;
+	}
+
+	public function getMethodName(): string
+	{
+		return $this->methodName;
+	}
+
+	public function getParameters(): array
+	{
+		return $this->parameters;
+	}
+
+	/**
+	 * @throws RuntimeException
+	 *
+	 * @return mixed Mocked return value
+	 */
+	public function generateReturnValue()
+	{
+		if ($this->isReturnTypeNullable || $this->proxiedCall) {
+			return null;
+		}
+
+		$intersection               = false;
+		$union                      = false;
+		$unionContainsIntersections = false;
+
+		if (strpos($this->returnType, '|') !== false) {
+			$types = explode('|', $this->returnType);
+			$union = true;
+
+			if (strpos($this->returnType, '(') !== false) {
+				$unionContainsIntersections = true;
+			}
+		} elseif (strpos($this->returnType, '&') !== false) {
+			$types        = explode('&', $this->returnType);
+			$intersection = true;
+		} else {
+			$types = [$this->returnType];
+		}
+
+		$types = array_map('strtolower', $types);
+
+		if (!$intersection && !$unionContainsIntersections) {
+			if (in_array('', $types, true) ||
+				in_array('null', $types, true) ||
+				in_array('mixed', $types, true) ||
+				in_array('void', $types, true)) {
+				return null;
+			}
+
+			if (in_array('true', $types, true)) {
+				return true;
+			}
+
+			if (in_array('false', $types, true) ||
+				in_array('bool', $types, true)) {
+				return false;
+			}
+
+			if (in_array('float', $types, true)) {
+				return 0.0;
+			}
+
+			if (in_array('int', $types, true)) {
+				return 0;
+			}
+
+			if (in_array('string', $types, true)) {
+				return '';
+			}
+
+			if (in_array('array', $types, true)) {
+				return [];
+			}
+
+			if (in_array('static', $types, true)) {
+				try {
+					return (new Instantiator)->instantiate(get_class($this->object));
+				} catch (Throwable $t) {
+					throw new RuntimeException(
+						$t->getMessage(),
+						(int) $t->getCode(),
+						$t
+					);
+				}
+			}
+
+			if (in_array('object', $types, true)) {
+				return new stdClass;
+			}
+
+			if (in_array('callable', $types, true) ||
+				in_array('closure', $types, true)) {
+				return static function (): void
+				{
+				};
+			}
+
+			if (in_array('traversable', $types, true) ||
+				in_array('generator', $types, true) ||
+				in_array('iterable', $types, true)) {
+				$generator = static function (): \Generator
+				{
+					yield from [];
+				};
+
+				return $generator();
+			}
+
+			if (!$union) {
+				try {
+					return (new Generator)->getMock($this->returnType, [], [], '', false);
+				} catch (Throwable $t) {
+					if ($t instanceof Exception) {
+						throw $t;
+					}
+
+					throw new RuntimeException(
+						$t->getMessage(),
+						(int) $t->getCode(),
+						$t
+					);
+				}
+			}
+		}
+
+		if ($intersection && $this->onlyInterfaces($types)) {
+			try {
+				return (new Generator)->getMockForInterfaces($types);
+			} catch (Throwable $t) {
+				throw new RuntimeException(
+					sprintf(
+						'Return value for %s::%s() cannot be generated: %s',
+						$this->className,
+						$this->methodName,
+						$t->getMessage(),
+					),
+					(int) $t->getCode(),
+				);
+			}
+		}
+
+		$reason = '';
+
+		if ($union) {
+			$reason = ' because the declared return type is a union';
+		} elseif ($intersection) {
+			$reason = ' because the declared return type is an intersection';
+		}
+
+		throw new RuntimeException(
+			sprintf(
+				'Return value for %s::%s() cannot be generated%s, please configure a return value for this method',
+				$this->className,
+				$this->methodName,
+				$reason
+			)
+		);
+	}
+
+	public function toString(): string
+	{
+		$exporter = new Exporter;
+
+		return sprintf(
+			'%s::%s(%s)%s',
+			$this->className,
+			$this->methodName,
+			implode(
+				', ',
+				array_map(
+					[$exporter, 'shortenedExport'],
+					$this->parameters
+				)
+			),
+			$this->returnType ? sprintf(': %s', $this->returnType) : ''
+		);
+	}
+
+	public function getObject(): object
+	{
+		return $this->object;
+	}
+
+	/**
+	 * @psalm-param non-empty-list<string> $types
+	 */
+	private function onlyInterfaces(array $types): bool
+	{
+		foreach ($types as $type) {
+			if (!interface_exists($type)) {
+				return false;
+			}
+		}
+
+		return true;
+	}
 }

Spacing +6 added lines, -6 removed lines

@@ -86,7 +86,7 @@ 
 
         $this->returnType = $returnType;
 
-        if (!$cloneObjects) {
+        if ( ! $cloneObjects) {
             return;
         }
 
@@ -143,7 +143,7 @@ 
 
         $types = array_map('strtolower', $types);
 
-        if (!$intersection && !$unionContainsIntersections) {
+        if ( ! $intersection && ! $unionContainsIntersections) {
             if (in_array('', $types, true) ||
                 in_array('null', $types, true) ||
                 in_array('mixed', $types, true) ||
@@ -194,7 +194,7 @@ 
 
             if (in_array('callable', $types, true) ||
                 in_array('closure', $types, true)) {
-                return static function (): void
+                return static function(): void
                 {
                 };
             }
@@ -202,7 +202,7 @@ 
             if (in_array('traversable', $types, true) ||
                 in_array('generator', $types, true) ||
                 in_array('iterable', $types, true)) {
-                $generator = static function (): \Generator
+                $generator = static function(): \Generator
                 {
                     yield from [];
                 };
@@ -210,7 +210,7 @@ 
                 return $generator();
             }
 
-            if (!$union) {
+            if ( ! $union) {
                 try {
                     return (new Generator)->getMock($this->returnType, [], [], '', false);
                 } catch (Throwable $t) {
@@ -291,7 +291,7 @@ 
     private function onlyInterfaces(array $types): bool
     {
         foreach ($types as $type) {
-            if (!interface_exists($type)) {
+            if ( ! interface_exists($type)) {
                 return false;
             }
         }

vendor/phpunit/phpunit/src/Framework/MockObject/Generator.php

Indentation +1042 added lines, -1042 removed lines

@@ -60,7 +60,7 @@ 
  */
 final class Generator
 {
-    private const MOCKED_CLONE_METHOD_WITH_VOID_RETURN_TYPE_TRAIT = <<<'EOT'
+	private const MOCKED_CLONE_METHOD_WITH_VOID_RETURN_TYPE_TRAIT = <<<'EOT'
 namespace PHPUnit\Framework\MockObject;
 
 trait MockedCloneMethodWithVoidReturnType
@@ -72,7 +72,7 @@ 
 }
 EOT;
 
-    private const MOCKED_CLONE_METHOD_WITHOUT_RETURN_TYPE_TRAIT = <<<'EOT'
+	private const MOCKED_CLONE_METHOD_WITHOUT_RETURN_TYPE_TRAIT = <<<'EOT'
 namespace PHPUnit\Framework\MockObject;
 
 trait MockedCloneMethodWithoutReturnType
@@ -84,7 +84,7 @@ 
 }
 EOT;
 
-    private const UNMOCKED_CLONE_METHOD_WITH_VOID_RETURN_TYPE_TRAIT = <<<'EOT'
+	private const UNMOCKED_CLONE_METHOD_WITH_VOID_RETURN_TYPE_TRAIT = <<<'EOT'
 namespace PHPUnit\Framework\MockObject;
 
 trait UnmockedCloneMethodWithVoidReturnType
@@ -98,7 +98,7 @@ 
 }
 EOT;
 
-    private const UNMOCKED_CLONE_METHOD_WITHOUT_RETURN_TYPE_TRAIT = <<<'EOT'
+	private const UNMOCKED_CLONE_METHOD_WITHOUT_RETURN_TYPE_TRAIT = <<<'EOT'
 namespace PHPUnit\Framework\MockObject;
 
 trait UnmockedCloneMethodWithoutReturnType
@@ -112,1042 +112,1042 @@ 
 }
 EOT;
 
-    /**
-     * @var array
-     */
-    private const EXCLUDED_METHOD_NAMES = [
-        '__CLASS__'       => true,
-        '__DIR__'         => true,
-        '__FILE__'        => true,
-        '__FUNCTION__'    => true,
-        '__LINE__'        => true,
-        '__METHOD__'      => true,
-        '__NAMESPACE__'   => true,
-        '__TRAIT__'       => true,
-        '__clone'         => true,
-        '__halt_compiler' => true,
-    ];
-
-    /**
-     * @var array
-     */
-    private static $cache = [];
-
-    /**
-     * @var Template[]
-     */
-    private static $templates = [];
-
-    /**
-     * Returns a mock object for the specified class.
-     *
-     * @param null|array $methods
-     *
-     * @throws \PHPUnit\Framework\InvalidArgumentException
-     * @throws ClassAlreadyExistsException
-     * @throws ClassIsFinalException
-     * @throws DuplicateMethodException
-     * @throws InvalidMethodNameException
-     * @throws OriginalConstructorInvocationRequiredException
-     * @throws ReflectionException
-     * @throws RuntimeException
-     * @throws UnknownTypeException
-     */
-    public function getMock(string $type, $methods = [], array $arguments = [], string $mockClassName = '', bool $callOriginalConstructor = true, bool $callOriginalClone = true, bool $callAutoload = true, bool $cloneArguments = true, bool $callOriginalMethods = false, object $proxyTarget = null, bool $allowMockingUnknownTypes = true, bool $returnValueGeneration = true): MockObject
-    {
-        if (!is_array($methods) && null !== $methods) {
-            throw InvalidArgumentException::create(2, 'array');
-        }
-
-        if ($type === 'Traversable' || $type === '\\Traversable') {
-            $type = 'Iterator';
-        }
-
-        if (!$allowMockingUnknownTypes && !class_exists($type, $callAutoload) && !interface_exists($type, $callAutoload)) {
-            throw new UnknownTypeException($type);
-        }
-
-        if (null !== $methods) {
-            foreach ($methods as $method) {
-                if (!preg_match('~[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*~', (string) $method)) {
-                    throw new InvalidMethodNameException((string) $method);
-                }
-            }
-
-            if ($methods !== array_unique($methods)) {
-                throw new DuplicateMethodException($methods);
-            }
-        }
-
-        if ($mockClassName !== '' && class_exists($mockClassName, false)) {
-            try {
-                $reflector = new ReflectionClass($mockClassName);
-                // @codeCoverageIgnoreStart
-            } catch (\ReflectionException $e) {
-                throw new ReflectionException(
-                    $e->getMessage(),
-                    (int) $e->getCode(),
-                    $e
-                );
-            }
-            // @codeCoverageIgnoreEnd
-
-            if (!$reflector->implementsInterface(MockObject::class)) {
-                throw new ClassAlreadyExistsException($mockClassName);
-            }
-        }
-
-        if (!$callOriginalConstructor && $callOriginalMethods) {
-            throw new OriginalConstructorInvocationRequiredException;
-        }
-
-        $mock = $this->generate(
-            $type,
-            $methods,
-            $mockClassName,
-            $callOriginalClone,
-            $callAutoload,
-            $cloneArguments,
-            $callOriginalMethods
-        );
-
-        return $this->getObject(
-            $mock,
-            $type,
-            $callOriginalConstructor,
-            $callAutoload,
-            $arguments,
-            $callOriginalMethods,
-            $proxyTarget,
-            $returnValueGeneration
-        );
-    }
-
-    /**
-     * @psalm-param list<class-string> $interfaces
-     *
-     * @throws RuntimeException
-     * @throws UnknownTypeException
-     */
-    public function getMockForInterfaces(array $interfaces, bool $callAutoload = true): MockObject
-    {
-        if (count($interfaces) < 2) {
-            throw new RuntimeException('At least two interfaces must be specified');
-        }
-
-        foreach ($interfaces as $interface) {
-            if (!interface_exists($interface, $callAutoload)) {
-                throw new UnknownTypeException($interface);
-            }
-        }
-
-        sort($interfaces);
-
-        $methods = [];
-
-        foreach ($interfaces as $interface) {
-            $methods = array_merge($methods, $this->getClassMethods($interface));
-        }
-
-        if (count(array_unique($methods)) < count($methods)) {
-            throw new RuntimeException('Interfaces must not declare the same method');
-        }
-
-        $unqualifiedNames = [];
-
-        foreach ($interfaces as $interface) {
-            $parts              = explode('\\', $interface);
-            $unqualifiedNames[] = array_pop($parts);
-        }
-
-        sort($unqualifiedNames);
-
-        do {
-            $intersectionName = sprintf(
-                'Intersection_%s_%s',
-                implode('_', $unqualifiedNames),
-                substr(md5((string) mt_rand()), 0, 8)
-            );
-        } while (interface_exists($intersectionName, false));
-
-        $template = $this->getTemplate('intersection.tpl');
-
-        $template->setVar(
-            [
-                'intersection' => $intersectionName,
-                'interfaces'   => implode(', ', $interfaces),
-            ]
-        );
-
-        eval($template->render());
-
-        return $this->getMock($intersectionName);
-    }
-
-    /**
-     * Returns a mock object for the specified abstract class with all abstract
-     * methods of the class mocked.
-     *
-     * Concrete methods to mock can be specified with the $mockedMethods parameter.
-     *
-     * @psalm-template RealInstanceType of object
-     *
-     * @psalm-param class-string<RealInstanceType> $originalClassName
-     *
-     * @psalm-return MockObject&RealInstanceType
-     *
-     * @throws \PHPUnit\Framework\InvalidArgumentException
-     * @throws ClassAlreadyExistsException
-     * @throws ClassIsFinalException
-     * @throws DuplicateMethodException
-     * @throws InvalidMethodNameException
-     * @throws OriginalConstructorInvocationRequiredException
-     * @throws ReflectionException
-     * @throws RuntimeException
-     * @throws UnknownClassException
-     * @throws UnknownTypeException
-     */
-    public function getMockForAbstractClass(string $originalClassName, array $arguments = [], string $mockClassName = '', bool $callOriginalConstructor = true, bool $callOriginalClone = true, bool $callAutoload = true, array $mockedMethods = null, bool $cloneArguments = true): MockObject
-    {
-        if (class_exists($originalClassName, $callAutoload) ||
-            interface_exists($originalClassName, $callAutoload)) {
-            try {
-                $reflector = new ReflectionClass($originalClassName);
-                // @codeCoverageIgnoreStart
-            } catch (\ReflectionException $e) {
-                throw new ReflectionException(
-                    $e->getMessage(),
-                    (int) $e->getCode(),
-                    $e
-                );
-            }
-            // @codeCoverageIgnoreEnd
-
-            $methods = $mockedMethods;
-
-            foreach ($reflector->getMethods() as $method) {
-                if ($method->isAbstract() && !in_array($method->getName(), $methods ?? [], true)) {
-                    $methods[] = $method->getName();
-                }
-            }
-
-            if (empty($methods)) {
-                $methods = null;
-            }
-
-            return $this->getMock(
-                $originalClassName,
-                $methods,
-                $arguments,
-                $mockClassName,
-                $callOriginalConstructor,
-                $callOriginalClone,
-                $callAutoload,
-                $cloneArguments
-            );
-        }
-
-        throw new UnknownClassException($originalClassName);
-    }
-
-    /**
-     * Returns a mock object for the specified trait with all abstract methods
-     * of the trait mocked. Concrete methods to mock can be specified with the
-     * `$mockedMethods` parameter.
-     *
-     * @psalm-param trait-string $traitName
-     *
-     * @throws \PHPUnit\Framework\InvalidArgumentException
-     * @throws ClassAlreadyExistsException
-     * @throws ClassIsFinalException
-     * @throws DuplicateMethodException
-     * @throws InvalidMethodNameException
-     * @throws OriginalConstructorInvocationRequiredException
-     * @throws ReflectionException
-     * @throws RuntimeException
-     * @throws UnknownClassException
-     * @throws UnknownTraitException
-     * @throws UnknownTypeException
-     */
-    public function getMockForTrait(string $traitName, array $arguments = [], string $mockClassName = '', bool $callOriginalConstructor = true, bool $callOriginalClone = true, bool $callAutoload = true, array $mockedMethods = null, bool $cloneArguments = true): MockObject
-    {
-        if (!trait_exists($traitName, $callAutoload)) {
-            throw new UnknownTraitException($traitName);
-        }
-
-        $className = $this->generateClassName(
-            $traitName,
-            '',
-            'Trait_'
-        );
-
-        $classTemplate = $this->getTemplate('trait_class.tpl');
-
-        $classTemplate->setVar(
-            [
-                'prologue'   => 'abstract ',
-                'class_name' => $className['className'],
-                'trait_name' => $traitName,
-            ]
-        );
-
-        $mockTrait = new MockTrait($classTemplate->render(), $className['className']);
-        $mockTrait->generate();
-
-        return $this->getMockForAbstractClass($className['className'], $arguments, $mockClassName, $callOriginalConstructor, $callOriginalClone, $callAutoload, $mockedMethods, $cloneArguments);
-    }
-
-    /**
-     * Returns an object for the specified trait.
-     *
-     * @psalm-param trait-string $traitName
-     *
-     * @throws ReflectionException
-     * @throws RuntimeException
-     * @throws UnknownTraitException
-     */
-    public function getObjectForTrait(string $traitName, string $traitClassName = '', bool $callAutoload = true, bool $callOriginalConstructor = false, array $arguments = []): object
-    {
-        if (!trait_exists($traitName, $callAutoload)) {
-            throw new UnknownTraitException($traitName);
-        }
-
-        $className = $this->generateClassName(
-            $traitName,
-            $traitClassName,
-            'Trait_'
-        );
-
-        $classTemplate = $this->getTemplate('trait_class.tpl');
-
-        $classTemplate->setVar(
-            [
-                'prologue'   => '',
-                'class_name' => $className['className'],
-                'trait_name' => $traitName,
-            ]
-        );
-
-        return $this->getObject(
-            new MockTrait(
-                $classTemplate->render(),
-                $className['className']
-            ),
-            '',
-            $callOriginalConstructor,
-            $callAutoload,
-            $arguments
-        );
-    }
-
-    /**
-     * @throws ClassIsFinalException
-     * @throws ReflectionException
-     * @throws RuntimeException
-     */
-    public function generate(string $type, array $methods = null, string $mockClassName = '', bool $callOriginalClone = true, bool $callAutoload = true, bool $cloneArguments = true, bool $callOriginalMethods = false): MockClass
-    {
-        if ($mockClassName !== '') {
-            return $this->generateMock(
-                $type,
-                $methods,
-                $mockClassName,
-                $callOriginalClone,
-                $callAutoload,
-                $cloneArguments,
-                $callOriginalMethods
-            );
-        }
-
-        $key = md5(
-            $type .
-            serialize($methods) .
-            serialize($callOriginalClone) .
-            serialize($cloneArguments) .
-            serialize($callOriginalMethods)
-        );
-
-        if (!isset(self::$cache[$key])) {
-            self::$cache[$key] = $this->generateMock(
-                $type,
-                $methods,
-                $mockClassName,
-                $callOriginalClone,
-                $callAutoload,
-                $cloneArguments,
-                $callOriginalMethods
-            );
-        }
-
-        return self::$cache[$key];
-    }
-
-    /**
-     * @throws RuntimeException
-     * @throws SoapExtensionNotAvailableException
-     */
-    public function generateClassFromWsdl(string $wsdlFile, string $className, array $methods = [], array $options = []): string
-    {
-        if (!extension_loaded('soap')) {
-            throw new SoapExtensionNotAvailableException;
-        }
-
-        $options = array_merge($options, ['cache_wsdl' => WSDL_CACHE_NONE]);
-
-        try {
-            $client   = new SoapClient($wsdlFile, $options);
-            $_methods = array_unique($client->__getFunctions());
-            unset($client);
-        } catch (SoapFault $e) {
-            throw new RuntimeException(
-                $e->getMessage(),
-                (int) $e->getCode(),
-                $e
-            );
-        }
-
-        sort($_methods);
-
-        $methodTemplate = $this->getTemplate('wsdl_method.tpl');
-        $methodsBuffer  = '';
-
-        foreach ($_methods as $method) {
-            preg_match_all('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*\(/', $method, $matches, PREG_OFFSET_CAPTURE);
-            $lastFunction = array_pop($matches[0]);
-            $nameStart    = $lastFunction[1];
-            $nameEnd      = $nameStart + strlen($lastFunction[0]) - 1;
-            $name         = str_replace('(', '', $lastFunction[0]);
-
-            if (empty($methods) || in_array($name, $methods, true)) {
-                $args = explode(
-                    ',',
-                    str_replace(')', '', substr($method, $nameEnd + 1))
-                );
-
-                foreach (range(0, count($args) - 1) as $i) {
-                    $parameterStart = strpos($args[$i], '$');
-
-                    if (!$parameterStart) {
-                        continue;
-                    }
-
-                    $args[$i] = substr($args[$i], $parameterStart);
-                }
-
-                $methodTemplate->setVar(
-                    [
-                        'method_name' => $name,
-                        'arguments'   => implode(', ', $args),
-                    ]
-                );
-
-                $methodsBuffer .= $methodTemplate->render();
-            }
-        }
-
-        $optionsBuffer = '[';
-
-        foreach ($options as $key => $value) {
-            $optionsBuffer .= $key . ' => ' . $value;
-        }
-
-        $optionsBuffer .= ']';
-
-        $classTemplate = $this->getTemplate('wsdl_class.tpl');
-        $namespace     = '';
-
-        if (strpos($className, '\\') !== false) {
-            $parts     = explode('\\', $className);
-            $className = array_pop($parts);
-            $namespace = 'namespace ' . implode('\\', $parts) . ';' . "\n\n";
-        }
-
-        $classTemplate->setVar(
-            [
-                'namespace'  => $namespace,
-                'class_name' => $className,
-                'wsdl'       => $wsdlFile,
-                'options'    => $optionsBuffer,
-                'methods'    => $methodsBuffer,
-            ]
-        );
-
-        return $classTemplate->render();
-    }
-
-    /**
-     * @throws ReflectionException
-     *
-     * @return string[]
-     */
-    public function getClassMethods(string $className): array
-    {
-        try {
-            $class = new ReflectionClass($className);
-            // @codeCoverageIgnoreStart
-        } catch (\ReflectionException $e) {
-            throw new ReflectionException(
-                $e->getMessage(),
-                (int) $e->getCode(),
-                $e
-            );
-        }
-        // @codeCoverageIgnoreEnd
-
-        $methods = [];
-
-        foreach ($class->getMethods() as $method) {
-            if ($method->isPublic() || $method->isAbstract()) {
-                $methods[] = $method->getName();
-            }
-        }
-
-        return $methods;
-    }
-
-    /**
-     * @throws ReflectionException
-     *
-     * @return MockMethod[]
-     */
-    public function mockClassMethods(string $className, bool $callOriginalMethods, bool $cloneArguments): array
-    {
-        try {
-            $class = new ReflectionClass($className);
-            // @codeCoverageIgnoreStart
-        } catch (\ReflectionException $e) {
-            throw new ReflectionException(
-                $e->getMessage(),
-                (int) $e->getCode(),
-                $e
-            );
-        }
-        // @codeCoverageIgnoreEnd
-
-        $methods = [];
-
-        foreach ($class->getMethods() as $method) {
-            if (($method->isPublic() || $method->isAbstract()) && $this->canMockMethod($method)) {
-                $methods[] = MockMethod::fromReflection($method, $callOriginalMethods, $cloneArguments);
-            }
-        }
-
-        return $methods;
-    }
-
-    /**
-     * @throws ReflectionException
-     *
-     * @return MockMethod[]
-     */
-    public function mockInterfaceMethods(string $interfaceName, bool $cloneArguments): array
-    {
-        try {
-            $class = new ReflectionClass($interfaceName);
-            // @codeCoverageIgnoreStart
-        } catch (\ReflectionException $e) {
-            throw new ReflectionException(
-                $e->getMessage(),
-                (int) $e->getCode(),
-                $e
-            );
-        }
-        // @codeCoverageIgnoreEnd
-
-        $methods = [];
-
-        foreach ($class->getMethods() as $method) {
-            $methods[] = MockMethod::fromReflection($method, false, $cloneArguments);
-        }
-
-        return $methods;
-    }
-
-    /**
-     * @psalm-param class-string $interfaceName
-     *
-     * @throws ReflectionException
-     *
-     * @return ReflectionMethod[]
-     */
-    private function userDefinedInterfaceMethods(string $interfaceName): array
-    {
-        try {
-            // @codeCoverageIgnoreStart
-            $interface = new ReflectionClass($interfaceName);
-        } catch (\ReflectionException $e) {
-            throw new ReflectionException(
-                $e->getMessage(),
-                (int) $e->getCode(),
-                $e
-            );
-        }
-        // @codeCoverageIgnoreEnd
-
-        $methods = [];
-
-        foreach ($interface->getMethods() as $method) {
-            if (!$method->isUserDefined()) {
-                continue;
-            }
-
-            $methods[] = $method;
-        }
-
-        return $methods;
-    }
-
-    /**
-     * @throws ReflectionException
-     * @throws RuntimeException
-     */
-    private function getObject(MockType $mockClass, $type = '', bool $callOriginalConstructor = false, bool $callAutoload = false, array $arguments = [], bool $callOriginalMethods = false, object $proxyTarget = null, bool $returnValueGeneration = true)
-    {
-        $className = $mockClass->generate();
-
-        if ($callOriginalConstructor) {
-            if (count($arguments) === 0) {
-                $object = new $className;
-            } else {
-                try {
-                    $class = new ReflectionClass($className);
-                    // @codeCoverageIgnoreStart
-                } catch (\ReflectionException $e) {
-                    throw new ReflectionException(
-                        $e->getMessage(),
-                        (int) $e->getCode(),
-                        $e
-                    );
-                }
-                // @codeCoverageIgnoreEnd
-
-                $object = $class->newInstanceArgs($arguments);
-            }
-        } else {
-            try {
-                $object = (new Instantiator)->instantiate($className);
-            } catch (InstantiatorException $e) {
-                throw new RuntimeException($e->getMessage());
-            }
-        }
-
-        if ($callOriginalMethods) {
-            if (!is_object($proxyTarget)) {
-                if (count($arguments) === 0) {
-                    $proxyTarget = new $type;
-                } else {
-                    try {
-                        $class = new ReflectionClass($type);
-                        // @codeCoverageIgnoreStart
-                    } catch (\ReflectionException $e) {
-                        throw new ReflectionException(
-                            $e->getMessage(),
-                            (int) $e->getCode(),
-                            $e
-                        );
-                    }
-                    // @codeCoverageIgnoreEnd
-
-                    $proxyTarget = $class->newInstanceArgs($arguments);
-                }
-            }
-
-            $object->__phpunit_setOriginalObject($proxyTarget);
-        }
-
-        if ($object instanceof MockObject) {
-            $object->__phpunit_setReturnValueGeneration($returnValueGeneration);
-        }
-
-        return $object;
-    }
-
-    /**
-     * @throws ClassIsFinalException
-     * @throws ReflectionException
-     * @throws RuntimeException
-     */
-    private function generateMock(string $type, ?array $explicitMethods, string $mockClassName, bool $callOriginalClone, bool $callAutoload, bool $cloneArguments, bool $callOriginalMethods): MockClass
-    {
-        $classTemplate        = $this->getTemplate('mocked_class.tpl');
-        $additionalInterfaces = [];
-        $mockedCloneMethod    = false;
-        $unmockedCloneMethod  = false;
-        $isClass              = false;
-        $isInterface          = false;
-        $class                = null;
-        $mockMethods          = new MockMethodSet;
-
-        $_mockClassName = $this->generateClassName(
-            $type,
-            $mockClassName,
-            'Mock_'
-        );
-
-        if (class_exists($_mockClassName['fullClassName'], $callAutoload)) {
-            $isClass = true;
-        } elseif (interface_exists($_mockClassName['fullClassName'], $callAutoload)) {
-            $isInterface = true;
-        }
-
-        if (!$isClass && !$isInterface) {
-            $prologue = 'class ' . $_mockClassName['originalClassName'] . "\n{\n}\n\n";
-
-            if (!empty($_mockClassName['namespaceName'])) {
-                $prologue = 'namespace ' . $_mockClassName['namespaceName'] .
-                            " {\n\n" . $prologue . "}\n\n" .
-                            "namespace {\n\n";
-
-                $epilogue = "\n\n}";
-            }
-
-            $mockedCloneMethod = true;
-        } else {
-            try {
-                $class = new ReflectionClass($_mockClassName['fullClassName']);
-                // @codeCoverageIgnoreStart
-            } catch (\ReflectionException $e) {
-                throw new ReflectionException(
-                    $e->getMessage(),
-                    (int) $e->getCode(),
-                    $e
-                );
-            }
-            // @codeCoverageIgnoreEnd
-
-            if ($class->isFinal()) {
-                throw new ClassIsFinalException($_mockClassName['fullClassName']);
-            }
-
-            // @see https://github.com/sebastianbergmann/phpunit/issues/2995
-            if ($isInterface && $class->implementsInterface(Throwable::class)) {
-                $actualClassName        = Exception::class;
-                $additionalInterfaces[] = $class->getName();
-                $isInterface            = false;
-
-                try {
-                    $class = new ReflectionClass($actualClassName);
-                    // @codeCoverageIgnoreStart
-                } catch (\ReflectionException $e) {
-                    throw new ReflectionException(
-                        $e->getMessage(),
-                        (int) $e->getCode(),
-                        $e
-                    );
-                }
-                // @codeCoverageIgnoreEnd
-
-                foreach ($this->userDefinedInterfaceMethods($_mockClassName['fullClassName']) as $method) {
-                    $methodName = $method->getName();
-
-                    if ($class->hasMethod($methodName)) {
-                        try {
-                            $classMethod = $class->getMethod($methodName);
-                            // @codeCoverageIgnoreStart
-                        } catch (\ReflectionException $e) {
-                            throw new ReflectionException(
-                                $e->getMessage(),
-                                (int) $e->getCode(),
-                                $e
-                            );
-                        }
-                        // @codeCoverageIgnoreEnd
-
-                        if (!$this->canMockMethod($classMethod)) {
-                            continue;
-                        }
-                    }
-
-                    $mockMethods->addMethods(
-                        MockMethod::fromReflection($method, $callOriginalMethods, $cloneArguments)
-                    );
-                }
-
-                $_mockClassName = $this->generateClassName(
-                    $actualClassName,
-                    $_mockClassName['className'],
-                    'Mock_'
-                );
-            }
-
-            // @see https://github.com/sebastianbergmann/phpunit-mock-objects/issues/103
-            if ($isInterface && $class->implementsInterface(Traversable::class) &&
-                !$class->implementsInterface(Iterator::class) &&
-                !$class->implementsInterface(IteratorAggregate::class)) {
-                $additionalInterfaces[] = Iterator::class;
-
-                $mockMethods->addMethods(
-                    ...$this->mockClassMethods(Iterator::class, $callOriginalMethods, $cloneArguments)
-                );
-            }
-
-            if ($class->hasMethod('__clone')) {
-                try {
-                    $cloneMethod = $class->getMethod('__clone');
-                    // @codeCoverageIgnoreStart
-                } catch (\ReflectionException $e) {
-                    throw new ReflectionException(
-                        $e->getMessage(),
-                        (int) $e->getCode(),
-                        $e
-                    );
-                }
-                // @codeCoverageIgnoreEnd
-
-                if (!$cloneMethod->isFinal()) {
-                    if ($callOriginalClone && !$isInterface) {
-                        $unmockedCloneMethod = true;
-                    } else {
-                        $mockedCloneMethod = true;
-                    }
-                }
-            } else {
-                $mockedCloneMethod = true;
-            }
-        }
-
-        if ($isClass && $explicitMethods === []) {
-            $mockMethods->addMethods(
-                ...$this->mockClassMethods($_mockClassName['fullClassName'], $callOriginalMethods, $cloneArguments)
-            );
-        }
-
-        if ($isInterface && ($explicitMethods === [] || $explicitMethods === null)) {
-            $mockMethods->addMethods(
-                ...$this->mockInterfaceMethods($_mockClassName['fullClassName'], $cloneArguments)
-            );
-        }
-
-        if (is_array($explicitMethods)) {
-            foreach ($explicitMethods as $methodName) {
-                if ($class !== null && $class->hasMethod($methodName)) {
-                    try {
-                        $method = $class->getMethod($methodName);
-                        // @codeCoverageIgnoreStart
-                    } catch (\ReflectionException $e) {
-                        throw new ReflectionException(
-                            $e->getMessage(),
-                            (int) $e->getCode(),
-                            $e
-                        );
-                    }
-                    // @codeCoverageIgnoreEnd
-
-                    if ($this->canMockMethod($method)) {
-                        $mockMethods->addMethods(
-                            MockMethod::fromReflection($method, $callOriginalMethods, $cloneArguments)
-                        );
-                    }
-                } else {
-                    $mockMethods->addMethods(
-                        MockMethod::fromName(
-                            $_mockClassName['fullClassName'],
-                            $methodName,
-                            $cloneArguments
-                        )
-                    );
-                }
-            }
-        }
-
-        $mockedMethods = '';
-        $configurable  = [];
-
-        foreach ($mockMethods->asArray() as $mockMethod) {
-            $mockedMethods .= $mockMethod->generateCode();
-            $configurable[] = new ConfigurableMethod($mockMethod->getName(), $mockMethod->getReturnType());
-        }
-
-        $method = '';
-
-        if (!$mockMethods->hasMethod('method') && (!isset($class) || !$class->hasMethod('method'))) {
-            $method = PHP_EOL . '    use \PHPUnit\Framework\MockObject\Method;';
-        }
-
-        $cloneTrait = '';
-
-        if ($mockedCloneMethod) {
-            $cloneTrait = $this->mockedCloneMethod();
-        }
-
-        if ($unmockedCloneMethod) {
-            $cloneTrait = $this->unmockedCloneMethod();
-        }
-
-        $classTemplate->setVar(
-            [
-                'prologue'          => $prologue ?? '',
-                'epilogue'          => $epilogue ?? '',
-                'class_declaration' => $this->generateMockClassDeclaration(
-                    $_mockClassName,
-                    $isInterface,
-                    $additionalInterfaces
-                ),
-                'clone'           => $cloneTrait,
-                'mock_class_name' => $_mockClassName['className'],
-                'mocked_methods'  => $mockedMethods,
-                'method'          => $method,
-            ]
-        );
-
-        return new MockClass(
-            $classTemplate->render(),
-            $_mockClassName['className'],
-            $configurable
-        );
-    }
-
-    private function generateClassName(string $type, string $className, string $prefix): array
-    {
-        if ($type[0] === '\\') {
-            $type = substr($type, 1);
-        }
-
-        $classNameParts = explode('\\', $type);
-
-        if (count($classNameParts) > 1) {
-            $type          = array_pop($classNameParts);
-            $namespaceName = implode('\\', $classNameParts);
-            $fullClassName = $namespaceName . '\\' . $type;
-        } else {
-            $namespaceName = '';
-            $fullClassName = $type;
-        }
-
-        if ($className === '') {
-            do {
-                $className = $prefix . $type . '_' .
-                             substr(md5((string) mt_rand()), 0, 8);
-            } while (class_exists($className, false));
-        }
-
-        return [
-            'className'         => $className,
-            'originalClassName' => $type,
-            'fullClassName'     => $fullClassName,
-            'namespaceName'     => $namespaceName,
-        ];
-    }
-
-    private function generateMockClassDeclaration(array $mockClassName, bool $isInterface, array $additionalInterfaces = []): string
-    {
-        $buffer = 'class ';
-
-        $additionalInterfaces[] = MockObject::class;
-        $interfaces             = implode(', ', $additionalInterfaces);
-
-        if ($isInterface) {
-            $buffer .= sprintf(
-                '%s implements %s',
-                $mockClassName['className'],
-                $interfaces
-            );
-
-            if (!in_array($mockClassName['originalClassName'], $additionalInterfaces, true)) {
-                $buffer .= ', ';
-
-                if (!empty($mockClassName['namespaceName'])) {
-                    $buffer .= $mockClassName['namespaceName'] . '\\';
-                }
-
-                $buffer .= $mockClassName['originalClassName'];
-            }
-        } else {
-            $buffer .= sprintf(
-                '%s extends %s%s implements %s',
-                $mockClassName['className'],
-                !empty($mockClassName['namespaceName']) ? $mockClassName['namespaceName'] . '\\' : '',
-                $mockClassName['originalClassName'],
-                $interfaces
-            );
-        }
-
-        return $buffer;
-    }
-
-    private function canMockMethod(ReflectionMethod $method): bool
-    {
-        return !($this->isConstructor($method) || $method->isFinal() || $method->isPrivate() || $this->isMethodNameExcluded($method->getName()));
-    }
-
-    private function isMethodNameExcluded(string $name): bool
-    {
-        return isset(self::EXCLUDED_METHOD_NAMES[$name]);
-    }
-
-    /**
-     * @throws RuntimeException
-     */
-    private function getTemplate(string $template): Template
-    {
-        $filename = __DIR__ . DIRECTORY_SEPARATOR . 'Generator' . DIRECTORY_SEPARATOR . $template;
-
-        if (!isset(self::$templates[$filename])) {
-            try {
-                self::$templates[$filename] = new Template($filename);
-            } catch (TemplateException $e) {
-                throw new RuntimeException(
-                    $e->getMessage(),
-                    (int) $e->getCode(),
-                    $e
-                );
-            }
-        }
-
-        return self::$templates[$filename];
-    }
-
-    /**
-     * @see https://github.com/sebastianbergmann/phpunit/issues/4139#issuecomment-605409765
-     */
-    private function isConstructor(ReflectionMethod $method): bool
-    {
-        $methodName = strtolower($method->getName());
-
-        if ($methodName === '__construct') {
-            return true;
-        }
-
-        if (PHP_MAJOR_VERSION >= 8) {
-            return false;
-        }
-
-        $className = strtolower($method->getDeclaringClass()->getName());
-
-        return $methodName === $className;
-    }
-
-    private function mockedCloneMethod(): string
-    {
-        if (PHP_MAJOR_VERSION >= 8) {
-            if (!trait_exists('\PHPUnit\Framework\MockObject\MockedCloneMethodWithVoidReturnType')) {
-                eval(self::MOCKED_CLONE_METHOD_WITH_VOID_RETURN_TYPE_TRAIT);
-            }
-
-            return PHP_EOL . '    use \PHPUnit\Framework\MockObject\MockedCloneMethodWithVoidReturnType;';
-        }
-
-        if (!trait_exists('\PHPUnit\Framework\MockObject\MockedCloneMethodWithoutReturnType')) {
-            eval(self::MOCKED_CLONE_METHOD_WITHOUT_RETURN_TYPE_TRAIT);
-        }
-
-        return PHP_EOL . '    use \PHPUnit\Framework\MockObject\MockedCloneMethodWithoutReturnType;';
-    }
-
-    private function unmockedCloneMethod(): string
-    {
-        if (PHP_MAJOR_VERSION >= 8) {
-            if (!trait_exists('\PHPUnit\Framework\MockObject\UnmockedCloneMethodWithVoidReturnType')) {
-                eval(self::UNMOCKED_CLONE_METHOD_WITH_VOID_RETURN_TYPE_TRAIT);
-            }
-
-            return PHP_EOL . '    use \PHPUnit\Framework\MockObject\UnmockedCloneMethodWithVoidReturnType;';
-        }
-
-        if (!trait_exists('\PHPUnit\Framework\MockObject\UnmockedCloneMethodWithoutReturnType')) {
-            eval(self::UNMOCKED_CLONE_METHOD_WITHOUT_RETURN_TYPE_TRAIT);
-        }
-
-        return PHP_EOL . '    use \PHPUnit\Framework\MockObject\UnmockedCloneMethodWithoutReturnType;';
-    }
+	/**
+	 * @var array
+	 */
+	private const EXCLUDED_METHOD_NAMES = [
+		'__CLASS__'       => true,
+		'__DIR__'         => true,
+		'__FILE__'        => true,
+		'__FUNCTION__'    => true,
+		'__LINE__'        => true,
+		'__METHOD__'      => true,
+		'__NAMESPACE__'   => true,
+		'__TRAIT__'       => true,
+		'__clone'         => true,
+		'__halt_compiler' => true,
+	];
+
+	/**
+	 * @var array
+	 */
+	private static $cache = [];
+
+	/**
+	 * @var Template[]
+	 */
+	private static $templates = [];
+
+	/**
+	 * Returns a mock object for the specified class.
+	 *
+	 * @param null|array $methods
+	 *
+	 * @throws \PHPUnit\Framework\InvalidArgumentException
+	 * @throws ClassAlreadyExistsException
+	 * @throws ClassIsFinalException
+	 * @throws DuplicateMethodException
+	 * @throws InvalidMethodNameException
+	 * @throws OriginalConstructorInvocationRequiredException
+	 * @throws ReflectionException
+	 * @throws RuntimeException
+	 * @throws UnknownTypeException
+	 */
+	public function getMock(string $type, $methods = [], array $arguments = [], string $mockClassName = '', bool $callOriginalConstructor = true, bool $callOriginalClone = true, bool $callAutoload = true, bool $cloneArguments = true, bool $callOriginalMethods = false, object $proxyTarget = null, bool $allowMockingUnknownTypes = true, bool $returnValueGeneration = true): MockObject
+	{
+		if (!is_array($methods) && null !== $methods) {
+			throw InvalidArgumentException::create(2, 'array');
+		}
+
+		if ($type === 'Traversable' || $type === '\\Traversable') {
+			$type = 'Iterator';
+		}
+
+		if (!$allowMockingUnknownTypes && !class_exists($type, $callAutoload) && !interface_exists($type, $callAutoload)) {
+			throw new UnknownTypeException($type);
+		}
+
+		if (null !== $methods) {
+			foreach ($methods as $method) {
+				if (!preg_match('~[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*~', (string) $method)) {
+					throw new InvalidMethodNameException((string) $method);
+				}
+			}
+
+			if ($methods !== array_unique($methods)) {
+				throw new DuplicateMethodException($methods);
+			}
+		}
+
+		if ($mockClassName !== '' && class_exists($mockClassName, false)) {
+			try {
+				$reflector = new ReflectionClass($mockClassName);
+				// @codeCoverageIgnoreStart
+			} catch (\ReflectionException $e) {
+				throw new ReflectionException(
+					$e->getMessage(),
+					(int) $e->getCode(),
+					$e
+				);
+			}
+			// @codeCoverageIgnoreEnd
+
+			if (!$reflector->implementsInterface(MockObject::class)) {
+				throw new ClassAlreadyExistsException($mockClassName);
+			}
+		}
+
+		if (!$callOriginalConstructor && $callOriginalMethods) {
+			throw new OriginalConstructorInvocationRequiredException;
+		}
+
+		$mock = $this->generate(
+			$type,
+			$methods,
+			$mockClassName,
+			$callOriginalClone,
+			$callAutoload,
+			$cloneArguments,
+			$callOriginalMethods
+		);
+
+		return $this->getObject(
+			$mock,
+			$type,
+			$callOriginalConstructor,
+			$callAutoload,
+			$arguments,
+			$callOriginalMethods,
+			$proxyTarget,
+			$returnValueGeneration
+		);
+	}
+
+	/**
+	 * @psalm-param list<class-string> $interfaces
+	 *
+	 * @throws RuntimeException
+	 * @throws UnknownTypeException
+	 */
+	public function getMockForInterfaces(array $interfaces, bool $callAutoload = true): MockObject
+	{
+		if (count($interfaces) < 2) {
+			throw new RuntimeException('At least two interfaces must be specified');
+		}
+
+		foreach ($interfaces as $interface) {
+			if (!interface_exists($interface, $callAutoload)) {
+				throw new UnknownTypeException($interface);
+			}
+		}
+
+		sort($interfaces);
+
+		$methods = [];
+
+		foreach ($interfaces as $interface) {
+			$methods = array_merge($methods, $this->getClassMethods($interface));
+		}
+
+		if (count(array_unique($methods)) < count($methods)) {
+			throw new RuntimeException('Interfaces must not declare the same method');
+		}
+
+		$unqualifiedNames = [];
+
+		foreach ($interfaces as $interface) {
+			$parts              = explode('\\', $interface);
+			$unqualifiedNames[] = array_pop($parts);
+		}
+
+		sort($unqualifiedNames);
+
+		do {
+			$intersectionName = sprintf(
+				'Intersection_%s_%s',
+				implode('_', $unqualifiedNames),
+				substr(md5((string) mt_rand()), 0, 8)
+			);
+		} while (interface_exists($intersectionName, false));
+
+		$template = $this->getTemplate('intersection.tpl');
+
+		$template->setVar(
+			[
+				'intersection' => $intersectionName,
+				'interfaces'   => implode(', ', $interfaces),
+			]
+		);
+
+		eval($template->render());
+
+		return $this->getMock($intersectionName);
+	}
+
+	/**
+	 * Returns a mock object for the specified abstract class with all abstract
+	 * methods of the class mocked.
+	 *
+	 * Concrete methods to mock can be specified with the $mockedMethods parameter.
+	 *
+	 * @psalm-template RealInstanceType of object
+	 *
+	 * @psalm-param class-string<RealInstanceType> $originalClassName
+	 *
+	 * @psalm-return MockObject&RealInstanceType
+	 *
+	 * @throws \PHPUnit\Framework\InvalidArgumentException
+	 * @throws ClassAlreadyExistsException
+	 * @throws ClassIsFinalException
+	 * @throws DuplicateMethodException
+	 * @throws InvalidMethodNameException
+	 * @throws OriginalConstructorInvocationRequiredException
+	 * @throws ReflectionException
+	 * @throws RuntimeException
+	 * @throws UnknownClassException
+	 * @throws UnknownTypeException
+	 */
+	public function getMockForAbstractClass(string $originalClassName, array $arguments = [], string $mockClassName = '', bool $callOriginalConstructor = true, bool $callOriginalClone = true, bool $callAutoload = true, array $mockedMethods = null, bool $cloneArguments = true): MockObject
+	{
+		if (class_exists($originalClassName, $callAutoload) ||
+			interface_exists($originalClassName, $callAutoload)) {
+			try {
+				$reflector = new ReflectionClass($originalClassName);
+				// @codeCoverageIgnoreStart
+			} catch (\ReflectionException $e) {
+				throw new ReflectionException(
+					$e->getMessage(),
+					(int) $e->getCode(),
+					$e
+				);
+			}
+			// @codeCoverageIgnoreEnd
+
+			$methods = $mockedMethods;
+
+			foreach ($reflector->getMethods() as $method) {
+				if ($method->isAbstract() && !in_array($method->getName(), $methods ?? [], true)) {
+					$methods[] = $method->getName();
+				}
+			}
+
+			if (empty($methods)) {
+				$methods = null;
+			}
+
+			return $this->getMock(
+				$originalClassName,
+				$methods,
+				$arguments,
+				$mockClassName,
+				$callOriginalConstructor,
+				$callOriginalClone,
+				$callAutoload,
+				$cloneArguments
+			);
+		}
+
+		throw new UnknownClassException($originalClassName);
+	}
+
+	/**
+	 * Returns a mock object for the specified trait with all abstract methods
+	 * of the trait mocked. Concrete methods to mock can be specified with the
+	 * `$mockedMethods` parameter.
+	 *
+	 * @psalm-param trait-string $traitName
+	 *
+	 * @throws \PHPUnit\Framework\InvalidArgumentException
+	 * @throws ClassAlreadyExistsException
+	 * @throws ClassIsFinalException
+	 * @throws DuplicateMethodException
+	 * @throws InvalidMethodNameException
+	 * @throws OriginalConstructorInvocationRequiredException
+	 * @throws ReflectionException
+	 * @throws RuntimeException
+	 * @throws UnknownClassException
+	 * @throws UnknownTraitException
+	 * @throws UnknownTypeException
+	 */
+	public function getMockForTrait(string $traitName, array $arguments = [], string $mockClassName = '', bool $callOriginalConstructor = true, bool $callOriginalClone = true, bool $callAutoload = true, array $mockedMethods = null, bool $cloneArguments = true): MockObject
+	{
+		if (!trait_exists($traitName, $callAutoload)) {
+			throw new UnknownTraitException($traitName);
+		}
+
+		$className = $this->generateClassName(
+			$traitName,
+			'',
+			'Trait_'
+		);
+
+		$classTemplate = $this->getTemplate('trait_class.tpl');
+
+		$classTemplate->setVar(
+			[
+				'prologue'   => 'abstract ',
+				'class_name' => $className['className'],
+				'trait_name' => $traitName,
+			]
+		);
+
+		$mockTrait = new MockTrait($classTemplate->render(), $className['className']);
+		$mockTrait->generate();
+
+		return $this->getMockForAbstractClass($className['className'], $arguments, $mockClassName, $callOriginalConstructor, $callOriginalClone, $callAutoload, $mockedMethods, $cloneArguments);
+	}
+
+	/**
+	 * Returns an object for the specified trait.
+	 *
+	 * @psalm-param trait-string $traitName
+	 *
+	 * @throws ReflectionException
+	 * @throws RuntimeException
+	 * @throws UnknownTraitException
+	 */
+	public function getObjectForTrait(string $traitName, string $traitClassName = '', bool $callAutoload = true, bool $callOriginalConstructor = false, array $arguments = []): object
+	{
+		if (!trait_exists($traitName, $callAutoload)) {
+			throw new UnknownTraitException($traitName);
+		}
+
+		$className = $this->generateClassName(
+			$traitName,
+			$traitClassName,
+			'Trait_'
+		);
+
+		$classTemplate = $this->getTemplate('trait_class.tpl');
+
+		$classTemplate->setVar(
+			[
+				'prologue'   => '',
+				'class_name' => $className['className'],
+				'trait_name' => $traitName,
+			]
+		);
+
+		return $this->getObject(
+			new MockTrait(
+				$classTemplate->render(),
+				$className['className']
+			),
+			'',
+			$callOriginalConstructor,
+			$callAutoload,
+			$arguments
+		);
+	}
+
+	/**
+	 * @throws ClassIsFinalException
+	 * @throws ReflectionException
+	 * @throws RuntimeException
+	 */
+	public function generate(string $type, array $methods = null, string $mockClassName = '', bool $callOriginalClone = true, bool $callAutoload = true, bool $cloneArguments = true, bool $callOriginalMethods = false): MockClass
+	{
+		if ($mockClassName !== '') {
+			return $this->generateMock(
+				$type,
+				$methods,
+				$mockClassName,
+				$callOriginalClone,
+				$callAutoload,
+				$cloneArguments,
+				$callOriginalMethods
+			);
+		}
+
+		$key = md5(
+			$type .
+			serialize($methods) .
+			serialize($callOriginalClone) .
+			serialize($cloneArguments) .
+			serialize($callOriginalMethods)
+		);
+
+		if (!isset(self::$cache[$key])) {
+			self::$cache[$key] = $this->generateMock(
+				$type,
+				$methods,
+				$mockClassName,
+				$callOriginalClone,
+				$callAutoload,
+				$cloneArguments,
+				$callOriginalMethods
+			);
+		}
+
+		return self::$cache[$key];
+	}
+
+	/**
+	 * @throws RuntimeException
+	 * @throws SoapExtensionNotAvailableException
+	 */
+	public function generateClassFromWsdl(string $wsdlFile, string $className, array $methods = [], array $options = []): string
+	{
+		if (!extension_loaded('soap')) {
+			throw new SoapExtensionNotAvailableException;
+		}
+
+		$options = array_merge($options, ['cache_wsdl' => WSDL_CACHE_NONE]);
+
+		try {
+			$client   = new SoapClient($wsdlFile, $options);
+			$_methods = array_unique($client->__getFunctions());
+			unset($client);
+		} catch (SoapFault $e) {
+			throw new RuntimeException(
+				$e->getMessage(),
+				(int) $e->getCode(),
+				$e
+			);
+		}
+
+		sort($_methods);
+
+		$methodTemplate = $this->getTemplate('wsdl_method.tpl');
+		$methodsBuffer  = '';
+
+		foreach ($_methods as $method) {
+			preg_match_all('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*\(/', $method, $matches, PREG_OFFSET_CAPTURE);
+			$lastFunction = array_pop($matches[0]);
+			$nameStart    = $lastFunction[1];
+			$nameEnd      = $nameStart + strlen($lastFunction[0]) - 1;
+			$name         = str_replace('(', '', $lastFunction[0]);
+
+			if (empty($methods) || in_array($name, $methods, true)) {
+				$args = explode(
+					',',
+					str_replace(')', '', substr($method, $nameEnd + 1))
+				);
+
+				foreach (range(0, count($args) - 1) as $i) {
+					$parameterStart = strpos($args[$i], '$');
+
+					if (!$parameterStart) {
+						continue;
+					}
+
+					$args[$i] = substr($args[$i], $parameterStart);
+				}
+
+				$methodTemplate->setVar(
+					[
+						'method_name' => $name,
+						'arguments'   => implode(', ', $args),
+					]
+				);
+
+				$methodsBuffer .= $methodTemplate->render();
+			}
+		}
+
+		$optionsBuffer = '[';
+
+		foreach ($options as $key => $value) {
+			$optionsBuffer .= $key . ' => ' . $value;
+		}
+
+		$optionsBuffer .= ']';
+
+		$classTemplate = $this->getTemplate('wsdl_class.tpl');
+		$namespace     = '';
+
+		if (strpos($className, '\\') !== false) {
+			$parts     = explode('\\', $className);
+			$className = array_pop($parts);
+			$namespace = 'namespace ' . implode('\\', $parts) . ';' . "\n\n";
+		}
+
+		$classTemplate->setVar(
+			[
+				'namespace'  => $namespace,
+				'class_name' => $className,
+				'wsdl'       => $wsdlFile,
+				'options'    => $optionsBuffer,
+				'methods'    => $methodsBuffer,
+			]
+		);
+
+		return $classTemplate->render();
+	}
+
+	/**
+	 * @throws ReflectionException
+	 *
+	 * @return string[]
+	 */
+	public function getClassMethods(string $className): array
+	{
+		try {
+			$class = new ReflectionClass($className);
+			// @codeCoverageIgnoreStart
+		} catch (\ReflectionException $e) {
+			throw new ReflectionException(
+				$e->getMessage(),
+				(int) $e->getCode(),
+				$e
+			);
+		}
+		// @codeCoverageIgnoreEnd
+
+		$methods = [];
+
+		foreach ($class->getMethods() as $method) {
+			if ($method->isPublic() || $method->isAbstract()) {
+				$methods[] = $method->getName();
+			}
+		}
+
+		return $methods;
+	}
+
+	/**
+	 * @throws ReflectionException
+	 *
+	 * @return MockMethod[]
+	 */
+	public function mockClassMethods(string $className, bool $callOriginalMethods, bool $cloneArguments): array
+	{
+		try {
+			$class = new ReflectionClass($className);
+			// @codeCoverageIgnoreStart
+		} catch (\ReflectionException $e) {
+			throw new ReflectionException(
+				$e->getMessage(),
+				(int) $e->getCode(),
+				$e
+			);
+		}
+		// @codeCoverageIgnoreEnd
+
+		$methods = [];
+
+		foreach ($class->getMethods() as $method) {
+			if (($method->isPublic() || $method->isAbstract()) && $this->canMockMethod($method)) {
+				$methods[] = MockMethod::fromReflection($method, $callOriginalMethods, $cloneArguments);
+			}
+		}
+
+		return $methods;
+	}
+
+	/**
+	 * @throws ReflectionException
+	 *
+	 * @return MockMethod[]
+	 */
+	public function mockInterfaceMethods(string $interfaceName, bool $cloneArguments): array
+	{
+		try {
+			$class = new ReflectionClass($interfaceName);
+			// @codeCoverageIgnoreStart
+		} catch (\ReflectionException $e) {
+			throw new ReflectionException(
+				$e->getMessage(),
+				(int) $e->getCode(),
+				$e
+			);
+		}
+		// @codeCoverageIgnoreEnd
+
+		$methods = [];
+
+		foreach ($class->getMethods() as $method) {
+			$methods[] = MockMethod::fromReflection($method, false, $cloneArguments);
+		}
+
+		return $methods;
+	}
+
+	/**
+	 * @psalm-param class-string $interfaceName
+	 *
+	 * @throws ReflectionException
+	 *
+	 * @return ReflectionMethod[]
+	 */
+	private function userDefinedInterfaceMethods(string $interfaceName): array
+	{
+		try {
+			// @codeCoverageIgnoreStart
+			$interface = new ReflectionClass($interfaceName);
+		} catch (\ReflectionException $e) {
+			throw new ReflectionException(
+				$e->getMessage(),
+				(int) $e->getCode(),
+				$e
+			);
+		}
+		// @codeCoverageIgnoreEnd
+
+		$methods = [];
+
+		foreach ($interface->getMethods() as $method) {
+			if (!$method->isUserDefined()) {
+				continue;
+			}
+
+			$methods[] = $method;
+		}
+
+		return $methods;
+	}
+
+	/**
+	 * @throws ReflectionException
+	 * @throws RuntimeException
+	 */
+	private function getObject(MockType $mockClass, $type = '', bool $callOriginalConstructor = false, bool $callAutoload = false, array $arguments = [], bool $callOriginalMethods = false, object $proxyTarget = null, bool $returnValueGeneration = true)
+	{
+		$className = $mockClass->generate();
+
+		if ($callOriginalConstructor) {
+			if (count($arguments) === 0) {
+				$object = new $className;
+			} else {
+				try {
+					$class = new ReflectionClass($className);
+					// @codeCoverageIgnoreStart
+				} catch (\ReflectionException $e) {
+					throw new ReflectionException(
+						$e->getMessage(),
+						(int) $e->getCode(),
+						$e
+					);
+				}
+				// @codeCoverageIgnoreEnd
+
+				$object = $class->newInstanceArgs($arguments);
+			}
+		} else {
+			try {
+				$object = (new Instantiator)->instantiate($className);
+			} catch (InstantiatorException $e) {
+				throw new RuntimeException($e->getMessage());
+			}
+		}
+
+		if ($callOriginalMethods) {
+			if (!is_object($proxyTarget)) {
+				if (count($arguments) === 0) {
+					$proxyTarget = new $type;
+				} else {
+					try {
+						$class = new ReflectionClass($type);
+						// @codeCoverageIgnoreStart
+					} catch (\ReflectionException $e) {
+						throw new ReflectionException(
+							$e->getMessage(),
+							(int) $e->getCode(),
+							$e
+						);
+					}
+					// @codeCoverageIgnoreEnd
+
+					$proxyTarget = $class->newInstanceArgs($arguments);
+				}
+			}
+
+			$object->__phpunit_setOriginalObject($proxyTarget);
+		}
+
+		if ($object instanceof MockObject) {
+			$object->__phpunit_setReturnValueGeneration($returnValueGeneration);
+		}
+
+		return $object;
+	}
+
+	/**
+	 * @throws ClassIsFinalException
+	 * @throws ReflectionException
+	 * @throws RuntimeException
+	 */
+	private function generateMock(string $type, ?array $explicitMethods, string $mockClassName, bool $callOriginalClone, bool $callAutoload, bool $cloneArguments, bool $callOriginalMethods): MockClass
+	{
+		$classTemplate        = $this->getTemplate('mocked_class.tpl');
+		$additionalInterfaces = [];
+		$mockedCloneMethod    = false;
+		$unmockedCloneMethod  = false;
+		$isClass              = false;
+		$isInterface          = false;
+		$class                = null;
+		$mockMethods          = new MockMethodSet;
+
+		$_mockClassName = $this->generateClassName(
+			$type,
+			$mockClassName,
+			'Mock_'
+		);
+
+		if (class_exists($_mockClassName['fullClassName'], $callAutoload)) {
+			$isClass = true;
+		} elseif (interface_exists($_mockClassName['fullClassName'], $callAutoload)) {
+			$isInterface = true;
+		}
+
+		if (!$isClass && !$isInterface) {
+			$prologue = 'class ' . $_mockClassName['originalClassName'] . "\n{\n}\n\n";
+
+			if (!empty($_mockClassName['namespaceName'])) {
+				$prologue = 'namespace ' . $_mockClassName['namespaceName'] .
+							" {\n\n" . $prologue . "}\n\n" .
+							"namespace {\n\n";
+
+				$epilogue = "\n\n}";
+			}
+
+			$mockedCloneMethod = true;
+		} else {
+			try {
+				$class = new ReflectionClass($_mockClassName['fullClassName']);
+				// @codeCoverageIgnoreStart
+			} catch (\ReflectionException $e) {
+				throw new ReflectionException(
+					$e->getMessage(),
+					(int) $e->getCode(),
+					$e
+				);
+			}
+			// @codeCoverageIgnoreEnd
+
+			if ($class->isFinal()) {
+				throw new ClassIsFinalException($_mockClassName['fullClassName']);
+			}
+
+			// @see https://github.com/sebastianbergmann/phpunit/issues/2995
+			if ($isInterface && $class->implementsInterface(Throwable::class)) {
+				$actualClassName        = Exception::class;
+				$additionalInterfaces[] = $class->getName();
+				$isInterface            = false;
+
+				try {
+					$class = new ReflectionClass($actualClassName);
+					// @codeCoverageIgnoreStart
+				} catch (\ReflectionException $e) {
+					throw new ReflectionException(
+						$e->getMessage(),
+						(int) $e->getCode(),
+						$e
+					);
+				}
+				// @codeCoverageIgnoreEnd
+
+				foreach ($this->userDefinedInterfaceMethods($_mockClassName['fullClassName']) as $method) {
+					$methodName = $method->getName();
+
+					if ($class->hasMethod($methodName)) {
+						try {
+							$classMethod = $class->getMethod($methodName);
+							// @codeCoverageIgnoreStart
+						} catch (\ReflectionException $e) {
+							throw new ReflectionException(
+								$e->getMessage(),
+								(int) $e->getCode(),
+								$e
+							);
+						}
+						// @codeCoverageIgnoreEnd
+
+						if (!$this->canMockMethod($classMethod)) {
+							continue;
+						}
+					}
+
+					$mockMethods->addMethods(
+						MockMethod::fromReflection($method, $callOriginalMethods, $cloneArguments)
+					);
+				}
+
+				$_mockClassName = $this->generateClassName(
+					$actualClassName,
+					$_mockClassName['className'],
+					'Mock_'
+				);
+			}
+
+			// @see https://github.com/sebastianbergmann/phpunit-mock-objects/issues/103
+			if ($isInterface && $class->implementsInterface(Traversable::class) &&
+				!$class->implementsInterface(Iterator::class) &&
+				!$class->implementsInterface(IteratorAggregate::class)) {
+				$additionalInterfaces[] = Iterator::class;
+
+				$mockMethods->addMethods(
+					...$this->mockClassMethods(Iterator::class, $callOriginalMethods, $cloneArguments)
+				);
+			}
+
+			if ($class->hasMethod('__clone')) {
+				try {
+					$cloneMethod = $class->getMethod('__clone');
+					// @codeCoverageIgnoreStart
+				} catch (\ReflectionException $e) {
+					throw new ReflectionException(
+						$e->getMessage(),
+						(int) $e->getCode(),
+						$e
+					);
+				}
+				// @codeCoverageIgnoreEnd
+
+				if (!$cloneMethod->isFinal()) {
+					if ($callOriginalClone && !$isInterface) {
+						$unmockedCloneMethod = true;
+					} else {
+						$mockedCloneMethod = true;
+					}
+				}
+			} else {
+				$mockedCloneMethod = true;
+			}
+		}
+
+		if ($isClass && $explicitMethods === []) {
+			$mockMethods->addMethods(
+				...$this->mockClassMethods($_mockClassName['fullClassName'], $callOriginalMethods, $cloneArguments)
+			);
+		}
+
+		if ($isInterface && ($explicitMethods === [] || $explicitMethods === null)) {
+			$mockMethods->addMethods(
+				...$this->mockInterfaceMethods($_mockClassName['fullClassName'], $cloneArguments)
+			);
+		}
+
+		if (is_array($explicitMethods)) {
+			foreach ($explicitMethods as $methodName) {
+				if ($class !== null && $class->hasMethod($methodName)) {
+					try {
+						$method = $class->getMethod($methodName);
+						// @codeCoverageIgnoreStart
+					} catch (\ReflectionException $e) {
+						throw new ReflectionException(
+							$e->getMessage(),
+							(int) $e->getCode(),
+							$e
+						);
+					}
+					// @codeCoverageIgnoreEnd
+
+					if ($this->canMockMethod($method)) {
+						$mockMethods->addMethods(
+							MockMethod::fromReflection($method, $callOriginalMethods, $cloneArguments)
+						);
+					}
+				} else {
+					$mockMethods->addMethods(
+						MockMethod::fromName(
+							$_mockClassName['fullClassName'],
+							$methodName,
+							$cloneArguments
+						)
+					);
+				}
+			}
+		}
+
+		$mockedMethods = '';
+		$configurable  = [];
+
+		foreach ($mockMethods->asArray() as $mockMethod) {
+			$mockedMethods .= $mockMethod->generateCode();
+			$configurable[] = new ConfigurableMethod($mockMethod->getName(), $mockMethod->getReturnType());
+		}
+
+		$method = '';
+
+		if (!$mockMethods->hasMethod('method') && (!isset($class) || !$class->hasMethod('method'))) {
+			$method = PHP_EOL . '    use \PHPUnit\Framework\MockObject\Method;';
+		}
+
+		$cloneTrait = '';
+
+		if ($mockedCloneMethod) {
+			$cloneTrait = $this->mockedCloneMethod();
+		}
+
+		if ($unmockedCloneMethod) {
+			$cloneTrait = $this->unmockedCloneMethod();
+		}
+
+		$classTemplate->setVar(
+			[
+				'prologue'          => $prologue ?? '',
+				'epilogue'          => $epilogue ?? '',
+				'class_declaration' => $this->generateMockClassDeclaration(
+					$_mockClassName,
+					$isInterface,
+					$additionalInterfaces
+				),
+				'clone'           => $cloneTrait,
+				'mock_class_name' => $_mockClassName['className'],
+				'mocked_methods'  => $mockedMethods,
+				'method'          => $method,
+			]
+		);
+
+		return new MockClass(
+			$classTemplate->render(),
+			$_mockClassName['className'],
+			$configurable
+		);
+	}
+
+	private function generateClassName(string $type, string $className, string $prefix): array
+	{
+		if ($type[0] === '\\') {
+			$type = substr($type, 1);
+		}
+
+		$classNameParts = explode('\\', $type);
+
+		if (count($classNameParts) > 1) {
+			$type          = array_pop($classNameParts);
+			$namespaceName = implode('\\', $classNameParts);
+			$fullClassName = $namespaceName . '\\' . $type;
+		} else {
+			$namespaceName = '';
+			$fullClassName = $type;
+		}
+
+		if ($className === '') {
+			do {
+				$className = $prefix . $type . '_' .
+							 substr(md5((string) mt_rand()), 0, 8);
+			} while (class_exists($className, false));
+		}
+
+		return [
+			'className'         => $className,
+			'originalClassName' => $type,
+			'fullClassName'     => $fullClassName,
+			'namespaceName'     => $namespaceName,
+		];
+	}
+
+	private function generateMockClassDeclaration(array $mockClassName, bool $isInterface, array $additionalInterfaces = []): string
+	{
+		$buffer = 'class ';
+
+		$additionalInterfaces[] = MockObject::class;
+		$interfaces             = implode(', ', $additionalInterfaces);
+
+		if ($isInterface) {
+			$buffer .= sprintf(
+				'%s implements %s',
+				$mockClassName['className'],
+				$interfaces
+			);
+
+			if (!in_array($mockClassName['originalClassName'], $additionalInterfaces, true)) {
+				$buffer .= ', ';
+
+				if (!empty($mockClassName['namespaceName'])) {
+					$buffer .= $mockClassName['namespaceName'] . '\\';
+				}
+
+				$buffer .= $mockClassName['originalClassName'];
+			}
+		} else {
+			$buffer .= sprintf(
+				'%s extends %s%s implements %s',
+				$mockClassName['className'],
+				!empty($mockClassName['namespaceName']) ? $mockClassName['namespaceName'] . '\\' : '',
+				$mockClassName['originalClassName'],
+				$interfaces
+			);
+		}
+
+		return $buffer;
+	}
+
+	private function canMockMethod(ReflectionMethod $method): bool
+	{
+		return !($this->isConstructor($method) || $method->isFinal() || $method->isPrivate() || $this->isMethodNameExcluded($method->getName()));
+	}
+
+	private function isMethodNameExcluded(string $name): bool
+	{
+		return isset(self::EXCLUDED_METHOD_NAMES[$name]);
+	}
+
+	/**
+	 * @throws RuntimeException
+	 */
+	private function getTemplate(string $template): Template
+	{
+		$filename = __DIR__ . DIRECTORY_SEPARATOR . 'Generator' . DIRECTORY_SEPARATOR . $template;
+
+		if (!isset(self::$templates[$filename])) {
+			try {
+				self::$templates[$filename] = new Template($filename);
+			} catch (TemplateException $e) {
+				throw new RuntimeException(
+					$e->getMessage(),
+					(int) $e->getCode(),
+					$e
+				);
+			}
+		}
+
+		return self::$templates[$filename];
+	}
+
+	/**
+	 * @see https://github.com/sebastianbergmann/phpunit/issues/4139#issuecomment-605409765
+	 */
+	private function isConstructor(ReflectionMethod $method): bool
+	{
+		$methodName = strtolower($method->getName());
+
+		if ($methodName === '__construct') {
+			return true;
+		}
+
+		if (PHP_MAJOR_VERSION >= 8) {
+			return false;
+		}
+
+		$className = strtolower($method->getDeclaringClass()->getName());
+
+		return $methodName === $className;
+	}
+
+	private function mockedCloneMethod(): string
+	{
+		if (PHP_MAJOR_VERSION >= 8) {
+			if (!trait_exists('\PHPUnit\Framework\MockObject\MockedCloneMethodWithVoidReturnType')) {
+				eval(self::MOCKED_CLONE_METHOD_WITH_VOID_RETURN_TYPE_TRAIT);
+			}
+
+			return PHP_EOL . '    use \PHPUnit\Framework\MockObject\MockedCloneMethodWithVoidReturnType;';
+		}
+
+		if (!trait_exists('\PHPUnit\Framework\MockObject\MockedCloneMethodWithoutReturnType')) {
+			eval(self::MOCKED_CLONE_METHOD_WITHOUT_RETURN_TYPE_TRAIT);
+		}
+
+		return PHP_EOL . '    use \PHPUnit\Framework\MockObject\MockedCloneMethodWithoutReturnType;';
+	}
+
+	private function unmockedCloneMethod(): string
+	{
+		if (PHP_MAJOR_VERSION >= 8) {
+			if (!trait_exists('\PHPUnit\Framework\MockObject\UnmockedCloneMethodWithVoidReturnType')) {
+				eval(self::UNMOCKED_CLONE_METHOD_WITH_VOID_RETURN_TYPE_TRAIT);
+			}
+
+			return PHP_EOL . '    use \PHPUnit\Framework\MockObject\UnmockedCloneMethodWithVoidReturnType;';
+		}
+
+		if (!trait_exists('\PHPUnit\Framework\MockObject\UnmockedCloneMethodWithoutReturnType')) {
+			eval(self::UNMOCKED_CLONE_METHOD_WITHOUT_RETURN_TYPE_TRAIT);
+		}
+
+		return PHP_EOL . '    use \PHPUnit\Framework\MockObject\UnmockedCloneMethodWithoutReturnType;';
+	}
 }

vendor/phpunit/phpunit/src/Framework/MockObject/MockMethod.php

Indentation +337 added lines, -337 removed lines

@@ -36,345 +36,345 @@
  */
 final class MockMethod
 {
-    /**
-     * @var Template[]
-     */
-    private static $templates = [];
-
-    /**
-     * @var string
-     */
-    private $className;
-
-    /**
-     * @var string
-     */
-    private $methodName;
-
-    /**
-     * @var bool
-     */
-    private $cloneArguments;
-
-    /**
-     * @var string string
-     */
-    private $modifier;
-
-    /**
-     * @var string
-     */
-    private $argumentsForDeclaration;
-
-    /**
-     * @var string
-     */
-    private $argumentsForCall;
-
-    /**
-     * @var Type
-     */
-    private $returnType;
-
-    /**
-     * @var string
-     */
-    private $reference;
-
-    /**
-     * @var bool
-     */
-    private $callOriginalMethod;
-
-    /**
-     * @var bool
-     */
-    private $static;
-
-    /**
-     * @var ?string
-     */
-    private $deprecation;
-
-    /**
-     * @throws ReflectionException
-     * @throws RuntimeException
-     */
-    public static function fromReflection(ReflectionMethod $method, bool $callOriginalMethod, bool $cloneArguments): self
-    {
-        if ($method->isPrivate()) {
-            $modifier = 'private';
-        } elseif ($method->isProtected()) {
-            $modifier = 'protected';
-        } else {
-            $modifier = 'public';
-        }
-
-        if ($method->isStatic()) {
-            $modifier .= ' static';
-        }
-
-        if ($method->returnsReference()) {
-            $reference = '&';
-        } else {
-            $reference = '';
-        }
-
-        $docComment = $method->getDocComment();
-
-        if (is_string($docComment) &&
-            preg_match('#\*[ \t]*+@deprecated[ \t]*+(.*?)\r?+\n[ \t]*+\*(?:[ \t]*+@|/$)#s', $docComment, $deprecation)) {
-            $deprecation = trim(preg_replace('#[ \t]*\r?\n[ \t]*+\*[ \t]*+#', ' ', $deprecation[1]));
-        } else {
-            $deprecation = null;
-        }
-
-        return new self(
-            $method->getDeclaringClass()->getName(),
-            $method->getName(),
-            $cloneArguments,
-            $modifier,
-            self::getMethodParametersForDeclaration($method),
-            self::getMethodParametersForCall($method),
-            (new ReflectionMapper)->fromReturnType($method),
-            $reference,
-            $callOriginalMethod,
-            $method->isStatic(),
-            $deprecation
-        );
-    }
-
-    public static function fromName(string $fullClassName, string $methodName, bool $cloneArguments): self
-    {
-        return new self(
-            $fullClassName,
-            $methodName,
-            $cloneArguments,
-            'public',
-            '',
-            '',
-            new UnknownType,
-            '',
-            false,
-            false,
-            null
-        );
-    }
-
-    public function __construct(string $className, string $methodName, bool $cloneArguments, string $modifier, string $argumentsForDeclaration, string $argumentsForCall, Type $returnType, string $reference, bool $callOriginalMethod, bool $static, ?string $deprecation)
-    {
-        $this->className               = $className;
-        $this->methodName              = $methodName;
-        $this->cloneArguments          = $cloneArguments;
-        $this->modifier                = $modifier;
-        $this->argumentsForDeclaration = $argumentsForDeclaration;
-        $this->argumentsForCall        = $argumentsForCall;
-        $this->returnType              = $returnType;
-        $this->reference               = $reference;
-        $this->callOriginalMethod      = $callOriginalMethod;
-        $this->static                  = $static;
-        $this->deprecation             = $deprecation;
-    }
-
-    public function getName(): string
-    {
-        return $this->methodName;
-    }
-
-    /**
-     * @throws RuntimeException
-     */
-    public function generateCode(): string
-    {
-        if ($this->static) {
-            $templateFile = 'mocked_static_method.tpl';
-        } elseif ($this->returnType->isNever() || $this->returnType->isVoid()) {
-            $templateFile = sprintf(
-                '%s_method_never_or_void.tpl',
-                $this->callOriginalMethod ? 'proxied' : 'mocked'
-            );
-        } else {
-            $templateFile = sprintf(
-                '%s_method.tpl',
-                $this->callOriginalMethod ? 'proxied' : 'mocked'
-            );
-        }
-
-        $deprecation = $this->deprecation;
-
-        if (null !== $this->deprecation) {
-            $deprecation         = "The {$this->className}::{$this->methodName} method is deprecated ({$this->deprecation}).";
-            $deprecationTemplate = $this->getTemplate('deprecation.tpl');
-
-            $deprecationTemplate->setVar(
-                [
-                    'deprecation' => var_export($deprecation, true),
-                ]
-            );
-
-            $deprecation = $deprecationTemplate->render();
-        }
-
-        $template = $this->getTemplate($templateFile);
-
-        $template->setVar(
-            [
-                'arguments_decl'     => $this->argumentsForDeclaration,
-                'arguments_call'     => $this->argumentsForCall,
-                'return_declaration' => !empty($this->returnType->asString()) ? (': ' . $this->returnType->asString()) : '',
-                'return_type'        => $this->returnType->asString(),
-                'arguments_count'    => !empty($this->argumentsForCall) ? substr_count($this->argumentsForCall, ',') + 1 : 0,
-                'class_name'         => $this->className,
-                'method_name'        => $this->methodName,
-                'modifier'           => $this->modifier,
-                'reference'          => $this->reference,
-                'clone_arguments'    => $this->cloneArguments ? 'true' : 'false',
-                'deprecation'        => $deprecation,
-            ]
-        );
-
-        return $template->render();
-    }
-
-    public function getReturnType(): Type
-    {
-        return $this->returnType;
-    }
-
-    /**
-     * @throws RuntimeException
-     */
-    private function getTemplate(string $template): Template
-    {
-        $filename = __DIR__ . DIRECTORY_SEPARATOR . 'Generator' . DIRECTORY_SEPARATOR . $template;
-
-        if (!isset(self::$templates[$filename])) {
-            try {
-                self::$templates[$filename] = new Template($filename);
-            } catch (TemplateException $e) {
-                throw new RuntimeException(
-                    $e->getMessage(),
-                    (int) $e->getCode(),
-                    $e
-                );
-            }
-        }
-
-        return self::$templates[$filename];
-    }
-
-    /**
-     * Returns the parameters of a function or method.
-     *
-     * @throws RuntimeException
-     */
-    private static function getMethodParametersForDeclaration(ReflectionMethod $method): string
-    {
-        $parameters = [];
-        $types      = (new ReflectionMapper)->fromParameterTypes($method);
-
-        foreach ($method->getParameters() as $i => $parameter) {
-            $name = '$' . $parameter->getName();
-
-            /* Note: PHP extensions may use empty names for reference arguments
+	/**
+	 * @var Template[]
+	 */
+	private static $templates = [];
+
+	/**
+	 * @var string
+	 */
+	private $className;
+
+	/**
+	 * @var string
+	 */
+	private $methodName;
+
+	/**
+	 * @var bool
+	 */
+	private $cloneArguments;
+
+	/**
+	 * @var string string
+	 */
+	private $modifier;
+
+	/**
+	 * @var string
+	 */
+	private $argumentsForDeclaration;
+
+	/**
+	 * @var string
+	 */
+	private $argumentsForCall;
+
+	/**
+	 * @var Type
+	 */
+	private $returnType;
+
+	/**
+	 * @var string
+	 */
+	private $reference;
+
+	/**
+	 * @var bool
+	 */
+	private $callOriginalMethod;
+
+	/**
+	 * @var bool
+	 */
+	private $static;
+
+	/**
+	 * @var ?string
+	 */
+	private $deprecation;
+
+	/**
+	 * @throws ReflectionException
+	 * @throws RuntimeException
+	 */
+	public static function fromReflection(ReflectionMethod $method, bool $callOriginalMethod, bool $cloneArguments): self
+	{
+		if ($method->isPrivate()) {
+			$modifier = 'private';
+		} elseif ($method->isProtected()) {
+			$modifier = 'protected';
+		} else {
+			$modifier = 'public';
+		}
+
+		if ($method->isStatic()) {
+			$modifier .= ' static';
+		}
+
+		if ($method->returnsReference()) {
+			$reference = '&';
+		} else {
+			$reference = '';
+		}
+
+		$docComment = $method->getDocComment();
+
+		if (is_string($docComment) &&
+			preg_match('#\*[ \t]*+@deprecated[ \t]*+(.*?)\r?+\n[ \t]*+\*(?:[ \t]*+@|/$)#s', $docComment, $deprecation)) {
+			$deprecation = trim(preg_replace('#[ \t]*\r?\n[ \t]*+\*[ \t]*+#', ' ', $deprecation[1]));
+		} else {
+			$deprecation = null;
+		}
+
+		return new self(
+			$method->getDeclaringClass()->getName(),
+			$method->getName(),
+			$cloneArguments,
+			$modifier,
+			self::getMethodParametersForDeclaration($method),
+			self::getMethodParametersForCall($method),
+			(new ReflectionMapper)->fromReturnType($method),
+			$reference,
+			$callOriginalMethod,
+			$method->isStatic(),
+			$deprecation
+		);
+	}
+
+	public static function fromName(string $fullClassName, string $methodName, bool $cloneArguments): self
+	{
+		return new self(
+			$fullClassName,
+			$methodName,
+			$cloneArguments,
+			'public',
+			'',
+			'',
+			new UnknownType,
+			'',
+			false,
+			false,
+			null
+		);
+	}
+
+	public function __construct(string $className, string $methodName, bool $cloneArguments, string $modifier, string $argumentsForDeclaration, string $argumentsForCall, Type $returnType, string $reference, bool $callOriginalMethod, bool $static, ?string $deprecation)
+	{
+		$this->className               = $className;
+		$this->methodName              = $methodName;
+		$this->cloneArguments          = $cloneArguments;
+		$this->modifier                = $modifier;
+		$this->argumentsForDeclaration = $argumentsForDeclaration;
+		$this->argumentsForCall        = $argumentsForCall;
+		$this->returnType              = $returnType;
+		$this->reference               = $reference;
+		$this->callOriginalMethod      = $callOriginalMethod;
+		$this->static                  = $static;
+		$this->deprecation             = $deprecation;
+	}
+
+	public function getName(): string
+	{
+		return $this->methodName;
+	}
+
+	/**
+	 * @throws RuntimeException
+	 */
+	public function generateCode(): string
+	{
+		if ($this->static) {
+			$templateFile = 'mocked_static_method.tpl';
+		} elseif ($this->returnType->isNever() || $this->returnType->isVoid()) {
+			$templateFile = sprintf(
+				'%s_method_never_or_void.tpl',
+				$this->callOriginalMethod ? 'proxied' : 'mocked'
+			);
+		} else {
+			$templateFile = sprintf(
+				'%s_method.tpl',
+				$this->callOriginalMethod ? 'proxied' : 'mocked'
+			);
+		}
+
+		$deprecation = $this->deprecation;
+
+		if (null !== $this->deprecation) {
+			$deprecation         = "The {$this->className}::{$this->methodName} method is deprecated ({$this->deprecation}).";
+			$deprecationTemplate = $this->getTemplate('deprecation.tpl');
+
+			$deprecationTemplate->setVar(
+				[
+					'deprecation' => var_export($deprecation, true),
+				]
+			);
+
+			$deprecation = $deprecationTemplate->render();
+		}
+
+		$template = $this->getTemplate($templateFile);
+
+		$template->setVar(
+			[
+				'arguments_decl'     => $this->argumentsForDeclaration,
+				'arguments_call'     => $this->argumentsForCall,
+				'return_declaration' => !empty($this->returnType->asString()) ? (': ' . $this->returnType->asString()) : '',
+				'return_type'        => $this->returnType->asString(),
+				'arguments_count'    => !empty($this->argumentsForCall) ? substr_count($this->argumentsForCall, ',') + 1 : 0,
+				'class_name'         => $this->className,
+				'method_name'        => $this->methodName,
+				'modifier'           => $this->modifier,
+				'reference'          => $this->reference,
+				'clone_arguments'    => $this->cloneArguments ? 'true' : 'false',
+				'deprecation'        => $deprecation,
+			]
+		);
+
+		return $template->render();
+	}
+
+	public function getReturnType(): Type
+	{
+		return $this->returnType;
+	}
+
+	/**
+	 * @throws RuntimeException
+	 */
+	private function getTemplate(string $template): Template
+	{
+		$filename = __DIR__ . DIRECTORY_SEPARATOR . 'Generator' . DIRECTORY_SEPARATOR . $template;
+
+		if (!isset(self::$templates[$filename])) {
+			try {
+				self::$templates[$filename] = new Template($filename);
+			} catch (TemplateException $e) {
+				throw new RuntimeException(
+					$e->getMessage(),
+					(int) $e->getCode(),
+					$e
+				);
+			}
+		}
+
+		return self::$templates[$filename];
+	}
+
+	/**
+	 * Returns the parameters of a function or method.
+	 *
+	 * @throws RuntimeException
+	 */
+	private static function getMethodParametersForDeclaration(ReflectionMethod $method): string
+	{
+		$parameters = [];
+		$types      = (new ReflectionMapper)->fromParameterTypes($method);
+
+		foreach ($method->getParameters() as $i => $parameter) {
+			$name = '$' . $parameter->getName();
+
+			/* Note: PHP extensions may use empty names for reference arguments
              * or "..." for methods taking a variable number of arguments.
              */
-            if ($name === '$' || $name === '$...') {
-                $name = '$arg' . $i;
-            }
-
-            $default         = '';
-            $reference       = '';
-            $typeDeclaration = '';
-
-            if (!$types[$i]->type()->isUnknown()) {
-                $typeDeclaration = $types[$i]->type()->asString() . ' ';
-            }
-
-            if ($parameter->isPassedByReference()) {
-                $reference = '&';
-            }
-
-            if ($parameter->isVariadic()) {
-                $name = '...' . $name;
-            } elseif ($parameter->isDefaultValueAvailable()) {
-                $default = ' = ' . self::exportDefaultValue($parameter);
-            } elseif ($parameter->isOptional()) {
-                $default = ' = null';
-            }
-
-            $parameters[] = $typeDeclaration . $reference . $name . $default;
-        }
-
-        return implode(', ', $parameters);
-    }
-
-    /**
-     * Returns the parameters of a function or method.
-     *
-     * @throws ReflectionException
-     */
-    private static function getMethodParametersForCall(ReflectionMethod $method): string
-    {
-        $parameters = [];
-
-        foreach ($method->getParameters() as $i => $parameter) {
-            $name = '$' . $parameter->getName();
-
-            /* Note: PHP extensions may use empty names for reference arguments
+			if ($name === '$' || $name === '$...') {
+				$name = '$arg' . $i;
+			}
+
+			$default         = '';
+			$reference       = '';
+			$typeDeclaration = '';
+
+			if (!$types[$i]->type()->isUnknown()) {
+				$typeDeclaration = $types[$i]->type()->asString() . ' ';
+			}
+
+			if ($parameter->isPassedByReference()) {
+				$reference = '&';
+			}
+
+			if ($parameter->isVariadic()) {
+				$name = '...' . $name;
+			} elseif ($parameter->isDefaultValueAvailable()) {
+				$default = ' = ' . self::exportDefaultValue($parameter);
+			} elseif ($parameter->isOptional()) {
+				$default = ' = null';
+			}
+
+			$parameters[] = $typeDeclaration . $reference . $name . $default;
+		}
+
+		return implode(', ', $parameters);
+	}
+
+	/**
+	 * Returns the parameters of a function or method.
+	 *
+	 * @throws ReflectionException
+	 */
+	private static function getMethodParametersForCall(ReflectionMethod $method): string
+	{
+		$parameters = [];
+
+		foreach ($method->getParameters() as $i => $parameter) {
+			$name = '$' . $parameter->getName();
+
+			/* Note: PHP extensions may use empty names for reference arguments
              * or "..." for methods taking a variable number of arguments.
              */
-            if ($name === '$' || $name === '$...') {
-                $name = '$arg' . $i;
-            }
-
-            if ($parameter->isVariadic()) {
-                continue;
-            }
-
-            if ($parameter->isPassedByReference()) {
-                $parameters[] = '&' . $name;
-            } else {
-                $parameters[] = $name;
-            }
-        }
-
-        return implode(', ', $parameters);
-    }
-
-    /**
-     * @throws ReflectionException
-     */
-    private static function exportDefaultValue(ReflectionParameter $parameter): string
-    {
-        try {
-            $defaultValue = $parameter->getDefaultValue();
-
-            if (!is_object($defaultValue)) {
-                return (string) var_export($defaultValue, true);
-            }
-
-            $parameterAsString = $parameter->__toString();
-
-            return (string) explode(
-                ' = ',
-                substr(
-                    substr(
-                        $parameterAsString,
-                        strpos($parameterAsString, '<optional> ') + strlen('<optional> ')
-                    ),
-                    0,
-                    -2
-                )
-            )[1];
-            // @codeCoverageIgnoreStart
-        } catch (\ReflectionException $e) {
-            throw new ReflectionException(
-                $e->getMessage(),
-                (int) $e->getCode(),
-                $e
-            );
-        }
-        // @codeCoverageIgnoreEnd
-    }
+			if ($name === '$' || $name === '$...') {
+				$name = '$arg' . $i;
+			}
+
+			if ($parameter->isVariadic()) {
+				continue;
+			}
+
+			if ($parameter->isPassedByReference()) {
+				$parameters[] = '&' . $name;
+			} else {
+				$parameters[] = $name;
+			}
+		}
+
+		return implode(', ', $parameters);
+	}
+
+	/**
+	 * @throws ReflectionException
+	 */
+	private static function exportDefaultValue(ReflectionParameter $parameter): string
+	{
+		try {
+			$defaultValue = $parameter->getDefaultValue();
+
+			if (!is_object($defaultValue)) {
+				return (string) var_export($defaultValue, true);
+			}
+
+			$parameterAsString = $parameter->__toString();
+
+			return (string) explode(
+				' = ',
+				substr(
+					substr(
+						$parameterAsString,
+						strpos($parameterAsString, '<optional> ') + strlen('<optional> ')
+					),
+					0,
+					-2
+				)
+			)[1];
+			// @codeCoverageIgnoreStart
+		} catch (\ReflectionException $e) {
+			throw new ReflectionException(
+				$e->getMessage(),
+				(int) $e->getCode(),
+				$e
+			);
+		}
+		// @codeCoverageIgnoreEnd
+	}
 }

Spacing +15 added lines, -15 removed lines

@@ -221,9 +221,9 @@ 
             [
                 'arguments_decl'     => $this->argumentsForDeclaration,
                 'arguments_call'     => $this->argumentsForCall,
-                'return_declaration' => !empty($this->returnType->asString()) ? (': ' . $this->returnType->asString()) : '',
+                'return_declaration' => ! empty($this->returnType->asString()) ? (': '.$this->returnType->asString()) : '',
                 'return_type'        => $this->returnType->asString(),
-                'arguments_count'    => !empty($this->argumentsForCall) ? substr_count($this->argumentsForCall, ',') + 1 : 0,
+                'arguments_count'    => ! empty($this->argumentsForCall) ? substr_count($this->argumentsForCall, ',') + 1 : 0,
                 'class_name'         => $this->className,
                 'method_name'        => $this->methodName,
                 'modifier'           => $this->modifier,
@@ -246,9 +246,9 @@ 
      */
     private function getTemplate(string $template): Template
     {
-        $filename = __DIR__ . DIRECTORY_SEPARATOR . 'Generator' . DIRECTORY_SEPARATOR . $template;
+        $filename = __DIR__.DIRECTORY_SEPARATOR.'Generator'.DIRECTORY_SEPARATOR.$template;
 
-        if (!isset(self::$templates[$filename])) {
+        if ( ! isset(self::$templates[$filename])) {
             try {
                 self::$templates[$filename] = new Template($filename);
             } catch (TemplateException $e) {
@@ -274,21 +274,21 @@ 
         $types      = (new ReflectionMapper)->fromParameterTypes($method);
 
         foreach ($method->getParameters() as $i => $parameter) {
-            $name = '$' . $parameter->getName();
+            $name = '$'.$parameter->getName();
 
             /* Note: PHP extensions may use empty names for reference arguments
              * or "..." for methods taking a variable number of arguments.
              */
             if ($name === '$' || $name === '$...') {
-                $name = '$arg' . $i;
+                $name = '$arg'.$i;
             }
 
             $default         = '';
             $reference       = '';
             $typeDeclaration = '';
 
-            if (!$types[$i]->type()->isUnknown()) {
-                $typeDeclaration = $types[$i]->type()->asString() . ' ';
+            if ( ! $types[$i]->type()->isUnknown()) {
+                $typeDeclaration = $types[$i]->type()->asString().' ';
             }
 
             if ($parameter->isPassedByReference()) {
@@ -296,14 +296,14 @@ 
             }
 
             if ($parameter->isVariadic()) {
-                $name = '...' . $name;
+                $name = '...'.$name;
             } elseif ($parameter->isDefaultValueAvailable()) {
-                $default = ' = ' . self::exportDefaultValue($parameter);
+                $default = ' = '.self::exportDefaultValue($parameter);
             } elseif ($parameter->isOptional()) {
                 $default = ' = null';
             }
 
-            $parameters[] = $typeDeclaration . $reference . $name . $default;
+            $parameters[] = $typeDeclaration.$reference.$name.$default;
         }
 
         return implode(', ', $parameters);
@@ -319,13 +319,13 @@ 
         $parameters = [];
 
         foreach ($method->getParameters() as $i => $parameter) {
-            $name = '$' . $parameter->getName();
+            $name = '$'.$parameter->getName();
 
             /* Note: PHP extensions may use empty names for reference arguments
              * or "..." for methods taking a variable number of arguments.
              */
             if ($name === '$' || $name === '$...') {
-                $name = '$arg' . $i;
+                $name = '$arg'.$i;
             }
 
             if ($parameter->isVariadic()) {
@@ -333,7 +333,7 @@ 
             }
 
             if ($parameter->isPassedByReference()) {
-                $parameters[] = '&' . $name;
+                $parameters[] = '&'.$name;
             } else {
                 $parameters[] = $name;
             }
@@ -350,7 +350,7 @@ 
         try {
             $defaultValue = $parameter->getDefaultValue();
 
-            if (!is_object($defaultValue)) {
+            if ( ! is_object($defaultValue)) {
                 return (string) var_export($defaultValue, true);
             }
 

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

Indentation +2377 added lines, -2377 removed lines

@@ -73,2970 +73,2970 @@
 use Throwable;
 
 if (!function_exists('PHPUnit\Framework\assertArrayHasKey')) {
-    /**
-     * Asserts that an array has a specified key.
-     *
-     * @param int|string        $key
-     * @param array|ArrayAccess $array
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertArrayHasKey
-     */
-    function assertArrayHasKey($key, $array, string $message = ''): void
-    {
-        Assert::assertArrayHasKey(...func_get_args());
-    }
+	/**
+	 * Asserts that an array has a specified key.
+	 *
+	 * @param int|string        $key
+	 * @param array|ArrayAccess $array
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertArrayHasKey
+	 */
+	function assertArrayHasKey($key, $array, string $message = ''): void
+	{
+		Assert::assertArrayHasKey(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertArrayNotHasKey')) {
-    /**
-     * Asserts that an array does not have a specified key.
-     *
-     * @param int|string        $key
-     * @param array|ArrayAccess $array
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertArrayNotHasKey
-     */
-    function assertArrayNotHasKey($key, $array, string $message = ''): void
-    {
-        Assert::assertArrayNotHasKey(...func_get_args());
-    }
+	/**
+	 * Asserts that an array does not have a specified key.
+	 *
+	 * @param int|string        $key
+	 * @param array|ArrayAccess $array
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertArrayNotHasKey
+	 */
+	function assertArrayNotHasKey($key, $array, string $message = ''): void
+	{
+		Assert::assertArrayNotHasKey(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertContains')) {
-    /**
-     * Asserts that a haystack contains a needle.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertContains
-     */
-    function assertContains($needle, iterable $haystack, string $message = ''): void
-    {
-        Assert::assertContains(...func_get_args());
-    }
+	/**
+	 * Asserts that a haystack contains a needle.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertContains
+	 */
+	function assertContains($needle, iterable $haystack, string $message = ''): void
+	{
+		Assert::assertContains(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertContainsEquals')) {
-    function assertContainsEquals($needle, iterable $haystack, string $message = ''): void
-    {
-        Assert::assertContainsEquals(...func_get_args());
-    }
+	function assertContainsEquals($needle, iterable $haystack, string $message = ''): void
+	{
+		Assert::assertContainsEquals(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotContains')) {
-    /**
-     * Asserts that a haystack does not contain a needle.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotContains
-     */
-    function assertNotContains($needle, iterable $haystack, string $message = ''): void
-    {
-        Assert::assertNotContains(...func_get_args());
-    }
+	/**
+	 * Asserts that a haystack does not contain a needle.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotContains
+	 */
+	function assertNotContains($needle, iterable $haystack, string $message = ''): void
+	{
+		Assert::assertNotContains(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotContainsEquals')) {
-    function assertNotContainsEquals($needle, iterable $haystack, string $message = ''): void
-    {
-        Assert::assertNotContainsEquals(...func_get_args());
-    }
+	function assertNotContainsEquals($needle, iterable $haystack, string $message = ''): void
+	{
+		Assert::assertNotContainsEquals(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertContainsOnly')) {
-    /**
-     * Asserts that a haystack contains only values of a given type.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertContainsOnly
-     */
-    function assertContainsOnly(string $type, iterable $haystack, ?bool $isNativeType = null, string $message = ''): void
-    {
-        Assert::assertContainsOnly(...func_get_args());
-    }
+	/**
+	 * Asserts that a haystack contains only values of a given type.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertContainsOnly
+	 */
+	function assertContainsOnly(string $type, iterable $haystack, ?bool $isNativeType = null, string $message = ''): void
+	{
+		Assert::assertContainsOnly(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertContainsOnlyInstancesOf')) {
-    /**
-     * Asserts that a haystack contains only instances of a given class name.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertContainsOnlyInstancesOf
-     */
-    function assertContainsOnlyInstancesOf(string $className, iterable $haystack, string $message = ''): void
-    {
-        Assert::assertContainsOnlyInstancesOf(...func_get_args());
-    }
+	/**
+	 * Asserts that a haystack contains only instances of a given class name.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertContainsOnlyInstancesOf
+	 */
+	function assertContainsOnlyInstancesOf(string $className, iterable $haystack, string $message = ''): void
+	{
+		Assert::assertContainsOnlyInstancesOf(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotContainsOnly')) {
-    /**
-     * Asserts that a haystack does not contain only values of a given type.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotContainsOnly
-     */
-    function assertNotContainsOnly(string $type, iterable $haystack, ?bool $isNativeType = null, string $message = ''): void
-    {
-        Assert::assertNotContainsOnly(...func_get_args());
-    }
+	/**
+	 * Asserts that a haystack does not contain only values of a given type.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotContainsOnly
+	 */
+	function assertNotContainsOnly(string $type, iterable $haystack, ?bool $isNativeType = null, string $message = ''): void
+	{
+		Assert::assertNotContainsOnly(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertCount')) {
-    /**
-     * Asserts the number of elements of an array, Countable or Traversable.
-     *
-     * @param Countable|iterable $haystack
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertCount
-     */
-    function assertCount(int $expectedCount, $haystack, string $message = ''): void
-    {
-        Assert::assertCount(...func_get_args());
-    }
+	/**
+	 * Asserts the number of elements of an array, Countable or Traversable.
+	 *
+	 * @param Countable|iterable $haystack
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertCount
+	 */
+	function assertCount(int $expectedCount, $haystack, string $message = ''): void
+	{
+		Assert::assertCount(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotCount')) {
-    /**
-     * Asserts the number of elements of an array, Countable or Traversable.
-     *
-     * @param Countable|iterable $haystack
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotCount
-     */
-    function assertNotCount(int $expectedCount, $haystack, string $message = ''): void
-    {
-        Assert::assertNotCount(...func_get_args());
-    }
+	/**
+	 * Asserts the number of elements of an array, Countable or Traversable.
+	 *
+	 * @param Countable|iterable $haystack
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotCount
+	 */
+	function assertNotCount(int $expectedCount, $haystack, string $message = ''): void
+	{
+		Assert::assertNotCount(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertEquals')) {
-    /**
-     * Asserts that two variables are equal.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertEquals
-     */
-    function assertEquals($expected, $actual, string $message = ''): void
-    {
-        Assert::assertEquals(...func_get_args());
-    }
+	/**
+	 * Asserts that two variables are equal.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertEquals
+	 */
+	function assertEquals($expected, $actual, string $message = ''): void
+	{
+		Assert::assertEquals(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertEqualsCanonicalizing')) {
-    /**
-     * Asserts that two variables are equal (canonicalizing).
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertEqualsCanonicalizing
-     */
-    function assertEqualsCanonicalizing($expected, $actual, string $message = ''): void
-    {
-        Assert::assertEqualsCanonicalizing(...func_get_args());
-    }
+	/**
+	 * Asserts that two variables are equal (canonicalizing).
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertEqualsCanonicalizing
+	 */
+	function assertEqualsCanonicalizing($expected, $actual, string $message = ''): void
+	{
+		Assert::assertEqualsCanonicalizing(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertEqualsIgnoringCase')) {
-    /**
-     * Asserts that two variables are equal (ignoring case).
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertEqualsIgnoringCase
-     */
-    function assertEqualsIgnoringCase($expected, $actual, string $message = ''): void
-    {
-        Assert::assertEqualsIgnoringCase(...func_get_args());
-    }
+	/**
+	 * Asserts that two variables are equal (ignoring case).
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertEqualsIgnoringCase
+	 */
+	function assertEqualsIgnoringCase($expected, $actual, string $message = ''): void
+	{
+		Assert::assertEqualsIgnoringCase(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertEqualsWithDelta')) {
-    /**
-     * Asserts that two variables are equal (with delta).
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertEqualsWithDelta
-     */
-    function assertEqualsWithDelta($expected, $actual, float $delta, string $message = ''): void
-    {
-        Assert::assertEqualsWithDelta(...func_get_args());
-    }
+	/**
+	 * Asserts that two variables are equal (with delta).
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertEqualsWithDelta
+	 */
+	function assertEqualsWithDelta($expected, $actual, float $delta, string $message = ''): void
+	{
+		Assert::assertEqualsWithDelta(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotEquals')) {
-    /**
-     * Asserts that two variables are not equal.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotEquals
-     */
-    function assertNotEquals($expected, $actual, string $message = ''): void
-    {
-        Assert::assertNotEquals(...func_get_args());
-    }
+	/**
+	 * Asserts that two variables are not equal.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotEquals
+	 */
+	function assertNotEquals($expected, $actual, string $message = ''): void
+	{
+		Assert::assertNotEquals(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotEqualsCanonicalizing')) {
-    /**
-     * Asserts that two variables are not equal (canonicalizing).
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotEqualsCanonicalizing
-     */
-    function assertNotEqualsCanonicalizing($expected, $actual, string $message = ''): void
-    {
-        Assert::assertNotEqualsCanonicalizing(...func_get_args());
-    }
+	/**
+	 * Asserts that two variables are not equal (canonicalizing).
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotEqualsCanonicalizing
+	 */
+	function assertNotEqualsCanonicalizing($expected, $actual, string $message = ''): void
+	{
+		Assert::assertNotEqualsCanonicalizing(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotEqualsIgnoringCase')) {
-    /**
-     * Asserts that two variables are not equal (ignoring case).
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotEqualsIgnoringCase
-     */
-    function assertNotEqualsIgnoringCase($expected, $actual, string $message = ''): void
-    {
-        Assert::assertNotEqualsIgnoringCase(...func_get_args());
-    }
+	/**
+	 * Asserts that two variables are not equal (ignoring case).
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotEqualsIgnoringCase
+	 */
+	function assertNotEqualsIgnoringCase($expected, $actual, string $message = ''): void
+	{
+		Assert::assertNotEqualsIgnoringCase(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotEqualsWithDelta')) {
-    /**
-     * Asserts that two variables are not equal (with delta).
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotEqualsWithDelta
-     */
-    function assertNotEqualsWithDelta($expected, $actual, float $delta, string $message = ''): void
-    {
-        Assert::assertNotEqualsWithDelta(...func_get_args());
-    }
+	/**
+	 * Asserts that two variables are not equal (with delta).
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotEqualsWithDelta
+	 */
+	function assertNotEqualsWithDelta($expected, $actual, float $delta, string $message = ''): void
+	{
+		Assert::assertNotEqualsWithDelta(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertObjectEquals')) {
-    /**
-     * @throws ExpectationFailedException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertObjectEquals
-     */
-    function assertObjectEquals(object $expected, object $actual, string $method = 'equals', string $message = ''): void
-    {
-        Assert::assertObjectEquals(...func_get_args());
-    }
+	/**
+	 * @throws ExpectationFailedException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertObjectEquals
+	 */
+	function assertObjectEquals(object $expected, object $actual, string $method = 'equals', string $message = ''): void
+	{
+		Assert::assertObjectEquals(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertEmpty')) {
-    /**
-     * Asserts that a variable is empty.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert empty $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertEmpty
-     */
-    function assertEmpty($actual, string $message = ''): void
-    {
-        Assert::assertEmpty(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is empty.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert empty $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertEmpty
+	 */
+	function assertEmpty($actual, string $message = ''): void
+	{
+		Assert::assertEmpty(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotEmpty')) {
-    /**
-     * Asserts that a variable is not empty.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert !empty $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotEmpty
-     */
-    function assertNotEmpty($actual, string $message = ''): void
-    {
-        Assert::assertNotEmpty(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is not empty.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert !empty $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotEmpty
+	 */
+	function assertNotEmpty($actual, string $message = ''): void
+	{
+		Assert::assertNotEmpty(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertGreaterThan')) {
-    /**
-     * Asserts that a value is greater than another value.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertGreaterThan
-     */
-    function assertGreaterThan($expected, $actual, string $message = ''): void
-    {
-        Assert::assertGreaterThan(...func_get_args());
-    }
+	/**
+	 * Asserts that a value is greater than another value.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertGreaterThan
+	 */
+	function assertGreaterThan($expected, $actual, string $message = ''): void
+	{
+		Assert::assertGreaterThan(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertGreaterThanOrEqual')) {
-    /**
-     * Asserts that a value is greater than or equal to another value.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertGreaterThanOrEqual
-     */
-    function assertGreaterThanOrEqual($expected, $actual, string $message = ''): void
-    {
-        Assert::assertGreaterThanOrEqual(...func_get_args());
-    }
+	/**
+	 * Asserts that a value is greater than or equal to another value.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertGreaterThanOrEqual
+	 */
+	function assertGreaterThanOrEqual($expected, $actual, string $message = ''): void
+	{
+		Assert::assertGreaterThanOrEqual(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertLessThan')) {
-    /**
-     * Asserts that a value is smaller than another value.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertLessThan
-     */
-    function assertLessThan($expected, $actual, string $message = ''): void
-    {
-        Assert::assertLessThan(...func_get_args());
-    }
+	/**
+	 * Asserts that a value is smaller than another value.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertLessThan
+	 */
+	function assertLessThan($expected, $actual, string $message = ''): void
+	{
+		Assert::assertLessThan(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertLessThanOrEqual')) {
-    /**
-     * Asserts that a value is smaller than or equal to another value.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertLessThanOrEqual
-     */
-    function assertLessThanOrEqual($expected, $actual, string $message = ''): void
-    {
-        Assert::assertLessThanOrEqual(...func_get_args());
-    }
+	/**
+	 * Asserts that a value is smaller than or equal to another value.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertLessThanOrEqual
+	 */
+	function assertLessThanOrEqual($expected, $actual, string $message = ''): void
+	{
+		Assert::assertLessThanOrEqual(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFileEquals')) {
-    /**
-     * Asserts that the contents of one file is equal to the contents of another
-     * file.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFileEquals
-     */
-    function assertFileEquals(string $expected, string $actual, string $message = ''): void
-    {
-        Assert::assertFileEquals(...func_get_args());
-    }
+	/**
+	 * Asserts that the contents of one file is equal to the contents of another
+	 * file.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFileEquals
+	 */
+	function assertFileEquals(string $expected, string $actual, string $message = ''): void
+	{
+		Assert::assertFileEquals(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFileEqualsCanonicalizing')) {
-    /**
-     * Asserts that the contents of one file is equal to the contents of another
-     * file (canonicalizing).
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFileEqualsCanonicalizing
-     */
-    function assertFileEqualsCanonicalizing(string $expected, string $actual, string $message = ''): void
-    {
-        Assert::assertFileEqualsCanonicalizing(...func_get_args());
-    }
+	/**
+	 * Asserts that the contents of one file is equal to the contents of another
+	 * file (canonicalizing).
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFileEqualsCanonicalizing
+	 */
+	function assertFileEqualsCanonicalizing(string $expected, string $actual, string $message = ''): void
+	{
+		Assert::assertFileEqualsCanonicalizing(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFileEqualsIgnoringCase')) {
-    /**
-     * Asserts that the contents of one file is equal to the contents of another
-     * file (ignoring case).
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFileEqualsIgnoringCase
-     */
-    function assertFileEqualsIgnoringCase(string $expected, string $actual, string $message = ''): void
-    {
-        Assert::assertFileEqualsIgnoringCase(...func_get_args());
-    }
+	/**
+	 * Asserts that the contents of one file is equal to the contents of another
+	 * file (ignoring case).
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFileEqualsIgnoringCase
+	 */
+	function assertFileEqualsIgnoringCase(string $expected, string $actual, string $message = ''): void
+	{
+		Assert::assertFileEqualsIgnoringCase(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFileNotEquals')) {
-    /**
-     * Asserts that the contents of one file is not equal to the contents of
-     * another file.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFileNotEquals
-     */
-    function assertFileNotEquals(string $expected, string $actual, string $message = ''): void
-    {
-        Assert::assertFileNotEquals(...func_get_args());
-    }
+	/**
+	 * Asserts that the contents of one file is not equal to the contents of
+	 * another file.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFileNotEquals
+	 */
+	function assertFileNotEquals(string $expected, string $actual, string $message = ''): void
+	{
+		Assert::assertFileNotEquals(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFileNotEqualsCanonicalizing')) {
-    /**
-     * Asserts that the contents of one file is not equal to the contents of another
-     * file (canonicalizing).
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFileNotEqualsCanonicalizing
-     */
-    function assertFileNotEqualsCanonicalizing(string $expected, string $actual, string $message = ''): void
-    {
-        Assert::assertFileNotEqualsCanonicalizing(...func_get_args());
-    }
+	/**
+	 * Asserts that the contents of one file is not equal to the contents of another
+	 * file (canonicalizing).
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFileNotEqualsCanonicalizing
+	 */
+	function assertFileNotEqualsCanonicalizing(string $expected, string $actual, string $message = ''): void
+	{
+		Assert::assertFileNotEqualsCanonicalizing(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFileNotEqualsIgnoringCase')) {
-    /**
-     * Asserts that the contents of one file is not equal to the contents of another
-     * file (ignoring case).
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFileNotEqualsIgnoringCase
-     */
-    function assertFileNotEqualsIgnoringCase(string $expected, string $actual, string $message = ''): void
-    {
-        Assert::assertFileNotEqualsIgnoringCase(...func_get_args());
-    }
+	/**
+	 * Asserts that the contents of one file is not equal to the contents of another
+	 * file (ignoring case).
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFileNotEqualsIgnoringCase
+	 */
+	function assertFileNotEqualsIgnoringCase(string $expected, string $actual, string $message = ''): void
+	{
+		Assert::assertFileNotEqualsIgnoringCase(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringEqualsFile')) {
-    /**
-     * Asserts that the contents of a string is equal
-     * to the contents of a file.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringEqualsFile
-     */
-    function assertStringEqualsFile(string $expectedFile, string $actualString, string $message = ''): void
-    {
-        Assert::assertStringEqualsFile(...func_get_args());
-    }
+	/**
+	 * Asserts that the contents of a string is equal
+	 * to the contents of a file.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringEqualsFile
+	 */
+	function assertStringEqualsFile(string $expectedFile, string $actualString, string $message = ''): void
+	{
+		Assert::assertStringEqualsFile(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringEqualsFileCanonicalizing')) {
-    /**
-     * Asserts that the contents of a string is equal
-     * to the contents of a file (canonicalizing).
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringEqualsFileCanonicalizing
-     */
-    function assertStringEqualsFileCanonicalizing(string $expectedFile, string $actualString, string $message = ''): void
-    {
-        Assert::assertStringEqualsFileCanonicalizing(...func_get_args());
-    }
+	/**
+	 * Asserts that the contents of a string is equal
+	 * to the contents of a file (canonicalizing).
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringEqualsFileCanonicalizing
+	 */
+	function assertStringEqualsFileCanonicalizing(string $expectedFile, string $actualString, string $message = ''): void
+	{
+		Assert::assertStringEqualsFileCanonicalizing(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringEqualsFileIgnoringCase')) {
-    /**
-     * Asserts that the contents of a string is equal
-     * to the contents of a file (ignoring case).
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringEqualsFileIgnoringCase
-     */
-    function assertStringEqualsFileIgnoringCase(string $expectedFile, string $actualString, string $message = ''): void
-    {
-        Assert::assertStringEqualsFileIgnoringCase(...func_get_args());
-    }
+	/**
+	 * Asserts that the contents of a string is equal
+	 * to the contents of a file (ignoring case).
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringEqualsFileIgnoringCase
+	 */
+	function assertStringEqualsFileIgnoringCase(string $expectedFile, string $actualString, string $message = ''): void
+	{
+		Assert::assertStringEqualsFileIgnoringCase(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringNotEqualsFile')) {
-    /**
-     * Asserts that the contents of a string is not equal
-     * to the contents of a file.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringNotEqualsFile
-     */
-    function assertStringNotEqualsFile(string $expectedFile, string $actualString, string $message = ''): void
-    {
-        Assert::assertStringNotEqualsFile(...func_get_args());
-    }
+	/**
+	 * Asserts that the contents of a string is not equal
+	 * to the contents of a file.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringNotEqualsFile
+	 */
+	function assertStringNotEqualsFile(string $expectedFile, string $actualString, string $message = ''): void
+	{
+		Assert::assertStringNotEqualsFile(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringNotEqualsFileCanonicalizing')) {
-    /**
-     * Asserts that the contents of a string is not equal
-     * to the contents of a file (canonicalizing).
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringNotEqualsFileCanonicalizing
-     */
-    function assertStringNotEqualsFileCanonicalizing(string $expectedFile, string $actualString, string $message = ''): void
-    {
-        Assert::assertStringNotEqualsFileCanonicalizing(...func_get_args());
-    }
+	/**
+	 * Asserts that the contents of a string is not equal
+	 * to the contents of a file (canonicalizing).
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringNotEqualsFileCanonicalizing
+	 */
+	function assertStringNotEqualsFileCanonicalizing(string $expectedFile, string $actualString, string $message = ''): void
+	{
+		Assert::assertStringNotEqualsFileCanonicalizing(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringNotEqualsFileIgnoringCase')) {
-    /**
-     * Asserts that the contents of a string is not equal
-     * to the contents of a file (ignoring case).
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringNotEqualsFileIgnoringCase
-     */
-    function assertStringNotEqualsFileIgnoringCase(string $expectedFile, string $actualString, string $message = ''): void
-    {
-        Assert::assertStringNotEqualsFileIgnoringCase(...func_get_args());
-    }
+	/**
+	 * Asserts that the contents of a string is not equal
+	 * to the contents of a file (ignoring case).
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringNotEqualsFileIgnoringCase
+	 */
+	function assertStringNotEqualsFileIgnoringCase(string $expectedFile, string $actualString, string $message = ''): void
+	{
+		Assert::assertStringNotEqualsFileIgnoringCase(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsReadable')) {
-    /**
-     * Asserts that a file/dir is readable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsReadable
-     */
-    function assertIsReadable(string $filename, string $message = ''): void
-    {
-        Assert::assertIsReadable(...func_get_args());
-    }
+	/**
+	 * Asserts that a file/dir is readable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsReadable
+	 */
+	function assertIsReadable(string $filename, string $message = ''): void
+	{
+		Assert::assertIsReadable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsNotReadable')) {
-    /**
-     * Asserts that a file/dir exists and is not readable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsNotReadable
-     */
-    function assertIsNotReadable(string $filename, string $message = ''): void
-    {
-        Assert::assertIsNotReadable(...func_get_args());
-    }
+	/**
+	 * Asserts that a file/dir exists and is not readable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsNotReadable
+	 */
+	function assertIsNotReadable(string $filename, string $message = ''): void
+	{
+		Assert::assertIsNotReadable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotIsReadable')) {
-    /**
-     * Asserts that a file/dir exists and is not readable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4062
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotIsReadable
-     */
-    function assertNotIsReadable(string $filename, string $message = ''): void
-    {
-        Assert::assertNotIsReadable(...func_get_args());
-    }
+	/**
+	 * Asserts that a file/dir exists and is not readable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4062
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotIsReadable
+	 */
+	function assertNotIsReadable(string $filename, string $message = ''): void
+	{
+		Assert::assertNotIsReadable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsWritable')) {
-    /**
-     * Asserts that a file/dir exists and is writable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsWritable
-     */
-    function assertIsWritable(string $filename, string $message = ''): void
-    {
-        Assert::assertIsWritable(...func_get_args());
-    }
+	/**
+	 * Asserts that a file/dir exists and is writable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsWritable
+	 */
+	function assertIsWritable(string $filename, string $message = ''): void
+	{
+		Assert::assertIsWritable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsNotWritable')) {
-    /**
-     * Asserts that a file/dir exists and is not writable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsNotWritable
-     */
-    function assertIsNotWritable(string $filename, string $message = ''): void
-    {
-        Assert::assertIsNotWritable(...func_get_args());
-    }
+	/**
+	 * Asserts that a file/dir exists and is not writable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsNotWritable
+	 */
+	function assertIsNotWritable(string $filename, string $message = ''): void
+	{
+		Assert::assertIsNotWritable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotIsWritable')) {
-    /**
-     * Asserts that a file/dir exists and is not writable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4065
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotIsWritable
-     */
-    function assertNotIsWritable(string $filename, string $message = ''): void
-    {
-        Assert::assertNotIsWritable(...func_get_args());
-    }
+	/**
+	 * Asserts that a file/dir exists and is not writable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4065
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotIsWritable
+	 */
+	function assertNotIsWritable(string $filename, string $message = ''): void
+	{
+		Assert::assertNotIsWritable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertDirectoryExists')) {
-    /**
-     * Asserts that a directory exists.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertDirectoryExists
-     */
-    function assertDirectoryExists(string $directory, string $message = ''): void
-    {
-        Assert::assertDirectoryExists(...func_get_args());
-    }
+	/**
+	 * Asserts that a directory exists.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertDirectoryExists
+	 */
+	function assertDirectoryExists(string $directory, string $message = ''): void
+	{
+		Assert::assertDirectoryExists(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertDirectoryDoesNotExist')) {
-    /**
-     * Asserts that a directory does not exist.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertDirectoryDoesNotExist
-     */
-    function assertDirectoryDoesNotExist(string $directory, string $message = ''): void
-    {
-        Assert::assertDirectoryDoesNotExist(...func_get_args());
-    }
+	/**
+	 * Asserts that a directory does not exist.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertDirectoryDoesNotExist
+	 */
+	function assertDirectoryDoesNotExist(string $directory, string $message = ''): void
+	{
+		Assert::assertDirectoryDoesNotExist(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertDirectoryNotExists')) {
-    /**
-     * Asserts that a directory does not exist.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4068
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertDirectoryNotExists
-     */
-    function assertDirectoryNotExists(string $directory, string $message = ''): void
-    {
-        Assert::assertDirectoryNotExists(...func_get_args());
-    }
+	/**
+	 * Asserts that a directory does not exist.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4068
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertDirectoryNotExists
+	 */
+	function assertDirectoryNotExists(string $directory, string $message = ''): void
+	{
+		Assert::assertDirectoryNotExists(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertDirectoryIsReadable')) {
-    /**
-     * Asserts that a directory exists and is readable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertDirectoryIsReadable
-     */
-    function assertDirectoryIsReadable(string $directory, string $message = ''): void
-    {
-        Assert::assertDirectoryIsReadable(...func_get_args());
-    }
+	/**
+	 * Asserts that a directory exists and is readable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertDirectoryIsReadable
+	 */
+	function assertDirectoryIsReadable(string $directory, string $message = ''): void
+	{
+		Assert::assertDirectoryIsReadable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertDirectoryIsNotReadable')) {
-    /**
-     * Asserts that a directory exists and is not readable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertDirectoryIsNotReadable
-     */
-    function assertDirectoryIsNotReadable(string $directory, string $message = ''): void
-    {
-        Assert::assertDirectoryIsNotReadable(...func_get_args());
-    }
+	/**
+	 * Asserts that a directory exists and is not readable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertDirectoryIsNotReadable
+	 */
+	function assertDirectoryIsNotReadable(string $directory, string $message = ''): void
+	{
+		Assert::assertDirectoryIsNotReadable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertDirectoryNotIsReadable')) {
-    /**
-     * Asserts that a directory exists and is not readable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4071
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertDirectoryNotIsReadable
-     */
-    function assertDirectoryNotIsReadable(string $directory, string $message = ''): void
-    {
-        Assert::assertDirectoryNotIsReadable(...func_get_args());
-    }
+	/**
+	 * Asserts that a directory exists and is not readable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4071
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertDirectoryNotIsReadable
+	 */
+	function assertDirectoryNotIsReadable(string $directory, string $message = ''): void
+	{
+		Assert::assertDirectoryNotIsReadable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertDirectoryIsWritable')) {
-    /**
-     * Asserts that a directory exists and is writable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertDirectoryIsWritable
-     */
-    function assertDirectoryIsWritable(string $directory, string $message = ''): void
-    {
-        Assert::assertDirectoryIsWritable(...func_get_args());
-    }
+	/**
+	 * Asserts that a directory exists and is writable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertDirectoryIsWritable
+	 */
+	function assertDirectoryIsWritable(string $directory, string $message = ''): void
+	{
+		Assert::assertDirectoryIsWritable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertDirectoryIsNotWritable')) {
-    /**
-     * Asserts that a directory exists and is not writable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertDirectoryIsNotWritable
-     */
-    function assertDirectoryIsNotWritable(string $directory, string $message = ''): void
-    {
-        Assert::assertDirectoryIsNotWritable(...func_get_args());
-    }
+	/**
+	 * Asserts that a directory exists and is not writable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertDirectoryIsNotWritable
+	 */
+	function assertDirectoryIsNotWritable(string $directory, string $message = ''): void
+	{
+		Assert::assertDirectoryIsNotWritable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertDirectoryNotIsWritable')) {
-    /**
-     * Asserts that a directory exists and is not writable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4074
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertDirectoryNotIsWritable
-     */
-    function assertDirectoryNotIsWritable(string $directory, string $message = ''): void
-    {
-        Assert::assertDirectoryNotIsWritable(...func_get_args());
-    }
+	/**
+	 * Asserts that a directory exists and is not writable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4074
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertDirectoryNotIsWritable
+	 */
+	function assertDirectoryNotIsWritable(string $directory, string $message = ''): void
+	{
+		Assert::assertDirectoryNotIsWritable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFileExists')) {
-    /**
-     * Asserts that a file exists.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFileExists
-     */
-    function assertFileExists(string $filename, string $message = ''): void
-    {
-        Assert::assertFileExists(...func_get_args());
-    }
+	/**
+	 * Asserts that a file exists.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFileExists
+	 */
+	function assertFileExists(string $filename, string $message = ''): void
+	{
+		Assert::assertFileExists(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFileDoesNotExist')) {
-    /**
-     * Asserts that a file does not exist.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFileDoesNotExist
-     */
-    function assertFileDoesNotExist(string $filename, string $message = ''): void
-    {
-        Assert::assertFileDoesNotExist(...func_get_args());
-    }
+	/**
+	 * Asserts that a file does not exist.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFileDoesNotExist
+	 */
+	function assertFileDoesNotExist(string $filename, string $message = ''): void
+	{
+		Assert::assertFileDoesNotExist(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFileNotExists')) {
-    /**
-     * Asserts that a file does not exist.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4077
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFileNotExists
-     */
-    function assertFileNotExists(string $filename, string $message = ''): void
-    {
-        Assert::assertFileNotExists(...func_get_args());
-    }
+	/**
+	 * Asserts that a file does not exist.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4077
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFileNotExists
+	 */
+	function assertFileNotExists(string $filename, string $message = ''): void
+	{
+		Assert::assertFileNotExists(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFileIsReadable')) {
-    /**
-     * Asserts that a file exists and is readable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFileIsReadable
-     */
-    function assertFileIsReadable(string $file, string $message = ''): void
-    {
-        Assert::assertFileIsReadable(...func_get_args());
-    }
+	/**
+	 * Asserts that a file exists and is readable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFileIsReadable
+	 */
+	function assertFileIsReadable(string $file, string $message = ''): void
+	{
+		Assert::assertFileIsReadable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFileIsNotReadable')) {
-    /**
-     * Asserts that a file exists and is not readable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFileIsNotReadable
-     */
-    function assertFileIsNotReadable(string $file, string $message = ''): void
-    {
-        Assert::assertFileIsNotReadable(...func_get_args());
-    }
+	/**
+	 * Asserts that a file exists and is not readable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFileIsNotReadable
+	 */
+	function assertFileIsNotReadable(string $file, string $message = ''): void
+	{
+		Assert::assertFileIsNotReadable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFileNotIsReadable')) {
-    /**
-     * Asserts that a file exists and is not readable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4080
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFileNotIsReadable
-     */
-    function assertFileNotIsReadable(string $file, string $message = ''): void
-    {
-        Assert::assertFileNotIsReadable(...func_get_args());
-    }
+	/**
+	 * Asserts that a file exists and is not readable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4080
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFileNotIsReadable
+	 */
+	function assertFileNotIsReadable(string $file, string $message = ''): void
+	{
+		Assert::assertFileNotIsReadable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFileIsWritable')) {
-    /**
-     * Asserts that a file exists and is writable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFileIsWritable
-     */
-    function assertFileIsWritable(string $file, string $message = ''): void
-    {
-        Assert::assertFileIsWritable(...func_get_args());
-    }
+	/**
+	 * Asserts that a file exists and is writable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFileIsWritable
+	 */
+	function assertFileIsWritable(string $file, string $message = ''): void
+	{
+		Assert::assertFileIsWritable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFileIsNotWritable')) {
-    /**
-     * Asserts that a file exists and is not writable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFileIsNotWritable
-     */
-    function assertFileIsNotWritable(string $file, string $message = ''): void
-    {
-        Assert::assertFileIsNotWritable(...func_get_args());
-    }
+	/**
+	 * Asserts that a file exists and is not writable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFileIsNotWritable
+	 */
+	function assertFileIsNotWritable(string $file, string $message = ''): void
+	{
+		Assert::assertFileIsNotWritable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFileNotIsWritable')) {
-    /**
-     * Asserts that a file exists and is not writable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4083
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFileNotIsWritable
-     */
-    function assertFileNotIsWritable(string $file, string $message = ''): void
-    {
-        Assert::assertFileNotIsWritable(...func_get_args());
-    }
+	/**
+	 * Asserts that a file exists and is not writable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4083
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFileNotIsWritable
+	 */
+	function assertFileNotIsWritable(string $file, string $message = ''): void
+	{
+		Assert::assertFileNotIsWritable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertTrue')) {
-    /**
-     * Asserts that a condition is true.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert true $condition
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertTrue
-     */
-    function assertTrue($condition, string $message = ''): void
-    {
-        Assert::assertTrue(...func_get_args());
-    }
+	/**
+	 * Asserts that a condition is true.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert true $condition
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertTrue
+	 */
+	function assertTrue($condition, string $message = ''): void
+	{
+		Assert::assertTrue(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotTrue')) {
-    /**
-     * Asserts that a condition is not true.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert !true $condition
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotTrue
-     */
-    function assertNotTrue($condition, string $message = ''): void
-    {
-        Assert::assertNotTrue(...func_get_args());
-    }
+	/**
+	 * Asserts that a condition is not true.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert !true $condition
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotTrue
+	 */
+	function assertNotTrue($condition, string $message = ''): void
+	{
+		Assert::assertNotTrue(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFalse')) {
-    /**
-     * Asserts that a condition is false.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert false $condition
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFalse
-     */
-    function assertFalse($condition, string $message = ''): void
-    {
-        Assert::assertFalse(...func_get_args());
-    }
+	/**
+	 * Asserts that a condition is false.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert false $condition
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFalse
+	 */
+	function assertFalse($condition, string $message = ''): void
+	{
+		Assert::assertFalse(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotFalse')) {
-    /**
-     * Asserts that a condition is not false.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert !false $condition
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotFalse
-     */
-    function assertNotFalse($condition, string $message = ''): void
-    {
-        Assert::assertNotFalse(...func_get_args());
-    }
+	/**
+	 * Asserts that a condition is not false.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert !false $condition
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotFalse
+	 */
+	function assertNotFalse($condition, string $message = ''): void
+	{
+		Assert::assertNotFalse(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNull')) {
-    /**
-     * Asserts that a variable is null.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert null $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNull
-     */
-    function assertNull($actual, string $message = ''): void
-    {
-        Assert::assertNull(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is null.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert null $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNull
+	 */
+	function assertNull($actual, string $message = ''): void
+	{
+		Assert::assertNull(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotNull')) {
-    /**
-     * Asserts that a variable is not null.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert !null $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotNull
-     */
-    function assertNotNull($actual, string $message = ''): void
-    {
-        Assert::assertNotNull(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is not null.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert !null $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotNull
+	 */
+	function assertNotNull($actual, string $message = ''): void
+	{
+		Assert::assertNotNull(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertFinite')) {
-    /**
-     * Asserts that a variable is finite.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertFinite
-     */
-    function assertFinite($actual, string $message = ''): void
-    {
-        Assert::assertFinite(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is finite.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertFinite
+	 */
+	function assertFinite($actual, string $message = ''): void
+	{
+		Assert::assertFinite(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertInfinite')) {
-    /**
-     * Asserts that a variable is infinite.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertInfinite
-     */
-    function assertInfinite($actual, string $message = ''): void
-    {
-        Assert::assertInfinite(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is infinite.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertInfinite
+	 */
+	function assertInfinite($actual, string $message = ''): void
+	{
+		Assert::assertInfinite(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNan')) {
-    /**
-     * Asserts that a variable is nan.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNan
-     */
-    function assertNan($actual, string $message = ''): void
-    {
-        Assert::assertNan(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is nan.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNan
+	 */
+	function assertNan($actual, string $message = ''): void
+	{
+		Assert::assertNan(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertClassHasAttribute')) {
-    /**
-     * Asserts that a class has a specified attribute.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertClassHasAttribute
-     */
-    function assertClassHasAttribute(string $attributeName, string $className, string $message = ''): void
-    {
-        Assert::assertClassHasAttribute(...func_get_args());
-    }
+	/**
+	 * Asserts that a class has a specified attribute.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertClassHasAttribute
+	 */
+	function assertClassHasAttribute(string $attributeName, string $className, string $message = ''): void
+	{
+		Assert::assertClassHasAttribute(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertClassNotHasAttribute')) {
-    /**
-     * Asserts that a class does not have a specified attribute.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertClassNotHasAttribute
-     */
-    function assertClassNotHasAttribute(string $attributeName, string $className, string $message = ''): void
-    {
-        Assert::assertClassNotHasAttribute(...func_get_args());
-    }
+	/**
+	 * Asserts that a class does not have a specified attribute.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertClassNotHasAttribute
+	 */
+	function assertClassNotHasAttribute(string $attributeName, string $className, string $message = ''): void
+	{
+		Assert::assertClassNotHasAttribute(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertClassHasStaticAttribute')) {
-    /**
-     * Asserts that a class has a specified static attribute.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertClassHasStaticAttribute
-     */
-    function assertClassHasStaticAttribute(string $attributeName, string $className, string $message = ''): void
-    {
-        Assert::assertClassHasStaticAttribute(...func_get_args());
-    }
+	/**
+	 * Asserts that a class has a specified static attribute.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertClassHasStaticAttribute
+	 */
+	function assertClassHasStaticAttribute(string $attributeName, string $className, string $message = ''): void
+	{
+		Assert::assertClassHasStaticAttribute(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertClassNotHasStaticAttribute')) {
-    /**
-     * Asserts that a class does not have a specified static attribute.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertClassNotHasStaticAttribute
-     */
-    function assertClassNotHasStaticAttribute(string $attributeName, string $className, string $message = ''): void
-    {
-        Assert::assertClassNotHasStaticAttribute(...func_get_args());
-    }
+	/**
+	 * Asserts that a class does not have a specified static attribute.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertClassNotHasStaticAttribute
+	 */
+	function assertClassNotHasStaticAttribute(string $attributeName, string $className, string $message = ''): void
+	{
+		Assert::assertClassNotHasStaticAttribute(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertObjectHasAttribute')) {
-    /**
-     * Asserts that an object has a specified attribute.
-     *
-     * @param object $object
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertObjectHasAttribute
-     */
-    function assertObjectHasAttribute(string $attributeName, $object, string $message = ''): void
-    {
-        Assert::assertObjectHasAttribute(...func_get_args());
-    }
+	/**
+	 * Asserts that an object has a specified attribute.
+	 *
+	 * @param object $object
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertObjectHasAttribute
+	 */
+	function assertObjectHasAttribute(string $attributeName, $object, string $message = ''): void
+	{
+		Assert::assertObjectHasAttribute(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertObjectNotHasAttribute')) {
-    /**
-     * Asserts that an object does not have a specified attribute.
-     *
-     * @param object $object
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertObjectNotHasAttribute
-     */
-    function assertObjectNotHasAttribute(string $attributeName, $object, string $message = ''): void
-    {
-        Assert::assertObjectNotHasAttribute(...func_get_args());
-    }
+	/**
+	 * Asserts that an object does not have a specified attribute.
+	 *
+	 * @param object $object
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertObjectNotHasAttribute
+	 */
+	function assertObjectNotHasAttribute(string $attributeName, $object, string $message = ''): void
+	{
+		Assert::assertObjectNotHasAttribute(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertSame')) {
-    /**
-     * Asserts that two variables have the same type and value.
-     * Used on objects, it asserts that two variables reference
-     * the same object.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-template ExpectedType
-     *
-     * @psalm-param ExpectedType $expected
-     *
-     * @psalm-assert =ExpectedType $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertSame
-     */
-    function assertSame($expected, $actual, string $message = ''): void
-    {
-        Assert::assertSame(...func_get_args());
-    }
+	/**
+	 * Asserts that two variables have the same type and value.
+	 * Used on objects, it asserts that two variables reference
+	 * the same object.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-template ExpectedType
+	 *
+	 * @psalm-param ExpectedType $expected
+	 *
+	 * @psalm-assert =ExpectedType $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertSame
+	 */
+	function assertSame($expected, $actual, string $message = ''): void
+	{
+		Assert::assertSame(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotSame')) {
-    /**
-     * 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.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotSame
-     */
-    function assertNotSame($expected, $actual, string $message = ''): void
-    {
-        Assert::assertNotSame(...func_get_args());
-    }
+	/**
+	 * 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.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotSame
+	 */
+	function assertNotSame($expected, $actual, string $message = ''): void
+	{
+		Assert::assertNotSame(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertInstanceOf')) {
-    /**
-     * Asserts that a variable is of a given type.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @psalm-template ExpectedType of object
-     *
-     * @psalm-param class-string<ExpectedType> $expected
-     *
-     * @psalm-assert =ExpectedType $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertInstanceOf
-     */
-    function assertInstanceOf(string $expected, $actual, string $message = ''): void
-    {
-        Assert::assertInstanceOf(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is of a given type.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @psalm-template ExpectedType of object
+	 *
+	 * @psalm-param class-string<ExpectedType> $expected
+	 *
+	 * @psalm-assert =ExpectedType $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertInstanceOf
+	 */
+	function assertInstanceOf(string $expected, $actual, string $message = ''): void
+	{
+		Assert::assertInstanceOf(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotInstanceOf')) {
-    /**
-     * Asserts that a variable is not of a given type.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @psalm-template ExpectedType of object
-     *
-     * @psalm-param class-string<ExpectedType> $expected
-     *
-     * @psalm-assert !ExpectedType $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotInstanceOf
-     */
-    function assertNotInstanceOf(string $expected, $actual, string $message = ''): void
-    {
-        Assert::assertNotInstanceOf(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is not of a given type.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @psalm-template ExpectedType of object
+	 *
+	 * @psalm-param class-string<ExpectedType> $expected
+	 *
+	 * @psalm-assert !ExpectedType $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotInstanceOf
+	 */
+	function assertNotInstanceOf(string $expected, $actual, string $message = ''): void
+	{
+		Assert::assertNotInstanceOf(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsArray')) {
-    /**
-     * Asserts that a variable is of type array.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert array $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsArray
-     */
-    function assertIsArray($actual, string $message = ''): void
-    {
-        Assert::assertIsArray(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is of type array.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert array $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsArray
+	 */
+	function assertIsArray($actual, string $message = ''): void
+	{
+		Assert::assertIsArray(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsBool')) {
-    /**
-     * Asserts that a variable is of type bool.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert bool $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsBool
-     */
-    function assertIsBool($actual, string $message = ''): void
-    {
-        Assert::assertIsBool(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is of type bool.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert bool $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsBool
+	 */
+	function assertIsBool($actual, string $message = ''): void
+	{
+		Assert::assertIsBool(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsFloat')) {
-    /**
-     * Asserts that a variable is of type float.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert float $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsFloat
-     */
-    function assertIsFloat($actual, string $message = ''): void
-    {
-        Assert::assertIsFloat(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is of type float.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert float $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsFloat
+	 */
+	function assertIsFloat($actual, string $message = ''): void
+	{
+		Assert::assertIsFloat(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsInt')) {
-    /**
-     * Asserts that a variable is of type int.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert int $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsInt
-     */
-    function assertIsInt($actual, string $message = ''): void
-    {
-        Assert::assertIsInt(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is of type int.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert int $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsInt
+	 */
+	function assertIsInt($actual, string $message = ''): void
+	{
+		Assert::assertIsInt(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsNumeric')) {
-    /**
-     * Asserts that a variable is of type numeric.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert numeric $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsNumeric
-     */
-    function assertIsNumeric($actual, string $message = ''): void
-    {
-        Assert::assertIsNumeric(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is of type numeric.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert numeric $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsNumeric
+	 */
+	function assertIsNumeric($actual, string $message = ''): void
+	{
+		Assert::assertIsNumeric(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsObject')) {
-    /**
-     * Asserts that a variable is of type object.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert object $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsObject
-     */
-    function assertIsObject($actual, string $message = ''): void
-    {
-        Assert::assertIsObject(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is of type object.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert object $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsObject
+	 */
+	function assertIsObject($actual, string $message = ''): void
+	{
+		Assert::assertIsObject(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsResource')) {
-    /**
-     * Asserts that a variable is of type resource.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert resource $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsResource
-     */
-    function assertIsResource($actual, string $message = ''): void
-    {
-        Assert::assertIsResource(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is of type resource.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert resource $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsResource
+	 */
+	function assertIsResource($actual, string $message = ''): void
+	{
+		Assert::assertIsResource(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsClosedResource')) {
-    /**
-     * Asserts that a variable is of type resource and is closed.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert resource $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsClosedResource
-     */
-    function assertIsClosedResource($actual, string $message = ''): void
-    {
-        Assert::assertIsClosedResource(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is of type resource and is closed.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert resource $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsClosedResource
+	 */
+	function assertIsClosedResource($actual, string $message = ''): void
+	{
+		Assert::assertIsClosedResource(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsString')) {
-    /**
-     * Asserts that a variable is of type string.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert string $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsString
-     */
-    function assertIsString($actual, string $message = ''): void
-    {
-        Assert::assertIsString(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is of type string.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert string $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsString
+	 */
+	function assertIsString($actual, string $message = ''): void
+	{
+		Assert::assertIsString(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsScalar')) {
-    /**
-     * Asserts that a variable is of type scalar.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert scalar $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsScalar
-     */
-    function assertIsScalar($actual, string $message = ''): void
-    {
-        Assert::assertIsScalar(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is of type scalar.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert scalar $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsScalar
+	 */
+	function assertIsScalar($actual, string $message = ''): void
+	{
+		Assert::assertIsScalar(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsCallable')) {
-    /**
-     * Asserts that a variable is of type callable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert callable $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsCallable
-     */
-    function assertIsCallable($actual, string $message = ''): void
-    {
-        Assert::assertIsCallable(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is of type callable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert callable $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsCallable
+	 */
+	function assertIsCallable($actual, string $message = ''): void
+	{
+		Assert::assertIsCallable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsIterable')) {
-    /**
-     * Asserts that a variable is of type iterable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert iterable $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsIterable
-     */
-    function assertIsIterable($actual, string $message = ''): void
-    {
-        Assert::assertIsIterable(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is of type iterable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert iterable $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsIterable
+	 */
+	function assertIsIterable($actual, string $message = ''): void
+	{
+		Assert::assertIsIterable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsNotArray')) {
-    /**
-     * Asserts that a variable is not of type array.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert !array $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsNotArray
-     */
-    function assertIsNotArray($actual, string $message = ''): void
-    {
-        Assert::assertIsNotArray(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is not of type array.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert !array $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsNotArray
+	 */
+	function assertIsNotArray($actual, string $message = ''): void
+	{
+		Assert::assertIsNotArray(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsNotBool')) {
-    /**
-     * Asserts that a variable is not of type bool.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert !bool $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsNotBool
-     */
-    function assertIsNotBool($actual, string $message = ''): void
-    {
-        Assert::assertIsNotBool(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is not of type bool.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert !bool $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsNotBool
+	 */
+	function assertIsNotBool($actual, string $message = ''): void
+	{
+		Assert::assertIsNotBool(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsNotFloat')) {
-    /**
-     * Asserts that a variable is not of type float.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert !float $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsNotFloat
-     */
-    function assertIsNotFloat($actual, string $message = ''): void
-    {
-        Assert::assertIsNotFloat(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is not of type float.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert !float $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsNotFloat
+	 */
+	function assertIsNotFloat($actual, string $message = ''): void
+	{
+		Assert::assertIsNotFloat(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsNotInt')) {
-    /**
-     * Asserts that a variable is not of type int.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert !int $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsNotInt
-     */
-    function assertIsNotInt($actual, string $message = ''): void
-    {
-        Assert::assertIsNotInt(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is not of type int.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert !int $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsNotInt
+	 */
+	function assertIsNotInt($actual, string $message = ''): void
+	{
+		Assert::assertIsNotInt(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsNotNumeric')) {
-    /**
-     * Asserts that a variable is not of type numeric.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert !numeric $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsNotNumeric
-     */
-    function assertIsNotNumeric($actual, string $message = ''): void
-    {
-        Assert::assertIsNotNumeric(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is not of type numeric.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert !numeric $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsNotNumeric
+	 */
+	function assertIsNotNumeric($actual, string $message = ''): void
+	{
+		Assert::assertIsNotNumeric(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsNotObject')) {
-    /**
-     * Asserts that a variable is not of type object.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert !object $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsNotObject
-     */
-    function assertIsNotObject($actual, string $message = ''): void
-    {
-        Assert::assertIsNotObject(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is not of type object.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert !object $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsNotObject
+	 */
+	function assertIsNotObject($actual, string $message = ''): void
+	{
+		Assert::assertIsNotObject(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsNotResource')) {
-    /**
-     * Asserts that a variable is not of type resource.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert !resource $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsNotResource
-     */
-    function assertIsNotResource($actual, string $message = ''): void
-    {
-        Assert::assertIsNotResource(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is not of type resource.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert !resource $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsNotResource
+	 */
+	function assertIsNotResource($actual, string $message = ''): void
+	{
+		Assert::assertIsNotResource(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsNotClosedResource')) {
-    /**
-     * Asserts that a variable is not of type resource.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert !resource $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsNotClosedResource
-     */
-    function assertIsNotClosedResource($actual, string $message = ''): void
-    {
-        Assert::assertIsNotClosedResource(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is not of type resource.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert !resource $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsNotClosedResource
+	 */
+	function assertIsNotClosedResource($actual, string $message = ''): void
+	{
+		Assert::assertIsNotClosedResource(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsNotString')) {
-    /**
-     * Asserts that a variable is not of type string.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert !string $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsNotString
-     */
-    function assertIsNotString($actual, string $message = ''): void
-    {
-        Assert::assertIsNotString(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is not of type string.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert !string $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsNotString
+	 */
+	function assertIsNotString($actual, string $message = ''): void
+	{
+		Assert::assertIsNotString(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsNotScalar')) {
-    /**
-     * Asserts that a variable is not of type scalar.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert !scalar $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsNotScalar
-     */
-    function assertIsNotScalar($actual, string $message = ''): void
-    {
-        Assert::assertIsNotScalar(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is not of type scalar.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert !scalar $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsNotScalar
+	 */
+	function assertIsNotScalar($actual, string $message = ''): void
+	{
+		Assert::assertIsNotScalar(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsNotCallable')) {
-    /**
-     * Asserts that a variable is not of type callable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert !callable $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsNotCallable
-     */
-    function assertIsNotCallable($actual, string $message = ''): void
-    {
-        Assert::assertIsNotCallable(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is not of type callable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert !callable $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsNotCallable
+	 */
+	function assertIsNotCallable($actual, string $message = ''): void
+	{
+		Assert::assertIsNotCallable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertIsNotIterable')) {
-    /**
-     * Asserts that a variable is not of type iterable.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @psalm-assert !iterable $actual
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertIsNotIterable
-     */
-    function assertIsNotIterable($actual, string $message = ''): void
-    {
-        Assert::assertIsNotIterable(...func_get_args());
-    }
+	/**
+	 * Asserts that a variable is not of type iterable.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @psalm-assert !iterable $actual
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertIsNotIterable
+	 */
+	function assertIsNotIterable($actual, string $message = ''): void
+	{
+		Assert::assertIsNotIterable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertMatchesRegularExpression')) {
-    /**
-     * Asserts that a string matches a given regular expression.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertMatchesRegularExpression
-     */
-    function assertMatchesRegularExpression(string $pattern, string $string, string $message = ''): void
-    {
-        Assert::assertMatchesRegularExpression(...func_get_args());
-    }
+	/**
+	 * Asserts that a string matches a given regular expression.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertMatchesRegularExpression
+	 */
+	function assertMatchesRegularExpression(string $pattern, string $string, string $message = ''): void
+	{
+		Assert::assertMatchesRegularExpression(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertRegExp')) {
-    /**
-     * Asserts that a string matches a given regular expression.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4086
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertRegExp
-     */
-    function assertRegExp(string $pattern, string $string, string $message = ''): void
-    {
-        Assert::assertRegExp(...func_get_args());
-    }
+	/**
+	 * Asserts that a string matches a given regular expression.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4086
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertRegExp
+	 */
+	function assertRegExp(string $pattern, string $string, string $message = ''): void
+	{
+		Assert::assertRegExp(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertDoesNotMatchRegularExpression')) {
-    /**
-     * Asserts that a string does not match a given regular expression.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertDoesNotMatchRegularExpression
-     */
-    function assertDoesNotMatchRegularExpression(string $pattern, string $string, string $message = ''): void
-    {
-        Assert::assertDoesNotMatchRegularExpression(...func_get_args());
-    }
+	/**
+	 * Asserts that a string does not match a given regular expression.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertDoesNotMatchRegularExpression
+	 */
+	function assertDoesNotMatchRegularExpression(string $pattern, string $string, string $message = ''): void
+	{
+		Assert::assertDoesNotMatchRegularExpression(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotRegExp')) {
-    /**
-     * Asserts that a string does not match a given regular expression.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4089
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotRegExp
-     */
-    function assertNotRegExp(string $pattern, string $string, string $message = ''): void
-    {
-        Assert::assertNotRegExp(...func_get_args());
-    }
+	/**
+	 * Asserts that a string does not match a given regular expression.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4089
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotRegExp
+	 */
+	function assertNotRegExp(string $pattern, string $string, string $message = ''): void
+	{
+		Assert::assertNotRegExp(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertSameSize')) {
-    /**
-     * Assert that the size of two arrays (or `Countable` or `Traversable` objects)
-     * is the same.
-     *
-     * @param Countable|iterable $expected
-     * @param Countable|iterable $actual
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertSameSize
-     */
-    function assertSameSize($expected, $actual, string $message = ''): void
-    {
-        Assert::assertSameSize(...func_get_args());
-    }
+	/**
+	 * Assert that the size of two arrays (or `Countable` or `Traversable` objects)
+	 * is the same.
+	 *
+	 * @param Countable|iterable $expected
+	 * @param Countable|iterable $actual
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertSameSize
+	 */
+	function assertSameSize($expected, $actual, string $message = ''): void
+	{
+		Assert::assertSameSize(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertNotSameSize')) {
-    /**
-     * Assert that the size of two arrays (or `Countable` or `Traversable` objects)
-     * is not the same.
-     *
-     * @param Countable|iterable $expected
-     * @param Countable|iterable $actual
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertNotSameSize
-     */
-    function assertNotSameSize($expected, $actual, string $message = ''): void
-    {
-        Assert::assertNotSameSize(...func_get_args());
-    }
+	/**
+	 * Assert that the size of two arrays (or `Countable` or `Traversable` objects)
+	 * is not the same.
+	 *
+	 * @param Countable|iterable $expected
+	 * @param Countable|iterable $actual
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertNotSameSize
+	 */
+	function assertNotSameSize($expected, $actual, string $message = ''): void
+	{
+		Assert::assertNotSameSize(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringMatchesFormat')) {
-    /**
-     * Asserts that a string matches a given format string.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringMatchesFormat
-     */
-    function assertStringMatchesFormat(string $format, string $string, string $message = ''): void
-    {
-        Assert::assertStringMatchesFormat(...func_get_args());
-    }
+	/**
+	 * Asserts that a string matches a given format string.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringMatchesFormat
+	 */
+	function assertStringMatchesFormat(string $format, string $string, string $message = ''): void
+	{
+		Assert::assertStringMatchesFormat(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringNotMatchesFormat')) {
-    /**
-     * Asserts that a string does not match a given format string.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringNotMatchesFormat
-     */
-    function assertStringNotMatchesFormat(string $format, string $string, string $message = ''): void
-    {
-        Assert::assertStringNotMatchesFormat(...func_get_args());
-    }
+	/**
+	 * Asserts that a string does not match a given format string.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringNotMatchesFormat
+	 */
+	function assertStringNotMatchesFormat(string $format, string $string, string $message = ''): void
+	{
+		Assert::assertStringNotMatchesFormat(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringMatchesFormatFile')) {
-    /**
-     * Asserts that a string matches a given format file.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringMatchesFormatFile
-     */
-    function assertStringMatchesFormatFile(string $formatFile, string $string, string $message = ''): void
-    {
-        Assert::assertStringMatchesFormatFile(...func_get_args());
-    }
+	/**
+	 * Asserts that a string matches a given format file.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringMatchesFormatFile
+	 */
+	function assertStringMatchesFormatFile(string $formatFile, string $string, string $message = ''): void
+	{
+		Assert::assertStringMatchesFormatFile(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringNotMatchesFormatFile')) {
-    /**
-     * Asserts that a string does not match a given format string.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringNotMatchesFormatFile
-     */
-    function assertStringNotMatchesFormatFile(string $formatFile, string $string, string $message = ''): void
-    {
-        Assert::assertStringNotMatchesFormatFile(...func_get_args());
-    }
+	/**
+	 * Asserts that a string does not match a given format string.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringNotMatchesFormatFile
+	 */
+	function assertStringNotMatchesFormatFile(string $formatFile, string $string, string $message = ''): void
+	{
+		Assert::assertStringNotMatchesFormatFile(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringStartsWith')) {
-    /**
-     * Asserts that a string starts with a given prefix.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringStartsWith
-     */
-    function assertStringStartsWith(string $prefix, string $string, string $message = ''): void
-    {
-        Assert::assertStringStartsWith(...func_get_args());
-    }
+	/**
+	 * Asserts that a string starts with a given prefix.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringStartsWith
+	 */
+	function assertStringStartsWith(string $prefix, string $string, string $message = ''): void
+	{
+		Assert::assertStringStartsWith(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringStartsNotWith')) {
-    /**
-     * Asserts that a string starts not with a given prefix.
-     *
-     * @param string $prefix
-     * @param string $string
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringStartsNotWith
-     */
-    function assertStringStartsNotWith($prefix, $string, string $message = ''): void
-    {
-        Assert::assertStringStartsNotWith(...func_get_args());
-    }
+	/**
+	 * Asserts that a string starts not with a given prefix.
+	 *
+	 * @param string $prefix
+	 * @param string $string
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringStartsNotWith
+	 */
+	function assertStringStartsNotWith($prefix, $string, string $message = ''): void
+	{
+		Assert::assertStringStartsNotWith(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringContainsString')) {
-    /**
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringContainsString
-     */
-    function assertStringContainsString(string $needle, string $haystack, string $message = ''): void
-    {
-        Assert::assertStringContainsString(...func_get_args());
-    }
+	/**
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringContainsString
+	 */
+	function assertStringContainsString(string $needle, string $haystack, string $message = ''): void
+	{
+		Assert::assertStringContainsString(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringContainsStringIgnoringCase')) {
-    /**
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringContainsStringIgnoringCase
-     */
-    function assertStringContainsStringIgnoringCase(string $needle, string $haystack, string $message = ''): void
-    {
-        Assert::assertStringContainsStringIgnoringCase(...func_get_args());
-    }
+	/**
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringContainsStringIgnoringCase
+	 */
+	function assertStringContainsStringIgnoringCase(string $needle, string $haystack, string $message = ''): void
+	{
+		Assert::assertStringContainsStringIgnoringCase(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringNotContainsString')) {
-    /**
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringNotContainsString
-     */
-    function assertStringNotContainsString(string $needle, string $haystack, string $message = ''): void
-    {
-        Assert::assertStringNotContainsString(...func_get_args());
-    }
+	/**
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringNotContainsString
+	 */
+	function assertStringNotContainsString(string $needle, string $haystack, string $message = ''): void
+	{
+		Assert::assertStringNotContainsString(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringNotContainsStringIgnoringCase')) {
-    /**
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringNotContainsStringIgnoringCase
-     */
-    function assertStringNotContainsStringIgnoringCase(string $needle, string $haystack, string $message = ''): void
-    {
-        Assert::assertStringNotContainsStringIgnoringCase(...func_get_args());
-    }
+	/**
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringNotContainsStringIgnoringCase
+	 */
+	function assertStringNotContainsStringIgnoringCase(string $needle, string $haystack, string $message = ''): void
+	{
+		Assert::assertStringNotContainsStringIgnoringCase(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringEndsWith')) {
-    /**
-     * Asserts that a string ends with a given suffix.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringEndsWith
-     */
-    function assertStringEndsWith(string $suffix, string $string, string $message = ''): void
-    {
-        Assert::assertStringEndsWith(...func_get_args());
-    }
+	/**
+	 * Asserts that a string ends with a given suffix.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringEndsWith
+	 */
+	function assertStringEndsWith(string $suffix, string $string, string $message = ''): void
+	{
+		Assert::assertStringEndsWith(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertStringEndsNotWith')) {
-    /**
-     * Asserts that a string ends not with a given suffix.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertStringEndsNotWith
-     */
-    function assertStringEndsNotWith(string $suffix, string $string, string $message = ''): void
-    {
-        Assert::assertStringEndsNotWith(...func_get_args());
-    }
+	/**
+	 * Asserts that a string ends not with a given suffix.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertStringEndsNotWith
+	 */
+	function assertStringEndsNotWith(string $suffix, string $string, string $message = ''): void
+	{
+		Assert::assertStringEndsNotWith(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertXmlFileEqualsXmlFile')) {
-    /**
-     * Asserts that two XML files are equal.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertXmlFileEqualsXmlFile
-     */
-    function assertXmlFileEqualsXmlFile(string $expectedFile, string $actualFile, string $message = ''): void
-    {
-        Assert::assertXmlFileEqualsXmlFile(...func_get_args());
-    }
+	/**
+	 * Asserts that two XML files are equal.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertXmlFileEqualsXmlFile
+	 */
+	function assertXmlFileEqualsXmlFile(string $expectedFile, string $actualFile, string $message = ''): void
+	{
+		Assert::assertXmlFileEqualsXmlFile(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertXmlFileNotEqualsXmlFile')) {
-    /**
-     * Asserts that two XML files are not equal.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws \PHPUnit\Util\Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertXmlFileNotEqualsXmlFile
-     */
-    function assertXmlFileNotEqualsXmlFile(string $expectedFile, string $actualFile, string $message = ''): void
-    {
-        Assert::assertXmlFileNotEqualsXmlFile(...func_get_args());
-    }
+	/**
+	 * Asserts that two XML files are not equal.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws \PHPUnit\Util\Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertXmlFileNotEqualsXmlFile
+	 */
+	function assertXmlFileNotEqualsXmlFile(string $expectedFile, string $actualFile, string $message = ''): void
+	{
+		Assert::assertXmlFileNotEqualsXmlFile(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertXmlStringEqualsXmlFile')) {
-    /**
-     * Asserts that two XML documents are equal.
-     *
-     * @param DOMDocument|string $actualXml
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws \PHPUnit\Util\Xml\Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertXmlStringEqualsXmlFile
-     */
-    function assertXmlStringEqualsXmlFile(string $expectedFile, $actualXml, string $message = ''): void
-    {
-        Assert::assertXmlStringEqualsXmlFile(...func_get_args());
-    }
+	/**
+	 * Asserts that two XML documents are equal.
+	 *
+	 * @param DOMDocument|string $actualXml
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws \PHPUnit\Util\Xml\Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertXmlStringEqualsXmlFile
+	 */
+	function assertXmlStringEqualsXmlFile(string $expectedFile, $actualXml, string $message = ''): void
+	{
+		Assert::assertXmlStringEqualsXmlFile(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertXmlStringNotEqualsXmlFile')) {
-    /**
-     * Asserts that two XML documents are not equal.
-     *
-     * @param DOMDocument|string $actualXml
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws \PHPUnit\Util\Xml\Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertXmlStringNotEqualsXmlFile
-     */
-    function assertXmlStringNotEqualsXmlFile(string $expectedFile, $actualXml, string $message = ''): void
-    {
-        Assert::assertXmlStringNotEqualsXmlFile(...func_get_args());
-    }
+	/**
+	 * Asserts that two XML documents are not equal.
+	 *
+	 * @param DOMDocument|string $actualXml
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws \PHPUnit\Util\Xml\Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertXmlStringNotEqualsXmlFile
+	 */
+	function assertXmlStringNotEqualsXmlFile(string $expectedFile, $actualXml, string $message = ''): void
+	{
+		Assert::assertXmlStringNotEqualsXmlFile(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertXmlStringEqualsXmlString')) {
-    /**
-     * Asserts that two XML documents are equal.
-     *
-     * @param DOMDocument|string $expectedXml
-     * @param DOMDocument|string $actualXml
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws \PHPUnit\Util\Xml\Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertXmlStringEqualsXmlString
-     */
-    function assertXmlStringEqualsXmlString($expectedXml, $actualXml, string $message = ''): void
-    {
-        Assert::assertXmlStringEqualsXmlString(...func_get_args());
-    }
+	/**
+	 * Asserts that two XML documents are equal.
+	 *
+	 * @param DOMDocument|string $expectedXml
+	 * @param DOMDocument|string $actualXml
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws \PHPUnit\Util\Xml\Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertXmlStringEqualsXmlString
+	 */
+	function assertXmlStringEqualsXmlString($expectedXml, $actualXml, string $message = ''): void
+	{
+		Assert::assertXmlStringEqualsXmlString(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertXmlStringNotEqualsXmlString')) {
-    /**
-     * Asserts that two XML documents are not equal.
-     *
-     * @param DOMDocument|string $expectedXml
-     * @param DOMDocument|string $actualXml
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws \PHPUnit\Util\Xml\Exception
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertXmlStringNotEqualsXmlString
-     */
-    function assertXmlStringNotEqualsXmlString($expectedXml, $actualXml, string $message = ''): void
-    {
-        Assert::assertXmlStringNotEqualsXmlString(...func_get_args());
-    }
+	/**
+	 * Asserts that two XML documents are not equal.
+	 *
+	 * @param DOMDocument|string $expectedXml
+	 * @param DOMDocument|string $actualXml
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws \PHPUnit\Util\Xml\Exception
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertXmlStringNotEqualsXmlString
+	 */
+	function assertXmlStringNotEqualsXmlString($expectedXml, $actualXml, string $message = ''): void
+	{
+		Assert::assertXmlStringNotEqualsXmlString(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertEqualXMLStructure')) {
-    /**
-     * Asserts that a hierarchy of DOMElements matches.
-     *
-     * @throws AssertionFailedError
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4091
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertEqualXMLStructure
-     */
-    function assertEqualXMLStructure(DOMElement $expectedElement, DOMElement $actualElement, bool $checkAttributes = false, string $message = ''): void
-    {
-        Assert::assertEqualXMLStructure(...func_get_args());
-    }
+	/**
+	 * Asserts that a hierarchy of DOMElements matches.
+	 *
+	 * @throws AssertionFailedError
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4091
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertEqualXMLStructure
+	 */
+	function assertEqualXMLStructure(DOMElement $expectedElement, DOMElement $actualElement, bool $checkAttributes = false, string $message = ''): void
+	{
+		Assert::assertEqualXMLStructure(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertThat')) {
-    /**
-     * Evaluates a PHPUnit\Framework\Constraint matcher object.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertThat
-     */
-    function assertThat($value, Constraint $constraint, string $message = ''): void
-    {
-        Assert::assertThat(...func_get_args());
-    }
+	/**
+	 * Evaluates a PHPUnit\Framework\Constraint matcher object.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertThat
+	 */
+	function assertThat($value, Constraint $constraint, string $message = ''): void
+	{
+		Assert::assertThat(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertJson')) {
-    /**
-     * Asserts that a string is a valid JSON string.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertJson
-     */
-    function assertJson(string $actualJson, string $message = ''): void
-    {
-        Assert::assertJson(...func_get_args());
-    }
+	/**
+	 * Asserts that a string is a valid JSON string.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertJson
+	 */
+	function assertJson(string $actualJson, string $message = ''): void
+	{
+		Assert::assertJson(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertJsonStringEqualsJsonString')) {
-    /**
-     * Asserts that two given JSON encoded objects or arrays are equal.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertJsonStringEqualsJsonString
-     */
-    function assertJsonStringEqualsJsonString(string $expectedJson, string $actualJson, string $message = ''): void
-    {
-        Assert::assertJsonStringEqualsJsonString(...func_get_args());
-    }
+	/**
+	 * Asserts that two given JSON encoded objects or arrays are equal.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertJsonStringEqualsJsonString
+	 */
+	function assertJsonStringEqualsJsonString(string $expectedJson, string $actualJson, string $message = ''): void
+	{
+		Assert::assertJsonStringEqualsJsonString(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertJsonStringNotEqualsJsonString')) {
-    /**
-     * Asserts that two given JSON encoded objects or arrays are not equal.
-     *
-     * @param string $expectedJson
-     * @param string $actualJson
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertJsonStringNotEqualsJsonString
-     */
-    function assertJsonStringNotEqualsJsonString($expectedJson, $actualJson, string $message = ''): void
-    {
-        Assert::assertJsonStringNotEqualsJsonString(...func_get_args());
-    }
+	/**
+	 * Asserts that two given JSON encoded objects or arrays are not equal.
+	 *
+	 * @param string $expectedJson
+	 * @param string $actualJson
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertJsonStringNotEqualsJsonString
+	 */
+	function assertJsonStringNotEqualsJsonString($expectedJson, $actualJson, string $message = ''): void
+	{
+		Assert::assertJsonStringNotEqualsJsonString(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertJsonStringEqualsJsonFile')) {
-    /**
-     * Asserts that the generated JSON encoded object and the content of the given file are equal.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertJsonStringEqualsJsonFile
-     */
-    function assertJsonStringEqualsJsonFile(string $expectedFile, string $actualJson, string $message = ''): void
-    {
-        Assert::assertJsonStringEqualsJsonFile(...func_get_args());
-    }
+	/**
+	 * Asserts that the generated JSON encoded object and the content of the given file are equal.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertJsonStringEqualsJsonFile
+	 */
+	function assertJsonStringEqualsJsonFile(string $expectedFile, string $actualJson, string $message = ''): void
+	{
+		Assert::assertJsonStringEqualsJsonFile(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertJsonStringNotEqualsJsonFile')) {
-    /**
-     * Asserts that the generated JSON encoded object and the content of the given file are not equal.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertJsonStringNotEqualsJsonFile
-     */
-    function assertJsonStringNotEqualsJsonFile(string $expectedFile, string $actualJson, string $message = ''): void
-    {
-        Assert::assertJsonStringNotEqualsJsonFile(...func_get_args());
-    }
+	/**
+	 * Asserts that the generated JSON encoded object and the content of the given file are not equal.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertJsonStringNotEqualsJsonFile
+	 */
+	function assertJsonStringNotEqualsJsonFile(string $expectedFile, string $actualJson, string $message = ''): void
+	{
+		Assert::assertJsonStringNotEqualsJsonFile(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertJsonFileEqualsJsonFile')) {
-    /**
-     * Asserts that two JSON files are equal.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertJsonFileEqualsJsonFile
-     */
-    function assertJsonFileEqualsJsonFile(string $expectedFile, string $actualFile, string $message = ''): void
-    {
-        Assert::assertJsonFileEqualsJsonFile(...func_get_args());
-    }
+	/**
+	 * Asserts that two JSON files are equal.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertJsonFileEqualsJsonFile
+	 */
+	function assertJsonFileEqualsJsonFile(string $expectedFile, string $actualFile, string $message = ''): void
+	{
+		Assert::assertJsonFileEqualsJsonFile(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\assertJsonFileNotEqualsJsonFile')) {
-    /**
-     * Asserts that two JSON files are not equal.
-     *
-     * @throws ExpectationFailedException
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     *
-     * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
-     *
-     * @see Assert::assertJsonFileNotEqualsJsonFile
-     */
-    function assertJsonFileNotEqualsJsonFile(string $expectedFile, string $actualFile, string $message = ''): void
-    {
-        Assert::assertJsonFileNotEqualsJsonFile(...func_get_args());
-    }
+	/**
+	 * Asserts that two JSON files are not equal.
+	 *
+	 * @throws ExpectationFailedException
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 *
+	 * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+	 *
+	 * @see Assert::assertJsonFileNotEqualsJsonFile
+	 */
+	function assertJsonFileNotEqualsJsonFile(string $expectedFile, string $actualFile, string $message = ''): void
+	{
+		Assert::assertJsonFileNotEqualsJsonFile(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\logicalAnd')) {
-    function logicalAnd(): LogicalAnd
-    {
-        return Assert::logicalAnd(...func_get_args());
-    }
+	function logicalAnd(): LogicalAnd
+	{
+		return Assert::logicalAnd(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\logicalOr')) {
-    function logicalOr(): LogicalOr
-    {
-        return Assert::logicalOr(...func_get_args());
-    }
+	function logicalOr(): LogicalOr
+	{
+		return Assert::logicalOr(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\logicalNot')) {
-    function logicalNot(Constraint $constraint): LogicalNot
-    {
-        return Assert::logicalNot(...func_get_args());
-    }
+	function logicalNot(Constraint $constraint): LogicalNot
+	{
+		return Assert::logicalNot(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\logicalXor')) {
-    function logicalXor(): LogicalXor
-    {
-        return Assert::logicalXor(...func_get_args());
-    }
+	function logicalXor(): LogicalXor
+	{
+		return Assert::logicalXor(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\anything')) {
-    function anything(): IsAnything
-    {
-        return Assert::anything(...func_get_args());
-    }
+	function anything(): IsAnything
+	{
+		return Assert::anything(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\isTrue')) {
-    function isTrue(): IsTrue
-    {
-        return Assert::isTrue(...func_get_args());
-    }
+	function isTrue(): IsTrue
+	{
+		return Assert::isTrue(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\callback')) {
-    function callback(callable $callback): Callback
-    {
-        return Assert::callback(...func_get_args());
-    }
+	function callback(callable $callback): Callback
+	{
+		return Assert::callback(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\isFalse')) {
-    function isFalse(): IsFalse
-    {
-        return Assert::isFalse(...func_get_args());
-    }
+	function isFalse(): IsFalse
+	{
+		return Assert::isFalse(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\isJson')) {
-    function isJson(): IsJson
-    {
-        return Assert::isJson(...func_get_args());
-    }
+	function isJson(): IsJson
+	{
+		return Assert::isJson(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\isNull')) {
-    function isNull(): IsNull
-    {
-        return Assert::isNull(...func_get_args());
-    }
+	function isNull(): IsNull
+	{
+		return Assert::isNull(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\isFinite')) {
-    function isFinite(): IsFinite
-    {
-        return Assert::isFinite(...func_get_args());
-    }
+	function isFinite(): IsFinite
+	{
+		return Assert::isFinite(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\isInfinite')) {
-    function isInfinite(): IsInfinite
-    {
-        return Assert::isInfinite(...func_get_args());
-    }
+	function isInfinite(): IsInfinite
+	{
+		return Assert::isInfinite(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\isNan')) {
-    function isNan(): IsNan
-    {
-        return Assert::isNan(...func_get_args());
-    }
+	function isNan(): IsNan
+	{
+		return Assert::isNan(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\containsEqual')) {
-    function containsEqual($value): TraversableContainsEqual
-    {
-        return Assert::containsEqual(...func_get_args());
-    }
+	function containsEqual($value): TraversableContainsEqual
+	{
+		return Assert::containsEqual(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\containsIdentical')) {
-    function containsIdentical($value): TraversableContainsIdentical
-    {
-        return Assert::containsIdentical(...func_get_args());
-    }
+	function containsIdentical($value): TraversableContainsIdentical
+	{
+		return Assert::containsIdentical(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\containsOnly')) {
-    function containsOnly(string $type): TraversableContainsOnly
-    {
-        return Assert::containsOnly(...func_get_args());
-    }
+	function containsOnly(string $type): TraversableContainsOnly
+	{
+		return Assert::containsOnly(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\containsOnlyInstancesOf')) {
-    function containsOnlyInstancesOf(string $className): TraversableContainsOnly
-    {
-        return Assert::containsOnlyInstancesOf(...func_get_args());
-    }
+	function containsOnlyInstancesOf(string $className): TraversableContainsOnly
+	{
+		return Assert::containsOnlyInstancesOf(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\arrayHasKey')) {
-    function arrayHasKey($key): ArrayHasKey
-    {
-        return Assert::arrayHasKey(...func_get_args());
-    }
+	function arrayHasKey($key): ArrayHasKey
+	{
+		return Assert::arrayHasKey(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\equalTo')) {
-    function equalTo($value): IsEqual
-    {
-        return Assert::equalTo(...func_get_args());
-    }
+	function equalTo($value): IsEqual
+	{
+		return Assert::equalTo(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\equalToCanonicalizing')) {
-    function equalToCanonicalizing($value): IsEqualCanonicalizing
-    {
-        return Assert::equalToCanonicalizing(...func_get_args());
-    }
+	function equalToCanonicalizing($value): IsEqualCanonicalizing
+	{
+		return Assert::equalToCanonicalizing(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\equalToIgnoringCase')) {
-    function equalToIgnoringCase($value): IsEqualIgnoringCase
-    {
-        return Assert::equalToIgnoringCase(...func_get_args());
-    }
+	function equalToIgnoringCase($value): IsEqualIgnoringCase
+	{
+		return Assert::equalToIgnoringCase(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\equalToWithDelta')) {
-    function equalToWithDelta($value, float $delta): IsEqualWithDelta
-    {
-        return Assert::equalToWithDelta(...func_get_args());
-    }
+	function equalToWithDelta($value, float $delta): IsEqualWithDelta
+	{
+		return Assert::equalToWithDelta(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\isEmpty')) {
-    function isEmpty(): IsEmpty
-    {
-        return Assert::isEmpty(...func_get_args());
-    }
+	function isEmpty(): IsEmpty
+	{
+		return Assert::isEmpty(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\isWritable')) {
-    function isWritable(): IsWritable
-    {
-        return Assert::isWritable(...func_get_args());
-    }
+	function isWritable(): IsWritable
+	{
+		return Assert::isWritable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\isReadable')) {
-    function isReadable(): IsReadable
-    {
-        return Assert::isReadable(...func_get_args());
-    }
+	function isReadable(): IsReadable
+	{
+		return Assert::isReadable(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\directoryExists')) {
-    function directoryExists(): DirectoryExists
-    {
-        return Assert::directoryExists(...func_get_args());
-    }
+	function directoryExists(): DirectoryExists
+	{
+		return Assert::directoryExists(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\fileExists')) {
-    function fileExists(): FileExists
-    {
-        return Assert::fileExists(...func_get_args());
-    }
+	function fileExists(): FileExists
+	{
+		return Assert::fileExists(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\greaterThan')) {
-    function greaterThan($value): GreaterThan
-    {
-        return Assert::greaterThan(...func_get_args());
-    }
+	function greaterThan($value): GreaterThan
+	{
+		return Assert::greaterThan(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\greaterThanOrEqual')) {
-    function greaterThanOrEqual($value): LogicalOr
-    {
-        return Assert::greaterThanOrEqual(...func_get_args());
-    }
+	function greaterThanOrEqual($value): LogicalOr
+	{
+		return Assert::greaterThanOrEqual(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\classHasAttribute')) {
-    function classHasAttribute(string $attributeName): ClassHasAttribute
-    {
-        return Assert::classHasAttribute(...func_get_args());
-    }
+	function classHasAttribute(string $attributeName): ClassHasAttribute
+	{
+		return Assert::classHasAttribute(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\classHasStaticAttribute')) {
-    function classHasStaticAttribute(string $attributeName): ClassHasStaticAttribute
-    {
-        return Assert::classHasStaticAttribute(...func_get_args());
-    }
+	function classHasStaticAttribute(string $attributeName): ClassHasStaticAttribute
+	{
+		return Assert::classHasStaticAttribute(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\objectHasAttribute')) {
-    function objectHasAttribute($attributeName): ObjectHasAttribute
-    {
-        return Assert::objectHasAttribute(...func_get_args());
-    }
+	function objectHasAttribute($attributeName): ObjectHasAttribute
+	{
+		return Assert::objectHasAttribute(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\identicalTo')) {
-    function identicalTo($value): IsIdentical
-    {
-        return Assert::identicalTo(...func_get_args());
-    }
+	function identicalTo($value): IsIdentical
+	{
+		return Assert::identicalTo(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\isInstanceOf')) {
-    function isInstanceOf(string $className): IsInstanceOf
-    {
-        return Assert::isInstanceOf(...func_get_args());
-    }
+	function isInstanceOf(string $className): IsInstanceOf
+	{
+		return Assert::isInstanceOf(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\isType')) {
-    function isType(string $type): IsType
-    {
-        return Assert::isType(...func_get_args());
-    }
+	function isType(string $type): IsType
+	{
+		return Assert::isType(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\lessThan')) {
-    function lessThan($value): LessThan
-    {
-        return Assert::lessThan(...func_get_args());
-    }
+	function lessThan($value): LessThan
+	{
+		return Assert::lessThan(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\lessThanOrEqual')) {
-    function lessThanOrEqual($value): LogicalOr
-    {
-        return Assert::lessThanOrEqual(...func_get_args());
-    }
+	function lessThanOrEqual($value): LogicalOr
+	{
+		return Assert::lessThanOrEqual(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\matchesRegularExpression')) {
-    function matchesRegularExpression(string $pattern): RegularExpression
-    {
-        return Assert::matchesRegularExpression(...func_get_args());
-    }
+	function matchesRegularExpression(string $pattern): RegularExpression
+	{
+		return Assert::matchesRegularExpression(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\matches')) {
-    function matches(string $string): StringMatchesFormatDescription
-    {
-        return Assert::matches(...func_get_args());
-    }
+	function matches(string $string): StringMatchesFormatDescription
+	{
+		return Assert::matches(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\stringStartsWith')) {
-    function stringStartsWith($prefix): StringStartsWith
-    {
-        return Assert::stringStartsWith(...func_get_args());
-    }
+	function stringStartsWith($prefix): StringStartsWith
+	{
+		return Assert::stringStartsWith(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\stringContains')) {
-    function stringContains(string $string, bool $case = true): StringContains
-    {
-        return Assert::stringContains(...func_get_args());
-    }
+	function stringContains(string $string, bool $case = true): StringContains
+	{
+		return Assert::stringContains(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\stringEndsWith')) {
-    function stringEndsWith(string $suffix): StringEndsWith
-    {
-        return Assert::stringEndsWith(...func_get_args());
-    }
+	function stringEndsWith(string $suffix): StringEndsWith
+	{
+		return Assert::stringEndsWith(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\countOf')) {
-    function countOf(int $count): Count
-    {
-        return Assert::countOf(...func_get_args());
-    }
+	function countOf(int $count): Count
+	{
+		return Assert::countOf(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\objectEquals')) {
-    function objectEquals(object $object, string $method = 'equals'): ObjectEquals
-    {
-        return Assert::objectEquals(...func_get_args());
-    }
+	function objectEquals(object $object, string $method = 'equals'): ObjectEquals
+	{
+		return Assert::objectEquals(...func_get_args());
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\any')) {
-    /**
-     * Returns a matcher that matches when the method is executed
-     * zero or more times.
-     */
-    function any(): AnyInvokedCountMatcher
-    {
-        return new AnyInvokedCountMatcher;
-    }
+	/**
+	 * Returns a matcher that matches when the method is executed
+	 * zero or more times.
+	 */
+	function any(): AnyInvokedCountMatcher
+	{
+		return new AnyInvokedCountMatcher;
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\never')) {
-    /**
-     * Returns a matcher that matches when the method is never executed.
-     */
-    function never(): InvokedCountMatcher
-    {
-        return new InvokedCountMatcher(0);
-    }
+	/**
+	 * Returns a matcher that matches when the method is never executed.
+	 */
+	function never(): InvokedCountMatcher
+	{
+		return new InvokedCountMatcher(0);
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\atLeast')) {
-    /**
-     * Returns a matcher that matches when the method is executed
-     * at least N times.
-     */
-    function atLeast(int $requiredInvocations): InvokedAtLeastCountMatcher
-    {
-        return new InvokedAtLeastCountMatcher(
-            $requiredInvocations
-        );
-    }
+	/**
+	 * Returns a matcher that matches when the method is executed
+	 * at least N times.
+	 */
+	function atLeast(int $requiredInvocations): InvokedAtLeastCountMatcher
+	{
+		return new InvokedAtLeastCountMatcher(
+			$requiredInvocations
+		);
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\atLeastOnce')) {
-    /**
-     * Returns a matcher that matches when the method is executed at least once.
-     */
-    function atLeastOnce(): InvokedAtLeastOnceMatcher
-    {
-        return new InvokedAtLeastOnceMatcher;
-    }
+	/**
+	 * Returns a matcher that matches when the method is executed at least once.
+	 */
+	function atLeastOnce(): InvokedAtLeastOnceMatcher
+	{
+		return new InvokedAtLeastOnceMatcher;
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\once')) {
-    /**
-     * Returns a matcher that matches when the method is executed exactly once.
-     */
-    function once(): InvokedCountMatcher
-    {
-        return new InvokedCountMatcher(1);
-    }
+	/**
+	 * Returns a matcher that matches when the method is executed exactly once.
+	 */
+	function once(): InvokedCountMatcher
+	{
+		return new InvokedCountMatcher(1);
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\exactly')) {
-    /**
-     * Returns a matcher that matches when the method is executed
-     * exactly $count times.
-     */
-    function exactly(int $count): InvokedCountMatcher
-    {
-        return new InvokedCountMatcher($count);
-    }
+	/**
+	 * Returns a matcher that matches when the method is executed
+	 * exactly $count times.
+	 */
+	function exactly(int $count): InvokedCountMatcher
+	{
+		return new InvokedCountMatcher($count);
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\atMost')) {
-    /**
-     * Returns a matcher that matches when the method is executed
-     * at most N times.
-     */
-    function atMost(int $allowedInvocations): InvokedAtMostCountMatcher
-    {
-        return new InvokedAtMostCountMatcher($allowedInvocations);
-    }
+	/**
+	 * Returns a matcher that matches when the method is executed
+	 * at most N times.
+	 */
+	function atMost(int $allowedInvocations): InvokedAtMostCountMatcher
+	{
+		return new InvokedAtMostCountMatcher($allowedInvocations);
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\at')) {
-    /**
-     * Returns a matcher that matches when the method is executed
-     * at the given index.
-     */
-    function at(int $index): InvokedAtIndexMatcher
-    {
-        return new InvokedAtIndexMatcher($index);
-    }
+	/**
+	 * Returns a matcher that matches when the method is executed
+	 * at the given index.
+	 */
+	function at(int $index): InvokedAtIndexMatcher
+	{
+		return new InvokedAtIndexMatcher($index);
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\returnValue')) {
-    function returnValue($value): ReturnStub
-    {
-        return new ReturnStub($value);
-    }
+	function returnValue($value): ReturnStub
+	{
+		return new ReturnStub($value);
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\returnValueMap')) {
-    function returnValueMap(array $valueMap): ReturnValueMapStub
-    {
-        return new ReturnValueMapStub($valueMap);
-    }
+	function returnValueMap(array $valueMap): ReturnValueMapStub
+	{
+		return new ReturnValueMapStub($valueMap);
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\returnArgument')) {
-    function returnArgument(int $argumentIndex): ReturnArgumentStub
-    {
-        return new ReturnArgumentStub($argumentIndex);
-    }
+	function returnArgument(int $argumentIndex): ReturnArgumentStub
+	{
+		return new ReturnArgumentStub($argumentIndex);
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\returnCallback')) {
-    function returnCallback($callback): ReturnCallbackStub
-    {
-        return new ReturnCallbackStub($callback);
-    }
+	function returnCallback($callback): ReturnCallbackStub
+	{
+		return new ReturnCallbackStub($callback);
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\returnSelf')) {
-    /**
-     * Returns the current object.
-     *
-     * This method is useful when mocking a fluent interface.
-     */
-    function returnSelf(): ReturnSelfStub
-    {
-        return new ReturnSelfStub;
-    }
+	/**
+	 * Returns the current object.
+	 *
+	 * This method is useful when mocking a fluent interface.
+	 */
+	function returnSelf(): ReturnSelfStub
+	{
+		return new ReturnSelfStub;
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\throwException')) {
-    function throwException(Throwable $exception): ExceptionStub
-    {
-        return new ExceptionStub($exception);
-    }
+	function throwException(Throwable $exception): ExceptionStub
+	{
+		return new ExceptionStub($exception);
+	}
 }
 
 if (!function_exists('PHPUnit\Framework\onConsecutiveCalls')) {
-    function onConsecutiveCalls(): ConsecutiveCallsStub
-    {
-        $args = func_get_args();
+	function onConsecutiveCalls(): ConsecutiveCallsStub
+	{
+		$args = func_get_args();
 
-        return new ConsecutiveCallsStub($args);
-    }
+		return new ConsecutiveCallsStub($args);
+	}
 }

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

Indentation +2767 added lines, -2767 removed lines

@@ -90,2771 +90,2771 @@
  */
 abstract class Assert
 {
-    /**
-     * @var int
-     */
-    private static $count = 0;
-
-    /**
-     * Asserts that an array has a specified key.
-     *
-     * @param int|string        $key
-     * @param array|ArrayAccess $array
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     */
-    public static function assertArrayHasKey($key, $array, string $message = ''): void
-    {
-        if (!(is_int($key) || is_string($key))) {
-            throw InvalidArgumentException::create(
-                1,
-                'integer or string'
-            );
-        }
-
-        if (!(is_array($array) || $array instanceof ArrayAccess)) {
-            throw InvalidArgumentException::create(
-                2,
-                'array or ArrayAccess'
-            );
-        }
-
-        $constraint = new ArrayHasKey($key);
-
-        static::assertThat($array, $constraint, $message);
-    }
-
-    /**
-     * Asserts that an array does not have a specified key.
-     *
-     * @param int|string        $key
-     * @param array|ArrayAccess $array
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     */
-    public static function assertArrayNotHasKey($key, $array, string $message = ''): void
-    {
-        if (!(is_int($key) || is_string($key))) {
-            throw InvalidArgumentException::create(
-                1,
-                'integer or string'
-            );
-        }
-
-        if (!(is_array($array) || $array instanceof ArrayAccess)) {
-            throw InvalidArgumentException::create(
-                2,
-                'array or ArrayAccess'
-            );
-        }
-
-        $constraint = new LogicalNot(
-            new ArrayHasKey($key)
-        );
-
-        static::assertThat($array, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a haystack contains a needle.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     */
-    public static function assertContains($needle, iterable $haystack, string $message = ''): void
-    {
-        $constraint = new TraversableContainsIdentical($needle);
-
-        static::assertThat($haystack, $constraint, $message);
-    }
-
-    public static function assertContainsEquals($needle, iterable $haystack, string $message = ''): void
-    {
-        $constraint = new TraversableContainsEqual($needle);
-
-        static::assertThat($haystack, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a haystack does not contain a needle.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     */
-    public static function assertNotContains($needle, iterable $haystack, string $message = ''): void
-    {
-        $constraint = new LogicalNot(
-            new TraversableContainsIdentical($needle)
-        );
-
-        static::assertThat($haystack, $constraint, $message);
-    }
-
-    public static function assertNotContainsEquals($needle, iterable $haystack, string $message = ''): void
-    {
-        $constraint = new LogicalNot(new TraversableContainsEqual($needle));
-
-        static::assertThat($haystack, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a haystack contains only values of a given type.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertContainsOnly(string $type, iterable $haystack, ?bool $isNativeType = null, string $message = ''): void
-    {
-        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 class name.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertContainsOnlyInstancesOf(string $className, iterable $haystack, string $message = ''): void
-    {
-        static::assertThat(
-            $haystack,
-            new TraversableContainsOnly(
-                $className,
-                false
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a haystack does not contain only values of a given type.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertNotContainsOnly(string $type, iterable $haystack, ?bool $isNativeType = null, string $message = ''): void
-    {
-        if ($isNativeType === null) {
-            $isNativeType = Type::isType($type);
-        }
-
-        static::assertThat(
-            $haystack,
-            new LogicalNot(
-                new TraversableContainsOnly(
-                    $type,
-                    $isNativeType
-                )
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts the number of elements of an array, Countable or Traversable.
-     *
-     * @param Countable|iterable $haystack
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     */
-    public static function assertCount(int $expectedCount, $haystack, string $message = ''): void
-    {
-        if (!$haystack instanceof Countable && !is_iterable($haystack)) {
-            throw InvalidArgumentException::create(2, 'countable or iterable');
-        }
-
-        static::assertThat(
-            $haystack,
-            new Count($expectedCount),
-            $message
-        );
-    }
-
-    /**
-     * Asserts the number of elements of an array, Countable or Traversable.
-     *
-     * @param Countable|iterable $haystack
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     */
-    public static function assertNotCount(int $expectedCount, $haystack, string $message = ''): void
-    {
-        if (!$haystack instanceof Countable && !is_iterable($haystack)) {
-            throw InvalidArgumentException::create(2, 'countable or iterable');
-        }
-
-        $constraint = new LogicalNot(
-            new Count($expectedCount)
-        );
-
-        static::assertThat($haystack, $constraint, $message);
-    }
-
-    /**
-     * Asserts that two variables are equal.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertEquals($expected, $actual, string $message = ''): void
-    {
-        $constraint = new IsEqual($expected);
-
-        static::assertThat($actual, $constraint, $message);
-    }
-
-    /**
-     * Asserts that two variables are equal (canonicalizing).
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertEqualsCanonicalizing($expected, $actual, string $message = ''): void
-    {
-        $constraint = new IsEqualCanonicalizing($expected);
-
-        static::assertThat($actual, $constraint, $message);
-    }
-
-    /**
-     * Asserts that two variables are equal (ignoring case).
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertEqualsIgnoringCase($expected, $actual, string $message = ''): void
-    {
-        $constraint = new IsEqualIgnoringCase($expected);
-
-        static::assertThat($actual, $constraint, $message);
-    }
-
-    /**
-     * Asserts that two variables are equal (with delta).
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertEqualsWithDelta($expected, $actual, float $delta, string $message = ''): void
-    {
-        $constraint = new IsEqualWithDelta(
-            $expected,
-            $delta
-        );
-
-        static::assertThat($actual, $constraint, $message);
-    }
-
-    /**
-     * Asserts that two variables are not equal.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertNotEquals($expected, $actual, string $message = ''): void
-    {
-        $constraint = new LogicalNot(
-            new IsEqual($expected)
-        );
-
-        static::assertThat($actual, $constraint, $message);
-    }
-
-    /**
-     * Asserts that two variables are not equal (canonicalizing).
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertNotEqualsCanonicalizing($expected, $actual, string $message = ''): void
-    {
-        $constraint = new LogicalNot(
-            new IsEqualCanonicalizing($expected)
-        );
-
-        static::assertThat($actual, $constraint, $message);
-    }
-
-    /**
-     * Asserts that two variables are not equal (ignoring case).
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertNotEqualsIgnoringCase($expected, $actual, string $message = ''): void
-    {
-        $constraint = new LogicalNot(
-            new IsEqualIgnoringCase($expected)
-        );
-
-        static::assertThat($actual, $constraint, $message);
-    }
-
-    /**
-     * Asserts that two variables are not equal (with delta).
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertNotEqualsWithDelta($expected, $actual, float $delta, string $message = ''): void
-    {
-        $constraint = new LogicalNot(
-            new IsEqualWithDelta(
-                $expected,
-                $delta
-            )
-        );
-
-        static::assertThat($actual, $constraint, $message);
-    }
-
-    /**
-     * @throws ExpectationFailedException
-     */
-    public static function assertObjectEquals(object $expected, object $actual, string $method = 'equals', string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            static::objectEquals($expected, $method),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is empty.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert empty $actual
-     */
-    public static function assertEmpty($actual, string $message = ''): void
-    {
-        static::assertThat($actual, static::isEmpty(), $message);
-    }
-
-    /**
-     * Asserts that a variable is not empty.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert !empty $actual
-     */
-    public static function assertNotEmpty($actual, string $message = ''): void
-    {
-        static::assertThat($actual, static::logicalNot(static::isEmpty()), $message);
-    }
-
-    /**
-     * Asserts that a value is greater than another value.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertGreaterThan($expected, $actual, string $message = ''): void
-    {
-        static::assertThat($actual, static::greaterThan($expected), $message);
-    }
-
-    /**
-     * Asserts that a value is greater than or equal to another value.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertGreaterThanOrEqual($expected, $actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            static::greaterThanOrEqual($expected),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a value is smaller than another value.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertLessThan($expected, $actual, string $message = ''): void
-    {
-        static::assertThat($actual, static::lessThan($expected), $message);
-    }
-
-    /**
-     * Asserts that a value is smaller than or equal to another value.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertLessThanOrEqual($expected, $actual, string $message = ''): void
-    {
-        static::assertThat($actual, static::lessThanOrEqual($expected), $message);
-    }
-
-    /**
-     * Asserts that the contents of one file is equal to the contents of another
-     * file.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertFileEquals(string $expected, string $actual, string $message = ''): void
-    {
-        static::assertFileExists($expected, $message);
-        static::assertFileExists($actual, $message);
-
-        $constraint = new IsEqual(file_get_contents($expected));
-
-        static::assertThat(file_get_contents($actual), $constraint, $message);
-    }
-
-    /**
-     * Asserts that the contents of one file is equal to the contents of another
-     * file (canonicalizing).
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertFileEqualsCanonicalizing(string $expected, string $actual, string $message = ''): void
-    {
-        static::assertFileExists($expected, $message);
-        static::assertFileExists($actual, $message);
-
-        $constraint = new IsEqualCanonicalizing(
-            file_get_contents($expected)
-        );
-
-        static::assertThat(file_get_contents($actual), $constraint, $message);
-    }
-
-    /**
-     * Asserts that the contents of one file is equal to the contents of another
-     * file (ignoring case).
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertFileEqualsIgnoringCase(string $expected, string $actual, string $message = ''): void
-    {
-        static::assertFileExists($expected, $message);
-        static::assertFileExists($actual, $message);
-
-        $constraint = new IsEqualIgnoringCase(file_get_contents($expected));
-
-        static::assertThat(file_get_contents($actual), $constraint, $message);
-    }
-
-    /**
-     * Asserts that the contents of one file is not equal to the contents of
-     * another file.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertFileNotEquals(string $expected, string $actual, string $message = ''): void
-    {
-        static::assertFileExists($expected, $message);
-        static::assertFileExists($actual, $message);
-
-        $constraint = new LogicalNot(
-            new IsEqual(file_get_contents($expected))
-        );
-
-        static::assertThat(file_get_contents($actual), $constraint, $message);
-    }
-
-    /**
-     * Asserts that the contents of one file is not equal to the contents of another
-     * file (canonicalizing).
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertFileNotEqualsCanonicalizing(string $expected, string $actual, string $message = ''): void
-    {
-        static::assertFileExists($expected, $message);
-        static::assertFileExists($actual, $message);
-
-        $constraint = new LogicalNot(
-            new IsEqualCanonicalizing(file_get_contents($expected))
-        );
-
-        static::assertThat(file_get_contents($actual), $constraint, $message);
-    }
-
-    /**
-     * Asserts that the contents of one file is not equal to the contents of another
-     * file (ignoring case).
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertFileNotEqualsIgnoringCase(string $expected, string $actual, string $message = ''): void
-    {
-        static::assertFileExists($expected, $message);
-        static::assertFileExists($actual, $message);
-
-        $constraint = new LogicalNot(
-            new IsEqualIgnoringCase(file_get_contents($expected))
-        );
-
-        static::assertThat(file_get_contents($actual), $constraint, $message);
-    }
-
-    /**
-     * Asserts that the contents of a string is equal
-     * to the contents of a file.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringEqualsFile(string $expectedFile, string $actualString, string $message = ''): void
-    {
-        static::assertFileExists($expectedFile, $message);
-
-        $constraint = new IsEqual(file_get_contents($expectedFile));
-
-        static::assertThat($actualString, $constraint, $message);
-    }
-
-    /**
-     * Asserts that the contents of a string is equal
-     * to the contents of a file (canonicalizing).
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringEqualsFileCanonicalizing(string $expectedFile, string $actualString, string $message = ''): void
-    {
-        static::assertFileExists($expectedFile, $message);
-
-        $constraint = new IsEqualCanonicalizing(file_get_contents($expectedFile));
-
-        static::assertThat($actualString, $constraint, $message);
-    }
-
-    /**
-     * Asserts that the contents of a string is equal
-     * to the contents of a file (ignoring case).
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringEqualsFileIgnoringCase(string $expectedFile, string $actualString, string $message = ''): void
-    {
-        static::assertFileExists($expectedFile, $message);
-
-        $constraint = new IsEqualIgnoringCase(file_get_contents($expectedFile));
-
-        static::assertThat($actualString, $constraint, $message);
-    }
-
-    /**
-     * Asserts that the contents of a string is not equal
-     * to the contents of a file.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringNotEqualsFile(string $expectedFile, string $actualString, string $message = ''): void
-    {
-        static::assertFileExists($expectedFile, $message);
-
-        $constraint = new LogicalNot(
-            new IsEqual(file_get_contents($expectedFile))
-        );
-
-        static::assertThat($actualString, $constraint, $message);
-    }
-
-    /**
-     * Asserts that the contents of a string is not equal
-     * to the contents of a file (canonicalizing).
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringNotEqualsFileCanonicalizing(string $expectedFile, string $actualString, string $message = ''): void
-    {
-        static::assertFileExists($expectedFile, $message);
-
-        $constraint = new LogicalNot(
-            new IsEqualCanonicalizing(file_get_contents($expectedFile))
-        );
-
-        static::assertThat($actualString, $constraint, $message);
-    }
-
-    /**
-     * Asserts that the contents of a string is not equal
-     * to the contents of a file (ignoring case).
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringNotEqualsFileIgnoringCase(string $expectedFile, string $actualString, string $message = ''): void
-    {
-        static::assertFileExists($expectedFile, $message);
-
-        $constraint = new LogicalNot(
-            new IsEqualIgnoringCase(file_get_contents($expectedFile))
-        );
-
-        static::assertThat($actualString, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a file/dir is readable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertIsReadable(string $filename, string $message = ''): void
-    {
-        static::assertThat($filename, new IsReadable, $message);
-    }
-
-    /**
-     * Asserts that a file/dir exists and is not readable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertIsNotReadable(string $filename, string $message = ''): void
-    {
-        static::assertThat($filename, new LogicalNot(new IsReadable), $message);
-    }
-
-    /**
-     * Asserts that a file/dir exists and is not readable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4062
-     */
-    public static function assertNotIsReadable(string $filename, string $message = ''): void
-    {
-        self::createWarning('assertNotIsReadable() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertIsNotReadable() instead.');
-
-        static::assertThat($filename, new LogicalNot(new IsReadable), $message);
-    }
-
-    /**
-     * Asserts that a file/dir exists and is writable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertIsWritable(string $filename, string $message = ''): void
-    {
-        static::assertThat($filename, new IsWritable, $message);
-    }
-
-    /**
-     * Asserts that a file/dir exists and is not writable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertIsNotWritable(string $filename, string $message = ''): void
-    {
-        static::assertThat($filename, new LogicalNot(new IsWritable), $message);
-    }
-
-    /**
-     * Asserts that a file/dir exists and is not writable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4065
-     */
-    public static function assertNotIsWritable(string $filename, string $message = ''): void
-    {
-        self::createWarning('assertNotIsWritable() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertIsNotWritable() instead.');
-
-        static::assertThat($filename, new LogicalNot(new IsWritable), $message);
-    }
-
-    /**
-     * Asserts that a directory exists.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertDirectoryExists(string $directory, string $message = ''): void
-    {
-        static::assertThat($directory, new DirectoryExists, $message);
-    }
-
-    /**
-     * Asserts that a directory does not exist.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertDirectoryDoesNotExist(string $directory, string $message = ''): void
-    {
-        static::assertThat($directory, new LogicalNot(new DirectoryExists), $message);
-    }
-
-    /**
-     * Asserts that a directory does not exist.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4068
-     */
-    public static function assertDirectoryNotExists(string $directory, string $message = ''): void
-    {
-        self::createWarning('assertDirectoryNotExists() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertDirectoryDoesNotExist() instead.');
-
-        static::assertThat($directory, new LogicalNot(new DirectoryExists), $message);
-    }
-
-    /**
-     * Asserts that a directory exists and is readable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertDirectoryIsReadable(string $directory, string $message = ''): void
-    {
-        self::assertDirectoryExists($directory, $message);
-        self::assertIsReadable($directory, $message);
-    }
-
-    /**
-     * Asserts that a directory exists and is not readable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertDirectoryIsNotReadable(string $directory, string $message = ''): void
-    {
-        self::assertDirectoryExists($directory, $message);
-        self::assertIsNotReadable($directory, $message);
-    }
-
-    /**
-     * Asserts that a directory exists and is not readable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4071
-     */
-    public static function assertDirectoryNotIsReadable(string $directory, string $message = ''): void
-    {
-        self::createWarning('assertDirectoryNotIsReadable() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertDirectoryIsNotReadable() instead.');
-
-        self::assertDirectoryExists($directory, $message);
-        self::assertIsNotReadable($directory, $message);
-    }
-
-    /**
-     * Asserts that a directory exists and is writable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertDirectoryIsWritable(string $directory, string $message = ''): void
-    {
-        self::assertDirectoryExists($directory, $message);
-        self::assertIsWritable($directory, $message);
-    }
-
-    /**
-     * Asserts that a directory exists and is not writable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertDirectoryIsNotWritable(string $directory, string $message = ''): void
-    {
-        self::assertDirectoryExists($directory, $message);
-        self::assertIsNotWritable($directory, $message);
-    }
-
-    /**
-     * Asserts that a directory exists and is not writable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4074
-     */
-    public static function assertDirectoryNotIsWritable(string $directory, string $message = ''): void
-    {
-        self::createWarning('assertDirectoryNotIsWritable() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertDirectoryIsNotWritable() instead.');
-
-        self::assertDirectoryExists($directory, $message);
-        self::assertIsNotWritable($directory, $message);
-    }
-
-    /**
-     * Asserts that a file exists.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertFileExists(string $filename, string $message = ''): void
-    {
-        static::assertThat($filename, new FileExists, $message);
-    }
-
-    /**
-     * Asserts that a file does not exist.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertFileDoesNotExist(string $filename, string $message = ''): void
-    {
-        static::assertThat($filename, new LogicalNot(new FileExists), $message);
-    }
-
-    /**
-     * Asserts that a file does not exist.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4077
-     */
-    public static function assertFileNotExists(string $filename, string $message = ''): void
-    {
-        self::createWarning('assertFileNotExists() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertFileDoesNotExist() instead.');
-
-        static::assertThat($filename, new LogicalNot(new FileExists), $message);
-    }
-
-    /**
-     * Asserts that a file exists and is readable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertFileIsReadable(string $file, string $message = ''): void
-    {
-        self::assertFileExists($file, $message);
-        self::assertIsReadable($file, $message);
-    }
-
-    /**
-     * Asserts that a file exists and is not readable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertFileIsNotReadable(string $file, string $message = ''): void
-    {
-        self::assertFileExists($file, $message);
-        self::assertIsNotReadable($file, $message);
-    }
-
-    /**
-     * Asserts that a file exists and is not readable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4080
-     */
-    public static function assertFileNotIsReadable(string $file, string $message = ''): void
-    {
-        self::createWarning('assertFileNotIsReadable() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertFileIsNotReadable() instead.');
-
-        self::assertFileExists($file, $message);
-        self::assertIsNotReadable($file, $message);
-    }
-
-    /**
-     * Asserts that a file exists and is writable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertFileIsWritable(string $file, string $message = ''): void
-    {
-        self::assertFileExists($file, $message);
-        self::assertIsWritable($file, $message);
-    }
-
-    /**
-     * Asserts that a file exists and is not writable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertFileIsNotWritable(string $file, string $message = ''): void
-    {
-        self::assertFileExists($file, $message);
-        self::assertIsNotWritable($file, $message);
-    }
-
-    /**
-     * Asserts that a file exists and is not writable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4083
-     */
-    public static function assertFileNotIsWritable(string $file, string $message = ''): void
-    {
-        self::createWarning('assertFileNotIsWritable() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertFileIsNotWritable() instead.');
-
-        self::assertFileExists($file, $message);
-        self::assertIsNotWritable($file, $message);
-    }
-
-    /**
-     * Asserts that a condition is true.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert true $condition
-     */
-    public static function assertTrue($condition, string $message = ''): void
-    {
-        static::assertThat($condition, static::isTrue(), $message);
-    }
-
-    /**
-     * Asserts that a condition is not true.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert !true $condition
-     */
-    public static function assertNotTrue($condition, string $message = ''): void
-    {
-        static::assertThat($condition, static::logicalNot(static::isTrue()), $message);
-    }
-
-    /**
-     * Asserts that a condition is false.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert false $condition
-     */
-    public static function assertFalse($condition, string $message = ''): void
-    {
-        static::assertThat($condition, static::isFalse(), $message);
-    }
-
-    /**
-     * Asserts that a condition is not false.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert !false $condition
-     */
-    public static function assertNotFalse($condition, string $message = ''): void
-    {
-        static::assertThat($condition, static::logicalNot(static::isFalse()), $message);
-    }
-
-    /**
-     * Asserts that a variable is null.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert null $actual
-     */
-    public static function assertNull($actual, string $message = ''): void
-    {
-        static::assertThat($actual, static::isNull(), $message);
-    }
-
-    /**
-     * Asserts that a variable is not null.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert !null $actual
-     */
-    public static function assertNotNull($actual, string $message = ''): void
-    {
-        static::assertThat($actual, static::logicalNot(static::isNull()), $message);
-    }
-
-    /**
-     * Asserts that a variable is finite.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertFinite($actual, string $message = ''): void
-    {
-        static::assertThat($actual, static::isFinite(), $message);
-    }
-
-    /**
-     * Asserts that a variable is infinite.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertInfinite($actual, string $message = ''): void
-    {
-        static::assertThat($actual, static::isInfinite(), $message);
-    }
-
-    /**
-     * Asserts that a variable is nan.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertNan($actual, string $message = ''): void
-    {
-        static::assertThat($actual, static::isNan(), $message);
-    }
-
-    /**
-     * Asserts that a class has a specified attribute.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     */
-    public static function assertClassHasAttribute(string $attributeName, string $className, string $message = ''): void
-    {
-        if (!self::isValidClassAttributeName($attributeName)) {
-            throw InvalidArgumentException::create(1, 'valid attribute name');
-        }
-
-        if (!class_exists($className)) {
-            throw InvalidArgumentException::create(2, 'class name');
-        }
-
-        static::assertThat($className, new ClassHasAttribute($attributeName), $message);
-    }
-
-    /**
-     * Asserts that a class does not have a specified attribute.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     */
-    public static function assertClassNotHasAttribute(string $attributeName, string $className, string $message = ''): void
-    {
-        if (!self::isValidClassAttributeName($attributeName)) {
-            throw InvalidArgumentException::create(1, 'valid attribute name');
-        }
-
-        if (!class_exists($className)) {
-            throw InvalidArgumentException::create(2, 'class name');
-        }
-
-        static::assertThat(
-            $className,
-            new LogicalNot(
-                new ClassHasAttribute($attributeName)
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a class has a specified static attribute.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     */
-    public static function assertClassHasStaticAttribute(string $attributeName, string $className, string $message = ''): void
-    {
-        if (!self::isValidClassAttributeName($attributeName)) {
-            throw InvalidArgumentException::create(1, 'valid attribute name');
-        }
-
-        if (!class_exists($className)) {
-            throw InvalidArgumentException::create(2, 'class name');
-        }
-
-        static::assertThat(
-            $className,
-            new ClassHasStaticAttribute($attributeName),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a class does not have a specified static attribute.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     */
-    public static function assertClassNotHasStaticAttribute(string $attributeName, string $className, string $message = ''): void
-    {
-        if (!self::isValidClassAttributeName($attributeName)) {
-            throw InvalidArgumentException::create(1, 'valid attribute name');
-        }
-
-        if (!class_exists($className)) {
-            throw InvalidArgumentException::create(2, 'class name');
-        }
-
-        static::assertThat(
-            $className,
-            new LogicalNot(
-                new ClassHasStaticAttribute($attributeName)
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that an object has a specified attribute.
-     *
-     * @param object $object
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     */
-    public static function assertObjectHasAttribute(string $attributeName, $object, string $message = ''): void
-    {
-        if (!self::isValidObjectAttributeName($attributeName)) {
-            throw InvalidArgumentException::create(1, 'valid attribute name');
-        }
-
-        if (!is_object($object)) {
-            throw InvalidArgumentException::create(2, 'object');
-        }
-
-        static::assertThat(
-            $object,
-            new ObjectHasAttribute($attributeName),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that an object does not have a specified attribute.
-     *
-     * @param object $object
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     */
-    public static function assertObjectNotHasAttribute(string $attributeName, $object, string $message = ''): void
-    {
-        if (!self::isValidObjectAttributeName($attributeName)) {
-            throw InvalidArgumentException::create(1, 'valid attribute name');
-        }
-
-        if (!is_object($object)) {
-            throw InvalidArgumentException::create(2, 'object');
-        }
-
-        static::assertThat(
-            $object,
-            new LogicalNot(
-                new ObjectHasAttribute($attributeName)
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that two variables have the same type and value.
-     * Used on objects, it asserts that two variables reference
-     * the same object.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-template ExpectedType
-     *
-     * @psalm-param ExpectedType $expected
-     *
-     * @psalm-assert =ExpectedType $actual
-     */
-    public static function assertSame($expected, $actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new IsIdentical($expected),
-            $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.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertNotSame($expected, $actual, string $message = ''): void
-    {
-        if (is_bool($expected) && is_bool($actual)) {
-            static::assertNotEquals($expected, $actual, $message);
-        }
-
-        static::assertThat(
-            $actual,
-            new LogicalNot(
-                new IsIdentical($expected)
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is of a given type.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     *
-     * @psalm-template ExpectedType of object
-     *
-     * @psalm-param class-string<ExpectedType> $expected
-     *
-     * @psalm-assert =ExpectedType $actual
-     */
-    public static function assertInstanceOf(string $expected, $actual, string $message = ''): void
-    {
-        if (!class_exists($expected) && !interface_exists($expected)) {
-            throw InvalidArgumentException::create(1, 'class or interface name');
-        }
-
-        static::assertThat(
-            $actual,
-            new IsInstanceOf($expected),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is not of a given type.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     *
-     * @psalm-template ExpectedType of object
-     *
-     * @psalm-param class-string<ExpectedType> $expected
-     *
-     * @psalm-assert !ExpectedType $actual
-     */
-    public static function assertNotInstanceOf(string $expected, $actual, string $message = ''): void
-    {
-        if (!class_exists($expected) && !interface_exists($expected)) {
-            throw InvalidArgumentException::create(1, 'class or interface name');
-        }
-
-        static::assertThat(
-            $actual,
-            new LogicalNot(
-                new IsInstanceOf($expected)
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is of type array.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert array $actual
-     */
-    public static function assertIsArray($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new IsType(IsType::TYPE_ARRAY),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is of type bool.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert bool $actual
-     */
-    public static function assertIsBool($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new IsType(IsType::TYPE_BOOL),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is of type float.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert float $actual
-     */
-    public static function assertIsFloat($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new IsType(IsType::TYPE_FLOAT),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is of type int.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert int $actual
-     */
-    public static function assertIsInt($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new IsType(IsType::TYPE_INT),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is of type numeric.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert numeric $actual
-     */
-    public static function assertIsNumeric($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new IsType(IsType::TYPE_NUMERIC),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is of type object.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert object $actual
-     */
-    public static function assertIsObject($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new IsType(IsType::TYPE_OBJECT),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is of type resource.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert resource $actual
-     */
-    public static function assertIsResource($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new IsType(IsType::TYPE_RESOURCE),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is of type resource and is closed.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert resource $actual
-     */
-    public static function assertIsClosedResource($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new IsType(IsType::TYPE_CLOSED_RESOURCE),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is of type string.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert string $actual
-     */
-    public static function assertIsString($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new IsType(IsType::TYPE_STRING),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is of type scalar.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert scalar $actual
-     */
-    public static function assertIsScalar($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new IsType(IsType::TYPE_SCALAR),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is of type callable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert callable $actual
-     */
-    public static function assertIsCallable($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new IsType(IsType::TYPE_CALLABLE),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is of type iterable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert iterable $actual
-     */
-    public static function assertIsIterable($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new IsType(IsType::TYPE_ITERABLE),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is not of type array.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert !array $actual
-     */
-    public static function assertIsNotArray($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new LogicalNot(new IsType(IsType::TYPE_ARRAY)),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is not of type bool.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert !bool $actual
-     */
-    public static function assertIsNotBool($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new LogicalNot(new IsType(IsType::TYPE_BOOL)),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is not of type float.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert !float $actual
-     */
-    public static function assertIsNotFloat($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new LogicalNot(new IsType(IsType::TYPE_FLOAT)),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is not of type int.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert !int $actual
-     */
-    public static function assertIsNotInt($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new LogicalNot(new IsType(IsType::TYPE_INT)),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is not of type numeric.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert !numeric $actual
-     */
-    public static function assertIsNotNumeric($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new LogicalNot(new IsType(IsType::TYPE_NUMERIC)),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is not of type object.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert !object $actual
-     */
-    public static function assertIsNotObject($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new LogicalNot(new IsType(IsType::TYPE_OBJECT)),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is not of type resource.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert !resource $actual
-     */
-    public static function assertIsNotResource($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new LogicalNot(new IsType(IsType::TYPE_RESOURCE)),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is not of type resource.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert !resource $actual
-     */
-    public static function assertIsNotClosedResource($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new LogicalNot(new IsType(IsType::TYPE_CLOSED_RESOURCE)),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is not of type string.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert !string $actual
-     */
-    public static function assertIsNotString($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new LogicalNot(new IsType(IsType::TYPE_STRING)),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is not of type scalar.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert !scalar $actual
-     */
-    public static function assertIsNotScalar($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new LogicalNot(new IsType(IsType::TYPE_SCALAR)),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is not of type callable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert !callable $actual
-     */
-    public static function assertIsNotCallable($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new LogicalNot(new IsType(IsType::TYPE_CALLABLE)),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a variable is not of type iterable.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @psalm-assert !iterable $actual
-     */
-    public static function assertIsNotIterable($actual, string $message = ''): void
-    {
-        static::assertThat(
-            $actual,
-            new LogicalNot(new IsType(IsType::TYPE_ITERABLE)),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a string matches a given regular expression.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertMatchesRegularExpression(string $pattern, string $string, string $message = ''): void
-    {
-        static::assertThat($string, new RegularExpression($pattern), $message);
-    }
-
-    /**
-     * Asserts that a string matches a given regular expression.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4086
-     */
-    public static function assertRegExp(string $pattern, string $string, string $message = ''): void
-    {
-        self::createWarning('assertRegExp() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertMatchesRegularExpression() instead.');
-
-        static::assertThat($string, new RegularExpression($pattern), $message);
-    }
-
-    /**
-     * Asserts that a string does not match a given regular expression.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertDoesNotMatchRegularExpression(string $pattern, string $string, string $message = ''): void
-    {
-        static::assertThat(
-            $string,
-            new LogicalNot(
-                new RegularExpression($pattern)
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a string does not match a given regular expression.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4089
-     */
-    public static function assertNotRegExp(string $pattern, string $string, string $message = ''): void
-    {
-        self::createWarning('assertNotRegExp() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertDoesNotMatchRegularExpression() instead.');
-
-        static::assertThat(
-            $string,
-            new LogicalNot(
-                new RegularExpression($pattern)
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Assert that the size of two arrays (or `Countable` or `Traversable` objects)
-     * is the same.
-     *
-     * @param Countable|iterable $expected
-     * @param Countable|iterable $actual
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     */
-    public static function assertSameSize($expected, $actual, string $message = ''): void
-    {
-        if (!$expected instanceof Countable && !is_iterable($expected)) {
-            throw InvalidArgumentException::create(1, 'countable or iterable');
-        }
-
-        if (!$actual instanceof Countable && !is_iterable($actual)) {
-            throw InvalidArgumentException::create(2, 'countable or iterable');
-        }
-
-        static::assertThat(
-            $actual,
-            new SameSize($expected),
-            $message
-        );
-    }
-
-    /**
-     * Assert that the size of two arrays (or `Countable` or `Traversable` objects)
-     * is not the same.
-     *
-     * @param Countable|iterable $expected
-     * @param Countable|iterable $actual
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     */
-    public static function assertNotSameSize($expected, $actual, string $message = ''): void
-    {
-        if (!$expected instanceof Countable && !is_iterable($expected)) {
-            throw InvalidArgumentException::create(1, 'countable or iterable');
-        }
-
-        if (!$actual instanceof Countable && !is_iterable($actual)) {
-            throw InvalidArgumentException::create(2, 'countable or iterable');
-        }
-
-        static::assertThat(
-            $actual,
-            new LogicalNot(
-                new SameSize($expected)
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a string matches a given format string.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringMatchesFormat(string $format, string $string, string $message = ''): void
-    {
-        static::assertThat($string, new StringMatchesFormatDescription($format), $message);
-    }
-
-    /**
-     * Asserts that a string does not match a given format string.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringNotMatchesFormat(string $format, string $string, string $message = ''): void
-    {
-        static::assertThat(
-            $string,
-            new LogicalNot(
-                new StringMatchesFormatDescription($format)
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a string matches a given format file.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringMatchesFormatFile(string $formatFile, string $string, string $message = ''): void
-    {
-        static::assertFileExists($formatFile, $message);
-
-        static::assertThat(
-            $string,
-            new StringMatchesFormatDescription(
-                file_get_contents($formatFile)
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a string does not match a given format string.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringNotMatchesFormatFile(string $formatFile, string $string, string $message = ''): void
-    {
-        static::assertFileExists($formatFile, $message);
-
-        static::assertThat(
-            $string,
-            new LogicalNot(
-                new StringMatchesFormatDescription(
-                    file_get_contents($formatFile)
-                )
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that a string starts with a given prefix.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringStartsWith(string $prefix, string $string, string $message = ''): void
-    {
-        static::assertThat($string, new StringStartsWith($prefix), $message);
-    }
-
-    /**
-     * Asserts that a string starts not with a given prefix.
-     *
-     * @param string $prefix
-     * @param string $string
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringStartsNotWith($prefix, $string, string $message = ''): void
-    {
-        static::assertThat(
-            $string,
-            new LogicalNot(
-                new StringStartsWith($prefix)
-            ),
-            $message
-        );
-    }
-
-    /**
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringContainsString(string $needle, string $haystack, string $message = ''): void
-    {
-        $constraint = new StringContains($needle, false);
-
-        static::assertThat($haystack, $constraint, $message);
-    }
-
-    /**
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringContainsStringIgnoringCase(string $needle, string $haystack, string $message = ''): void
-    {
-        $constraint = new StringContains($needle, true);
-
-        static::assertThat($haystack, $constraint, $message);
-    }
-
-    /**
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringNotContainsString(string $needle, string $haystack, string $message = ''): void
-    {
-        $constraint = new LogicalNot(new StringContains($needle));
-
-        static::assertThat($haystack, $constraint, $message);
-    }
-
-    /**
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringNotContainsStringIgnoringCase(string $needle, string $haystack, string $message = ''): void
-    {
-        $constraint = new LogicalNot(new StringContains($needle, true));
-
-        static::assertThat($haystack, $constraint, $message);
-    }
-
-    /**
-     * Asserts that a string ends with a given suffix.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringEndsWith(string $suffix, string $string, string $message = ''): void
-    {
-        static::assertThat($string, new StringEndsWith($suffix), $message);
-    }
-
-    /**
-     * Asserts that a string ends not with a given suffix.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertStringEndsNotWith(string $suffix, string $string, string $message = ''): void
-    {
-        static::assertThat(
-            $string,
-            new LogicalNot(
-                new StringEndsWith($suffix)
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that two XML files are equal.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws Exception
-     * @throws ExpectationFailedException
-     */
-    public static function assertXmlFileEqualsXmlFile(string $expectedFile, string $actualFile, string $message = ''): void
-    {
-        $expected = (new XmlLoader)->loadFile($expectedFile);
-        $actual   = (new XmlLoader)->loadFile($actualFile);
-
-        static::assertEquals($expected, $actual, $message);
-    }
-
-    /**
-     * Asserts that two XML files are not equal.
-     *
-     * @throws \PHPUnit\Util\Exception
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertXmlFileNotEqualsXmlFile(string $expectedFile, string $actualFile, string $message = ''): void
-    {
-        $expected = (new XmlLoader)->loadFile($expectedFile);
-        $actual   = (new XmlLoader)->loadFile($actualFile);
-
-        static::assertNotEquals($expected, $actual, $message);
-    }
-
-    /**
-     * Asserts that two XML documents are equal.
-     *
-     * @param DOMDocument|string $actualXml
-     *
-     * @throws \PHPUnit\Util\Xml\Exception
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertXmlStringEqualsXmlFile(string $expectedFile, $actualXml, string $message = ''): void
-    {
-        if (!is_string($actualXml)) {
-            self::createWarning('Passing an argument of type DOMDocument for the $actualXml parameter is deprecated. Support for this will be removed in PHPUnit 10.');
-
-            $actual = $actualXml;
-        } else {
-            $actual = (new XmlLoader)->load($actualXml);
-        }
-
-        $expected = (new XmlLoader)->loadFile($expectedFile);
-
-        static::assertEquals($expected, $actual, $message);
-    }
-
-    /**
-     * Asserts that two XML documents are not equal.
-     *
-     * @param DOMDocument|string $actualXml
-     *
-     * @throws \PHPUnit\Util\Xml\Exception
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertXmlStringNotEqualsXmlFile(string $expectedFile, $actualXml, string $message = ''): void
-    {
-        if (!is_string($actualXml)) {
-            self::createWarning('Passing an argument of type DOMDocument for the $actualXml parameter is deprecated. Support for this will be removed in PHPUnit 10.');
-
-            $actual = $actualXml;
-        } else {
-            $actual = (new XmlLoader)->load($actualXml);
-        }
-
-        $expected = (new XmlLoader)->loadFile($expectedFile);
-
-        static::assertNotEquals($expected, $actual, $message);
-    }
-
-    /**
-     * Asserts that two XML documents are equal.
-     *
-     * @param DOMDocument|string $expectedXml
-     * @param DOMDocument|string $actualXml
-     *
-     * @throws \PHPUnit\Util\Xml\Exception
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertXmlStringEqualsXmlString($expectedXml, $actualXml, string $message = ''): void
-    {
-        if (!is_string($expectedXml)) {
-            self::createWarning('Passing an argument of type DOMDocument for the $expectedXml parameter is deprecated. Support for this will be removed in PHPUnit 10.');
-
-            $expected = $expectedXml;
-        } else {
-            $expected = (new XmlLoader)->load($expectedXml);
-        }
-
-        if (!is_string($actualXml)) {
-            self::createWarning('Passing an argument of type DOMDocument for the $actualXml parameter is deprecated. Support for this will be removed in PHPUnit 10.');
-
-            $actual = $actualXml;
-        } else {
-            $actual = (new XmlLoader)->load($actualXml);
-        }
-
-        static::assertEquals($expected, $actual, $message);
-    }
-
-    /**
-     * Asserts that two XML documents are not equal.
-     *
-     * @param DOMDocument|string $expectedXml
-     * @param DOMDocument|string $actualXml
-     *
-     * @throws \PHPUnit\Util\Xml\Exception
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertXmlStringNotEqualsXmlString($expectedXml, $actualXml, string $message = ''): void
-    {
-        if (!is_string($expectedXml)) {
-            self::createWarning('Passing an argument of type DOMDocument for the $expectedXml parameter is deprecated. Support for this will be removed in PHPUnit 10.');
-
-            $expected = $expectedXml;
-        } else {
-            $expected = (new XmlLoader)->load($expectedXml);
-        }
-
-        if (!is_string($actualXml)) {
-            self::createWarning('Passing an argument of type DOMDocument for the $actualXml parameter is deprecated. Support for this will be removed in PHPUnit 10.');
-
-            $actual = $actualXml;
-        } else {
-            $actual = (new XmlLoader)->load($actualXml);
-        }
-
-        static::assertNotEquals($expected, $actual, $message);
-    }
-
-    /**
-     * Asserts that a hierarchy of DOMElements matches.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws AssertionFailedError
-     * @throws ExpectationFailedException
-     *
-     * @codeCoverageIgnore
-     *
-     * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4091
-     */
-    public static function assertEqualXMLStructure(DOMElement $expectedElement, DOMElement $actualElement, bool $checkAttributes = false, string $message = ''): void
-    {
-        self::createWarning('assertEqualXMLStructure() is deprecated and will be removed in PHPUnit 10.');
-
-        $expectedElement = Xml::import($expectedElement);
-        $actualElement   = Xml::import($actualElement);
-
-        static::assertSame(
-            $expectedElement->tagName,
-            $actualElement->tagName,
-            $message
-        );
-
-        if ($checkAttributes) {
-            static::assertSame(
-                $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);
-
-                assert($expectedAttribute instanceof DOMAttr);
-
-                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::assertSame(
-            $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.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertThat($value, Constraint $constraint, string $message = ''): void
-    {
-        self::$count += count($constraint);
-
-        $constraint->evaluate($value, $message);
-    }
-
-    /**
-     * Asserts that a string is a valid JSON string.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertJson(string $actualJson, string $message = ''): void
-    {
-        static::assertThat($actualJson, static::isJson(), $message);
-    }
-
-    /**
-     * Asserts that two given JSON encoded objects or arrays are equal.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertJsonStringEqualsJsonString(string $expectedJson, string $actualJson, string $message = ''): void
-    {
-        static::assertJson($expectedJson, $message);
-        static::assertJson($actualJson, $message);
-
-        static::assertThat($actualJson, new JsonMatches($expectedJson), $message);
-    }
-
-    /**
-     * Asserts that two given JSON encoded objects or arrays are not equal.
-     *
-     * @param string $expectedJson
-     * @param string $actualJson
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertJsonStringNotEqualsJsonString($expectedJson, $actualJson, string $message = ''): void
-    {
-        static::assertJson($expectedJson, $message);
-        static::assertJson($actualJson, $message);
-
-        static::assertThat(
-            $actualJson,
-            new LogicalNot(
-                new JsonMatches($expectedJson)
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that the generated JSON encoded object and the content of the given file are equal.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertJsonStringEqualsJsonFile(string $expectedFile, string $actualJson, string $message = ''): void
-    {
-        static::assertFileExists($expectedFile, $message);
-        $expectedJson = file_get_contents($expectedFile);
-
-        static::assertJson($expectedJson, $message);
-        static::assertJson($actualJson, $message);
-
-        static::assertThat($actualJson, new JsonMatches($expectedJson), $message);
-    }
-
-    /**
-     * Asserts that the generated JSON encoded object and the content of the given file are not equal.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertJsonStringNotEqualsJsonFile(string $expectedFile, string $actualJson, string $message = ''): void
-    {
-        static::assertFileExists($expectedFile, $message);
-        $expectedJson = file_get_contents($expectedFile);
-
-        static::assertJson($expectedJson, $message);
-        static::assertJson($actualJson, $message);
-
-        static::assertThat(
-            $actualJson,
-            new LogicalNot(
-                new JsonMatches($expectedJson)
-            ),
-            $message
-        );
-    }
-
-    /**
-     * Asserts that two JSON files are equal.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertJsonFileEqualsJsonFile(string $expectedFile, string $actualFile, string $message = ''): void
-    {
-        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.
-     *
-     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
-     * @throws ExpectationFailedException
-     */
-    public static function assertJsonFileNotEqualsJsonFile(string $expectedFile, string $actualFile, string $message = ''): void
-    {
-        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);
-    }
-
-    /**
-     * @throws Exception
-     */
-    public static function logicalAnd(): LogicalAnd
-    {
-        $constraints = func_get_args();
-
-        $constraint = new LogicalAnd;
-        $constraint->setConstraints($constraints);
-
-        return $constraint;
-    }
-
-    public static function logicalOr(): LogicalOr
-    {
-        $constraints = func_get_args();
-
-        $constraint = new LogicalOr;
-        $constraint->setConstraints($constraints);
-
-        return $constraint;
-    }
-
-    public static function logicalNot(Constraint $constraint): LogicalNot
-    {
-        return new LogicalNot($constraint);
-    }
-
-    public static function logicalXor(): LogicalXor
-    {
-        $constraints = func_get_args();
-
-        $constraint = new LogicalXor;
-        $constraint->setConstraints($constraints);
-
-        return $constraint;
-    }
-
-    public static function anything(): IsAnything
-    {
-        return new IsAnything;
-    }
-
-    public static function isTrue(): IsTrue
-    {
-        return new IsTrue;
-    }
-
-    /**
-     * @psalm-template CallbackInput of mixed
-     *
-     * @psalm-param callable(CallbackInput $callback): bool $callback
-     *
-     * @psalm-return Callback<CallbackInput>
-     */
-    public static function callback(callable $callback): Callback
-    {
-        return new Callback($callback);
-    }
-
-    public static function isFalse(): IsFalse
-    {
-        return new IsFalse;
-    }
-
-    public static function isJson(): IsJson
-    {
-        return new IsJson;
-    }
-
-    public static function isNull(): IsNull
-    {
-        return new IsNull;
-    }
-
-    public static function isFinite(): IsFinite
-    {
-        return new IsFinite;
-    }
-
-    public static function isInfinite(): IsInfinite
-    {
-        return new IsInfinite;
-    }
-
-    public static function isNan(): IsNan
-    {
-        return new IsNan;
-    }
-
-    public static function containsEqual($value): TraversableContainsEqual
-    {
-        return new TraversableContainsEqual($value);
-    }
-
-    public static function containsIdentical($value): TraversableContainsIdentical
-    {
-        return new TraversableContainsIdentical($value);
-    }
-
-    public static function containsOnly(string $type): TraversableContainsOnly
-    {
-        return new TraversableContainsOnly($type);
-    }
-
-    public static function containsOnlyInstancesOf(string $className): TraversableContainsOnly
-    {
-        return new TraversableContainsOnly($className, false);
-    }
-
-    /**
-     * @param int|string $key
-     */
-    public static function arrayHasKey($key): ArrayHasKey
-    {
-        return new ArrayHasKey($key);
-    }
-
-    public static function equalTo($value): IsEqual
-    {
-        return new IsEqual($value, 0.0, false, false);
-    }
-
-    public static function equalToCanonicalizing($value): IsEqualCanonicalizing
-    {
-        return new IsEqualCanonicalizing($value);
-    }
-
-    public static function equalToIgnoringCase($value): IsEqualIgnoringCase
-    {
-        return new IsEqualIgnoringCase($value);
-    }
-
-    public static function equalToWithDelta($value, float $delta): IsEqualWithDelta
-    {
-        return new IsEqualWithDelta($value, $delta);
-    }
-
-    public static function isEmpty(): IsEmpty
-    {
-        return new IsEmpty;
-    }
-
-    public static function isWritable(): IsWritable
-    {
-        return new IsWritable;
-    }
-
-    public static function isReadable(): IsReadable
-    {
-        return new IsReadable;
-    }
-
-    public static function directoryExists(): DirectoryExists
-    {
-        return new DirectoryExists;
-    }
-
-    public static function fileExists(): FileExists
-    {
-        return new FileExists;
-    }
-
-    public static function greaterThan($value): GreaterThan
-    {
-        return new GreaterThan($value);
-    }
-
-    public static function greaterThanOrEqual($value): LogicalOr
-    {
-        return static::logicalOr(
-            new IsEqual($value),
-            new GreaterThan($value)
-        );
-    }
-
-    public static function classHasAttribute(string $attributeName): ClassHasAttribute
-    {
-        return new ClassHasAttribute($attributeName);
-    }
-
-    public static function classHasStaticAttribute(string $attributeName): ClassHasStaticAttribute
-    {
-        return new ClassHasStaticAttribute($attributeName);
-    }
-
-    public static function objectHasAttribute($attributeName): ObjectHasAttribute
-    {
-        return new ObjectHasAttribute($attributeName);
-    }
-
-    public static function identicalTo($value): IsIdentical
-    {
-        return new IsIdentical($value);
-    }
-
-    public static function isInstanceOf(string $className): IsInstanceOf
-    {
-        return new IsInstanceOf($className);
-    }
-
-    public static function isType(string $type): IsType
-    {
-        return new IsType($type);
-    }
-
-    public static function lessThan($value): LessThan
-    {
-        return new LessThan($value);
-    }
-
-    public static function lessThanOrEqual($value): LogicalOr
-    {
-        return static::logicalOr(
-            new IsEqual($value),
-            new LessThan($value)
-        );
-    }
-
-    public static function matchesRegularExpression(string $pattern): RegularExpression
-    {
-        return new RegularExpression($pattern);
-    }
-
-    public static function matches(string $string): StringMatchesFormatDescription
-    {
-        return new StringMatchesFormatDescription($string);
-    }
-
-    public static function stringStartsWith($prefix): StringStartsWith
-    {
-        return new StringStartsWith($prefix);
-    }
-
-    public static function stringContains(string $string, bool $case = true): StringContains
-    {
-        return new StringContains($string, $case);
-    }
-
-    public static function stringEndsWith(string $suffix): StringEndsWith
-    {
-        return new StringEndsWith($suffix);
-    }
-
-    public static function countOf(int $count): Count
-    {
-        return new Count($count);
-    }
-
-    public static function objectEquals(object $object, string $method = 'equals'): ObjectEquals
-    {
-        return new ObjectEquals($object, $method);
-    }
-
-    /**
-     * Fails a test with the given message.
-     *
-     * @throws AssertionFailedError
-     *
-     * @psalm-return never-return
-     */
-    public static function fail(string $message = ''): void
-    {
-        self::$count++;
-
-        throw new AssertionFailedError($message);
-    }
-
-    /**
-     * Mark the test as incomplete.
-     *
-     * @throws IncompleteTestError
-     *
-     * @psalm-return never-return
-     */
-    public static function markTestIncomplete(string $message = ''): void
-    {
-        throw new IncompleteTestError($message);
-    }
-
-    /**
-     * Mark the test as skipped.
-     *
-     * @throws SkippedTestError
-     * @throws SyntheticSkippedError
-     *
-     * @psalm-return never-return
-     */
-    public static function markTestSkipped(string $message = ''): void
-    {
-        if ($hint = self::detectLocationHint($message)) {
-            $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
-            array_unshift($trace, $hint);
-
-            throw new SyntheticSkippedError($hint['message'], 0, $hint['file'], (int) $hint['line'], $trace);
-        }
-
-        throw new SkippedTestError($message);
-    }
-
-    /**
-     * Return the current assertion count.
-     */
-    public static function getCount(): int
-    {
-        return self::$count;
-    }
-
-    /**
-     * Reset the assertion counter.
-     */
-    public static function resetCount(): void
-    {
-        self::$count = 0;
-    }
-
-    private static function detectLocationHint(string $message): ?array
-    {
-        $hint  = null;
-        $lines = preg_split('/\r\n|\r|\n/', $message);
-
-        while (strpos($lines[0], '__OFFSET') !== false) {
-            $offset = explode('=', array_shift($lines));
-
-            if ($offset[0] === '__OFFSET_FILE') {
-                $hint['file'] = $offset[1];
-            }
-
-            if ($offset[0] === '__OFFSET_LINE') {
-                $hint['line'] = $offset[1];
-            }
-        }
-
-        if ($hint) {
-            $hint['message'] = implode(PHP_EOL, $lines);
-        }
-
-        return $hint;
-    }
-
-    private static function isValidObjectAttributeName(string $attributeName): bool
-    {
-        return (bool) preg_match('/[^\x00-\x1f\x7f-\x9f]+/', $attributeName);
-    }
-
-    private static function isValidClassAttributeName(string $attributeName): bool
-    {
-        return (bool) preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName);
-    }
-
-    /**
-     * @codeCoverageIgnore
-     */
-    private static function createWarning(string $warning): void
-    {
-        foreach (debug_backtrace() as $step) {
-            if (isset($step['object']) && $step['object'] instanceof TestCase) {
-                assert($step['object'] instanceof TestCase);
-
-                $step['object']->addWarning($warning);
-
-                break;
-            }
-        }
-    }
+	/**
+	 * @var int
+	 */
+	private static $count = 0;
+
+	/**
+	 * Asserts that an array has a specified key.
+	 *
+	 * @param int|string        $key
+	 * @param array|ArrayAccess $array
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertArrayHasKey($key, $array, string $message = ''): void
+	{
+		if (!(is_int($key) || is_string($key))) {
+			throw InvalidArgumentException::create(
+				1,
+				'integer or string'
+			);
+		}
+
+		if (!(is_array($array) || $array instanceof ArrayAccess)) {
+			throw InvalidArgumentException::create(
+				2,
+				'array or ArrayAccess'
+			);
+		}
+
+		$constraint = new ArrayHasKey($key);
+
+		static::assertThat($array, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that an array does not have a specified key.
+	 *
+	 * @param int|string        $key
+	 * @param array|ArrayAccess $array
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertArrayNotHasKey($key, $array, string $message = ''): void
+	{
+		if (!(is_int($key) || is_string($key))) {
+			throw InvalidArgumentException::create(
+				1,
+				'integer or string'
+			);
+		}
+
+		if (!(is_array($array) || $array instanceof ArrayAccess)) {
+			throw InvalidArgumentException::create(
+				2,
+				'array or ArrayAccess'
+			);
+		}
+
+		$constraint = new LogicalNot(
+			new ArrayHasKey($key)
+		);
+
+		static::assertThat($array, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a haystack contains a needle.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertContains($needle, iterable $haystack, string $message = ''): void
+	{
+		$constraint = new TraversableContainsIdentical($needle);
+
+		static::assertThat($haystack, $constraint, $message);
+	}
+
+	public static function assertContainsEquals($needle, iterable $haystack, string $message = ''): void
+	{
+		$constraint = new TraversableContainsEqual($needle);
+
+		static::assertThat($haystack, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a haystack does not contain a needle.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertNotContains($needle, iterable $haystack, string $message = ''): void
+	{
+		$constraint = new LogicalNot(
+			new TraversableContainsIdentical($needle)
+		);
+
+		static::assertThat($haystack, $constraint, $message);
+	}
+
+	public static function assertNotContainsEquals($needle, iterable $haystack, string $message = ''): void
+	{
+		$constraint = new LogicalNot(new TraversableContainsEqual($needle));
+
+		static::assertThat($haystack, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a haystack contains only values of a given type.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertContainsOnly(string $type, iterable $haystack, ?bool $isNativeType = null, string $message = ''): void
+	{
+		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 class name.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertContainsOnlyInstancesOf(string $className, iterable $haystack, string $message = ''): void
+	{
+		static::assertThat(
+			$haystack,
+			new TraversableContainsOnly(
+				$className,
+				false
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a haystack does not contain only values of a given type.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertNotContainsOnly(string $type, iterable $haystack, ?bool $isNativeType = null, string $message = ''): void
+	{
+		if ($isNativeType === null) {
+			$isNativeType = Type::isType($type);
+		}
+
+		static::assertThat(
+			$haystack,
+			new LogicalNot(
+				new TraversableContainsOnly(
+					$type,
+					$isNativeType
+				)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts the number of elements of an array, Countable or Traversable.
+	 *
+	 * @param Countable|iterable $haystack
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertCount(int $expectedCount, $haystack, string $message = ''): void
+	{
+		if (!$haystack instanceof Countable && !is_iterable($haystack)) {
+			throw InvalidArgumentException::create(2, 'countable or iterable');
+		}
+
+		static::assertThat(
+			$haystack,
+			new Count($expectedCount),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts the number of elements of an array, Countable or Traversable.
+	 *
+	 * @param Countable|iterable $haystack
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertNotCount(int $expectedCount, $haystack, string $message = ''): void
+	{
+		if (!$haystack instanceof Countable && !is_iterable($haystack)) {
+			throw InvalidArgumentException::create(2, 'countable or iterable');
+		}
+
+		$constraint = new LogicalNot(
+			new Count($expectedCount)
+		);
+
+		static::assertThat($haystack, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that two variables are equal.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertEquals($expected, $actual, string $message = ''): void
+	{
+		$constraint = new IsEqual($expected);
+
+		static::assertThat($actual, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that two variables are equal (canonicalizing).
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertEqualsCanonicalizing($expected, $actual, string $message = ''): void
+	{
+		$constraint = new IsEqualCanonicalizing($expected);
+
+		static::assertThat($actual, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that two variables are equal (ignoring case).
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertEqualsIgnoringCase($expected, $actual, string $message = ''): void
+	{
+		$constraint = new IsEqualIgnoringCase($expected);
+
+		static::assertThat($actual, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that two variables are equal (with delta).
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertEqualsWithDelta($expected, $actual, float $delta, string $message = ''): void
+	{
+		$constraint = new IsEqualWithDelta(
+			$expected,
+			$delta
+		);
+
+		static::assertThat($actual, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that two variables are not equal.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertNotEquals($expected, $actual, string $message = ''): void
+	{
+		$constraint = new LogicalNot(
+			new IsEqual($expected)
+		);
+
+		static::assertThat($actual, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that two variables are not equal (canonicalizing).
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertNotEqualsCanonicalizing($expected, $actual, string $message = ''): void
+	{
+		$constraint = new LogicalNot(
+			new IsEqualCanonicalizing($expected)
+		);
+
+		static::assertThat($actual, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that two variables are not equal (ignoring case).
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertNotEqualsIgnoringCase($expected, $actual, string $message = ''): void
+	{
+		$constraint = new LogicalNot(
+			new IsEqualIgnoringCase($expected)
+		);
+
+		static::assertThat($actual, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that two variables are not equal (with delta).
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertNotEqualsWithDelta($expected, $actual, float $delta, string $message = ''): void
+	{
+		$constraint = new LogicalNot(
+			new IsEqualWithDelta(
+				$expected,
+				$delta
+			)
+		);
+
+		static::assertThat($actual, $constraint, $message);
+	}
+
+	/**
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertObjectEquals(object $expected, object $actual, string $method = 'equals', string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			static::objectEquals($expected, $method),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is empty.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert empty $actual
+	 */
+	public static function assertEmpty($actual, string $message = ''): void
+	{
+		static::assertThat($actual, static::isEmpty(), $message);
+	}
+
+	/**
+	 * Asserts that a variable is not empty.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert !empty $actual
+	 */
+	public static function assertNotEmpty($actual, string $message = ''): void
+	{
+		static::assertThat($actual, static::logicalNot(static::isEmpty()), $message);
+	}
+
+	/**
+	 * Asserts that a value is greater than another value.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertGreaterThan($expected, $actual, string $message = ''): void
+	{
+		static::assertThat($actual, static::greaterThan($expected), $message);
+	}
+
+	/**
+	 * Asserts that a value is greater than or equal to another value.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertGreaterThanOrEqual($expected, $actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			static::greaterThanOrEqual($expected),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a value is smaller than another value.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertLessThan($expected, $actual, string $message = ''): void
+	{
+		static::assertThat($actual, static::lessThan($expected), $message);
+	}
+
+	/**
+	 * Asserts that a value is smaller than or equal to another value.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertLessThanOrEqual($expected, $actual, string $message = ''): void
+	{
+		static::assertThat($actual, static::lessThanOrEqual($expected), $message);
+	}
+
+	/**
+	 * Asserts that the contents of one file is equal to the contents of another
+	 * file.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertFileEquals(string $expected, string $actual, string $message = ''): void
+	{
+		static::assertFileExists($expected, $message);
+		static::assertFileExists($actual, $message);
+
+		$constraint = new IsEqual(file_get_contents($expected));
+
+		static::assertThat(file_get_contents($actual), $constraint, $message);
+	}
+
+	/**
+	 * Asserts that the contents of one file is equal to the contents of another
+	 * file (canonicalizing).
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertFileEqualsCanonicalizing(string $expected, string $actual, string $message = ''): void
+	{
+		static::assertFileExists($expected, $message);
+		static::assertFileExists($actual, $message);
+
+		$constraint = new IsEqualCanonicalizing(
+			file_get_contents($expected)
+		);
+
+		static::assertThat(file_get_contents($actual), $constraint, $message);
+	}
+
+	/**
+	 * Asserts that the contents of one file is equal to the contents of another
+	 * file (ignoring case).
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertFileEqualsIgnoringCase(string $expected, string $actual, string $message = ''): void
+	{
+		static::assertFileExists($expected, $message);
+		static::assertFileExists($actual, $message);
+
+		$constraint = new IsEqualIgnoringCase(file_get_contents($expected));
+
+		static::assertThat(file_get_contents($actual), $constraint, $message);
+	}
+
+	/**
+	 * Asserts that the contents of one file is not equal to the contents of
+	 * another file.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertFileNotEquals(string $expected, string $actual, string $message = ''): void
+	{
+		static::assertFileExists($expected, $message);
+		static::assertFileExists($actual, $message);
+
+		$constraint = new LogicalNot(
+			new IsEqual(file_get_contents($expected))
+		);
+
+		static::assertThat(file_get_contents($actual), $constraint, $message);
+	}
+
+	/**
+	 * Asserts that the contents of one file is not equal to the contents of another
+	 * file (canonicalizing).
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertFileNotEqualsCanonicalizing(string $expected, string $actual, string $message = ''): void
+	{
+		static::assertFileExists($expected, $message);
+		static::assertFileExists($actual, $message);
+
+		$constraint = new LogicalNot(
+			new IsEqualCanonicalizing(file_get_contents($expected))
+		);
+
+		static::assertThat(file_get_contents($actual), $constraint, $message);
+	}
+
+	/**
+	 * Asserts that the contents of one file is not equal to the contents of another
+	 * file (ignoring case).
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertFileNotEqualsIgnoringCase(string $expected, string $actual, string $message = ''): void
+	{
+		static::assertFileExists($expected, $message);
+		static::assertFileExists($actual, $message);
+
+		$constraint = new LogicalNot(
+			new IsEqualIgnoringCase(file_get_contents($expected))
+		);
+
+		static::assertThat(file_get_contents($actual), $constraint, $message);
+	}
+
+	/**
+	 * Asserts that the contents of a string is equal
+	 * to the contents of a file.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringEqualsFile(string $expectedFile, string $actualString, string $message = ''): void
+	{
+		static::assertFileExists($expectedFile, $message);
+
+		$constraint = new IsEqual(file_get_contents($expectedFile));
+
+		static::assertThat($actualString, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that the contents of a string is equal
+	 * to the contents of a file (canonicalizing).
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringEqualsFileCanonicalizing(string $expectedFile, string $actualString, string $message = ''): void
+	{
+		static::assertFileExists($expectedFile, $message);
+
+		$constraint = new IsEqualCanonicalizing(file_get_contents($expectedFile));
+
+		static::assertThat($actualString, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that the contents of a string is equal
+	 * to the contents of a file (ignoring case).
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringEqualsFileIgnoringCase(string $expectedFile, string $actualString, string $message = ''): void
+	{
+		static::assertFileExists($expectedFile, $message);
+
+		$constraint = new IsEqualIgnoringCase(file_get_contents($expectedFile));
+
+		static::assertThat($actualString, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that the contents of a string is not equal
+	 * to the contents of a file.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringNotEqualsFile(string $expectedFile, string $actualString, string $message = ''): void
+	{
+		static::assertFileExists($expectedFile, $message);
+
+		$constraint = new LogicalNot(
+			new IsEqual(file_get_contents($expectedFile))
+		);
+
+		static::assertThat($actualString, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that the contents of a string is not equal
+	 * to the contents of a file (canonicalizing).
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringNotEqualsFileCanonicalizing(string $expectedFile, string $actualString, string $message = ''): void
+	{
+		static::assertFileExists($expectedFile, $message);
+
+		$constraint = new LogicalNot(
+			new IsEqualCanonicalizing(file_get_contents($expectedFile))
+		);
+
+		static::assertThat($actualString, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that the contents of a string is not equal
+	 * to the contents of a file (ignoring case).
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringNotEqualsFileIgnoringCase(string $expectedFile, string $actualString, string $message = ''): void
+	{
+		static::assertFileExists($expectedFile, $message);
+
+		$constraint = new LogicalNot(
+			new IsEqualIgnoringCase(file_get_contents($expectedFile))
+		);
+
+		static::assertThat($actualString, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a file/dir is readable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertIsReadable(string $filename, string $message = ''): void
+	{
+		static::assertThat($filename, new IsReadable, $message);
+	}
+
+	/**
+	 * Asserts that a file/dir exists and is not readable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertIsNotReadable(string $filename, string $message = ''): void
+	{
+		static::assertThat($filename, new LogicalNot(new IsReadable), $message);
+	}
+
+	/**
+	 * Asserts that a file/dir exists and is not readable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4062
+	 */
+	public static function assertNotIsReadable(string $filename, string $message = ''): void
+	{
+		self::createWarning('assertNotIsReadable() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertIsNotReadable() instead.');
+
+		static::assertThat($filename, new LogicalNot(new IsReadable), $message);
+	}
+
+	/**
+	 * Asserts that a file/dir exists and is writable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertIsWritable(string $filename, string $message = ''): void
+	{
+		static::assertThat($filename, new IsWritable, $message);
+	}
+
+	/**
+	 * Asserts that a file/dir exists and is not writable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertIsNotWritable(string $filename, string $message = ''): void
+	{
+		static::assertThat($filename, new LogicalNot(new IsWritable), $message);
+	}
+
+	/**
+	 * Asserts that a file/dir exists and is not writable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4065
+	 */
+	public static function assertNotIsWritable(string $filename, string $message = ''): void
+	{
+		self::createWarning('assertNotIsWritable() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertIsNotWritable() instead.');
+
+		static::assertThat($filename, new LogicalNot(new IsWritable), $message);
+	}
+
+	/**
+	 * Asserts that a directory exists.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertDirectoryExists(string $directory, string $message = ''): void
+	{
+		static::assertThat($directory, new DirectoryExists, $message);
+	}
+
+	/**
+	 * Asserts that a directory does not exist.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertDirectoryDoesNotExist(string $directory, string $message = ''): void
+	{
+		static::assertThat($directory, new LogicalNot(new DirectoryExists), $message);
+	}
+
+	/**
+	 * Asserts that a directory does not exist.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4068
+	 */
+	public static function assertDirectoryNotExists(string $directory, string $message = ''): void
+	{
+		self::createWarning('assertDirectoryNotExists() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertDirectoryDoesNotExist() instead.');
+
+		static::assertThat($directory, new LogicalNot(new DirectoryExists), $message);
+	}
+
+	/**
+	 * Asserts that a directory exists and is readable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertDirectoryIsReadable(string $directory, string $message = ''): void
+	{
+		self::assertDirectoryExists($directory, $message);
+		self::assertIsReadable($directory, $message);
+	}
+
+	/**
+	 * Asserts that a directory exists and is not readable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertDirectoryIsNotReadable(string $directory, string $message = ''): void
+	{
+		self::assertDirectoryExists($directory, $message);
+		self::assertIsNotReadable($directory, $message);
+	}
+
+	/**
+	 * Asserts that a directory exists and is not readable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4071
+	 */
+	public static function assertDirectoryNotIsReadable(string $directory, string $message = ''): void
+	{
+		self::createWarning('assertDirectoryNotIsReadable() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertDirectoryIsNotReadable() instead.');
+
+		self::assertDirectoryExists($directory, $message);
+		self::assertIsNotReadable($directory, $message);
+	}
+
+	/**
+	 * Asserts that a directory exists and is writable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertDirectoryIsWritable(string $directory, string $message = ''): void
+	{
+		self::assertDirectoryExists($directory, $message);
+		self::assertIsWritable($directory, $message);
+	}
+
+	/**
+	 * Asserts that a directory exists and is not writable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertDirectoryIsNotWritable(string $directory, string $message = ''): void
+	{
+		self::assertDirectoryExists($directory, $message);
+		self::assertIsNotWritable($directory, $message);
+	}
+
+	/**
+	 * Asserts that a directory exists and is not writable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4074
+	 */
+	public static function assertDirectoryNotIsWritable(string $directory, string $message = ''): void
+	{
+		self::createWarning('assertDirectoryNotIsWritable() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertDirectoryIsNotWritable() instead.');
+
+		self::assertDirectoryExists($directory, $message);
+		self::assertIsNotWritable($directory, $message);
+	}
+
+	/**
+	 * Asserts that a file exists.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertFileExists(string $filename, string $message = ''): void
+	{
+		static::assertThat($filename, new FileExists, $message);
+	}
+
+	/**
+	 * Asserts that a file does not exist.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertFileDoesNotExist(string $filename, string $message = ''): void
+	{
+		static::assertThat($filename, new LogicalNot(new FileExists), $message);
+	}
+
+	/**
+	 * Asserts that a file does not exist.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4077
+	 */
+	public static function assertFileNotExists(string $filename, string $message = ''): void
+	{
+		self::createWarning('assertFileNotExists() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertFileDoesNotExist() instead.');
+
+		static::assertThat($filename, new LogicalNot(new FileExists), $message);
+	}
+
+	/**
+	 * Asserts that a file exists and is readable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertFileIsReadable(string $file, string $message = ''): void
+	{
+		self::assertFileExists($file, $message);
+		self::assertIsReadable($file, $message);
+	}
+
+	/**
+	 * Asserts that a file exists and is not readable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertFileIsNotReadable(string $file, string $message = ''): void
+	{
+		self::assertFileExists($file, $message);
+		self::assertIsNotReadable($file, $message);
+	}
+
+	/**
+	 * Asserts that a file exists and is not readable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4080
+	 */
+	public static function assertFileNotIsReadable(string $file, string $message = ''): void
+	{
+		self::createWarning('assertFileNotIsReadable() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertFileIsNotReadable() instead.');
+
+		self::assertFileExists($file, $message);
+		self::assertIsNotReadable($file, $message);
+	}
+
+	/**
+	 * Asserts that a file exists and is writable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertFileIsWritable(string $file, string $message = ''): void
+	{
+		self::assertFileExists($file, $message);
+		self::assertIsWritable($file, $message);
+	}
+
+	/**
+	 * Asserts that a file exists and is not writable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertFileIsNotWritable(string $file, string $message = ''): void
+	{
+		self::assertFileExists($file, $message);
+		self::assertIsNotWritable($file, $message);
+	}
+
+	/**
+	 * Asserts that a file exists and is not writable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4083
+	 */
+	public static function assertFileNotIsWritable(string $file, string $message = ''): void
+	{
+		self::createWarning('assertFileNotIsWritable() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertFileIsNotWritable() instead.');
+
+		self::assertFileExists($file, $message);
+		self::assertIsNotWritable($file, $message);
+	}
+
+	/**
+	 * Asserts that a condition is true.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert true $condition
+	 */
+	public static function assertTrue($condition, string $message = ''): void
+	{
+		static::assertThat($condition, static::isTrue(), $message);
+	}
+
+	/**
+	 * Asserts that a condition is not true.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert !true $condition
+	 */
+	public static function assertNotTrue($condition, string $message = ''): void
+	{
+		static::assertThat($condition, static::logicalNot(static::isTrue()), $message);
+	}
+
+	/**
+	 * Asserts that a condition is false.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert false $condition
+	 */
+	public static function assertFalse($condition, string $message = ''): void
+	{
+		static::assertThat($condition, static::isFalse(), $message);
+	}
+
+	/**
+	 * Asserts that a condition is not false.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert !false $condition
+	 */
+	public static function assertNotFalse($condition, string $message = ''): void
+	{
+		static::assertThat($condition, static::logicalNot(static::isFalse()), $message);
+	}
+
+	/**
+	 * Asserts that a variable is null.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert null $actual
+	 */
+	public static function assertNull($actual, string $message = ''): void
+	{
+		static::assertThat($actual, static::isNull(), $message);
+	}
+
+	/**
+	 * Asserts that a variable is not null.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert !null $actual
+	 */
+	public static function assertNotNull($actual, string $message = ''): void
+	{
+		static::assertThat($actual, static::logicalNot(static::isNull()), $message);
+	}
+
+	/**
+	 * Asserts that a variable is finite.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertFinite($actual, string $message = ''): void
+	{
+		static::assertThat($actual, static::isFinite(), $message);
+	}
+
+	/**
+	 * Asserts that a variable is infinite.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertInfinite($actual, string $message = ''): void
+	{
+		static::assertThat($actual, static::isInfinite(), $message);
+	}
+
+	/**
+	 * Asserts that a variable is nan.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertNan($actual, string $message = ''): void
+	{
+		static::assertThat($actual, static::isNan(), $message);
+	}
+
+	/**
+	 * Asserts that a class has a specified attribute.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertClassHasAttribute(string $attributeName, string $className, string $message = ''): void
+	{
+		if (!self::isValidClassAttributeName($attributeName)) {
+			throw InvalidArgumentException::create(1, 'valid attribute name');
+		}
+
+		if (!class_exists($className)) {
+			throw InvalidArgumentException::create(2, 'class name');
+		}
+
+		static::assertThat($className, new ClassHasAttribute($attributeName), $message);
+	}
+
+	/**
+	 * Asserts that a class does not have a specified attribute.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertClassNotHasAttribute(string $attributeName, string $className, string $message = ''): void
+	{
+		if (!self::isValidClassAttributeName($attributeName)) {
+			throw InvalidArgumentException::create(1, 'valid attribute name');
+		}
+
+		if (!class_exists($className)) {
+			throw InvalidArgumentException::create(2, 'class name');
+		}
+
+		static::assertThat(
+			$className,
+			new LogicalNot(
+				new ClassHasAttribute($attributeName)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a class has a specified static attribute.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertClassHasStaticAttribute(string $attributeName, string $className, string $message = ''): void
+	{
+		if (!self::isValidClassAttributeName($attributeName)) {
+			throw InvalidArgumentException::create(1, 'valid attribute name');
+		}
+
+		if (!class_exists($className)) {
+			throw InvalidArgumentException::create(2, 'class name');
+		}
+
+		static::assertThat(
+			$className,
+			new ClassHasStaticAttribute($attributeName),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a class does not have a specified static attribute.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertClassNotHasStaticAttribute(string $attributeName, string $className, string $message = ''): void
+	{
+		if (!self::isValidClassAttributeName($attributeName)) {
+			throw InvalidArgumentException::create(1, 'valid attribute name');
+		}
+
+		if (!class_exists($className)) {
+			throw InvalidArgumentException::create(2, 'class name');
+		}
+
+		static::assertThat(
+			$className,
+			new LogicalNot(
+				new ClassHasStaticAttribute($attributeName)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that an object has a specified attribute.
+	 *
+	 * @param object $object
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertObjectHasAttribute(string $attributeName, $object, string $message = ''): void
+	{
+		if (!self::isValidObjectAttributeName($attributeName)) {
+			throw InvalidArgumentException::create(1, 'valid attribute name');
+		}
+
+		if (!is_object($object)) {
+			throw InvalidArgumentException::create(2, 'object');
+		}
+
+		static::assertThat(
+			$object,
+			new ObjectHasAttribute($attributeName),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that an object does not have a specified attribute.
+	 *
+	 * @param object $object
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertObjectNotHasAttribute(string $attributeName, $object, string $message = ''): void
+	{
+		if (!self::isValidObjectAttributeName($attributeName)) {
+			throw InvalidArgumentException::create(1, 'valid attribute name');
+		}
+
+		if (!is_object($object)) {
+			throw InvalidArgumentException::create(2, 'object');
+		}
+
+		static::assertThat(
+			$object,
+			new LogicalNot(
+				new ObjectHasAttribute($attributeName)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that two variables have the same type and value.
+	 * Used on objects, it asserts that two variables reference
+	 * the same object.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-template ExpectedType
+	 *
+	 * @psalm-param ExpectedType $expected
+	 *
+	 * @psalm-assert =ExpectedType $actual
+	 */
+	public static function assertSame($expected, $actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new IsIdentical($expected),
+			$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.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertNotSame($expected, $actual, string $message = ''): void
+	{
+		if (is_bool($expected) && is_bool($actual)) {
+			static::assertNotEquals($expected, $actual, $message);
+		}
+
+		static::assertThat(
+			$actual,
+			new LogicalNot(
+				new IsIdentical($expected)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is of a given type.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-template ExpectedType of object
+	 *
+	 * @psalm-param class-string<ExpectedType> $expected
+	 *
+	 * @psalm-assert =ExpectedType $actual
+	 */
+	public static function assertInstanceOf(string $expected, $actual, string $message = ''): void
+	{
+		if (!class_exists($expected) && !interface_exists($expected)) {
+			throw InvalidArgumentException::create(1, 'class or interface name');
+		}
+
+		static::assertThat(
+			$actual,
+			new IsInstanceOf($expected),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is not of a given type.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-template ExpectedType of object
+	 *
+	 * @psalm-param class-string<ExpectedType> $expected
+	 *
+	 * @psalm-assert !ExpectedType $actual
+	 */
+	public static function assertNotInstanceOf(string $expected, $actual, string $message = ''): void
+	{
+		if (!class_exists($expected) && !interface_exists($expected)) {
+			throw InvalidArgumentException::create(1, 'class or interface name');
+		}
+
+		static::assertThat(
+			$actual,
+			new LogicalNot(
+				new IsInstanceOf($expected)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is of type array.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert array $actual
+	 */
+	public static function assertIsArray($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new IsType(IsType::TYPE_ARRAY),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is of type bool.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert bool $actual
+	 */
+	public static function assertIsBool($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new IsType(IsType::TYPE_BOOL),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is of type float.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert float $actual
+	 */
+	public static function assertIsFloat($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new IsType(IsType::TYPE_FLOAT),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is of type int.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert int $actual
+	 */
+	public static function assertIsInt($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new IsType(IsType::TYPE_INT),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is of type numeric.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert numeric $actual
+	 */
+	public static function assertIsNumeric($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new IsType(IsType::TYPE_NUMERIC),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is of type object.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert object $actual
+	 */
+	public static function assertIsObject($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new IsType(IsType::TYPE_OBJECT),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is of type resource.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert resource $actual
+	 */
+	public static function assertIsResource($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new IsType(IsType::TYPE_RESOURCE),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is of type resource and is closed.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert resource $actual
+	 */
+	public static function assertIsClosedResource($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new IsType(IsType::TYPE_CLOSED_RESOURCE),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is of type string.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert string $actual
+	 */
+	public static function assertIsString($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new IsType(IsType::TYPE_STRING),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is of type scalar.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert scalar $actual
+	 */
+	public static function assertIsScalar($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new IsType(IsType::TYPE_SCALAR),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is of type callable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert callable $actual
+	 */
+	public static function assertIsCallable($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new IsType(IsType::TYPE_CALLABLE),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is of type iterable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert iterable $actual
+	 */
+	public static function assertIsIterable($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new IsType(IsType::TYPE_ITERABLE),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is not of type array.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert !array $actual
+	 */
+	public static function assertIsNotArray($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new LogicalNot(new IsType(IsType::TYPE_ARRAY)),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is not of type bool.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert !bool $actual
+	 */
+	public static function assertIsNotBool($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new LogicalNot(new IsType(IsType::TYPE_BOOL)),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is not of type float.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert !float $actual
+	 */
+	public static function assertIsNotFloat($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new LogicalNot(new IsType(IsType::TYPE_FLOAT)),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is not of type int.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert !int $actual
+	 */
+	public static function assertIsNotInt($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new LogicalNot(new IsType(IsType::TYPE_INT)),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is not of type numeric.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert !numeric $actual
+	 */
+	public static function assertIsNotNumeric($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new LogicalNot(new IsType(IsType::TYPE_NUMERIC)),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is not of type object.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert !object $actual
+	 */
+	public static function assertIsNotObject($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new LogicalNot(new IsType(IsType::TYPE_OBJECT)),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is not of type resource.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert !resource $actual
+	 */
+	public static function assertIsNotResource($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new LogicalNot(new IsType(IsType::TYPE_RESOURCE)),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is not of type resource.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert !resource $actual
+	 */
+	public static function assertIsNotClosedResource($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new LogicalNot(new IsType(IsType::TYPE_CLOSED_RESOURCE)),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is not of type string.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert !string $actual
+	 */
+	public static function assertIsNotString($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new LogicalNot(new IsType(IsType::TYPE_STRING)),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is not of type scalar.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert !scalar $actual
+	 */
+	public static function assertIsNotScalar($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new LogicalNot(new IsType(IsType::TYPE_SCALAR)),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is not of type callable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert !callable $actual
+	 */
+	public static function assertIsNotCallable($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new LogicalNot(new IsType(IsType::TYPE_CALLABLE)),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a variable is not of type iterable.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @psalm-assert !iterable $actual
+	 */
+	public static function assertIsNotIterable($actual, string $message = ''): void
+	{
+		static::assertThat(
+			$actual,
+			new LogicalNot(new IsType(IsType::TYPE_ITERABLE)),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a string matches a given regular expression.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertMatchesRegularExpression(string $pattern, string $string, string $message = ''): void
+	{
+		static::assertThat($string, new RegularExpression($pattern), $message);
+	}
+
+	/**
+	 * Asserts that a string matches a given regular expression.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4086
+	 */
+	public static function assertRegExp(string $pattern, string $string, string $message = ''): void
+	{
+		self::createWarning('assertRegExp() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertMatchesRegularExpression() instead.');
+
+		static::assertThat($string, new RegularExpression($pattern), $message);
+	}
+
+	/**
+	 * Asserts that a string does not match a given regular expression.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertDoesNotMatchRegularExpression(string $pattern, string $string, string $message = ''): void
+	{
+		static::assertThat(
+			$string,
+			new LogicalNot(
+				new RegularExpression($pattern)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a string does not match a given regular expression.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4089
+	 */
+	public static function assertNotRegExp(string $pattern, string $string, string $message = ''): void
+	{
+		self::createWarning('assertNotRegExp() is deprecated and will be removed in PHPUnit 10. Refactor your code to use assertDoesNotMatchRegularExpression() instead.');
+
+		static::assertThat(
+			$string,
+			new LogicalNot(
+				new RegularExpression($pattern)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Assert that the size of two arrays (or `Countable` or `Traversable` objects)
+	 * is the same.
+	 *
+	 * @param Countable|iterable $expected
+	 * @param Countable|iterable $actual
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertSameSize($expected, $actual, string $message = ''): void
+	{
+		if (!$expected instanceof Countable && !is_iterable($expected)) {
+			throw InvalidArgumentException::create(1, 'countable or iterable');
+		}
+
+		if (!$actual instanceof Countable && !is_iterable($actual)) {
+			throw InvalidArgumentException::create(2, 'countable or iterable');
+		}
+
+		static::assertThat(
+			$actual,
+			new SameSize($expected),
+			$message
+		);
+	}
+
+	/**
+	 * Assert that the size of two arrays (or `Countable` or `Traversable` objects)
+	 * is not the same.
+	 *
+	 * @param Countable|iterable $expected
+	 * @param Countable|iterable $actual
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertNotSameSize($expected, $actual, string $message = ''): void
+	{
+		if (!$expected instanceof Countable && !is_iterable($expected)) {
+			throw InvalidArgumentException::create(1, 'countable or iterable');
+		}
+
+		if (!$actual instanceof Countable && !is_iterable($actual)) {
+			throw InvalidArgumentException::create(2, 'countable or iterable');
+		}
+
+		static::assertThat(
+			$actual,
+			new LogicalNot(
+				new SameSize($expected)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a string matches a given format string.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringMatchesFormat(string $format, string $string, string $message = ''): void
+	{
+		static::assertThat($string, new StringMatchesFormatDescription($format), $message);
+	}
+
+	/**
+	 * Asserts that a string does not match a given format string.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringNotMatchesFormat(string $format, string $string, string $message = ''): void
+	{
+		static::assertThat(
+			$string,
+			new LogicalNot(
+				new StringMatchesFormatDescription($format)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a string matches a given format file.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringMatchesFormatFile(string $formatFile, string $string, string $message = ''): void
+	{
+		static::assertFileExists($formatFile, $message);
+
+		static::assertThat(
+			$string,
+			new StringMatchesFormatDescription(
+				file_get_contents($formatFile)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a string does not match a given format string.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringNotMatchesFormatFile(string $formatFile, string $string, string $message = ''): void
+	{
+		static::assertFileExists($formatFile, $message);
+
+		static::assertThat(
+			$string,
+			new LogicalNot(
+				new StringMatchesFormatDescription(
+					file_get_contents($formatFile)
+				)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that a string starts with a given prefix.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringStartsWith(string $prefix, string $string, string $message = ''): void
+	{
+		static::assertThat($string, new StringStartsWith($prefix), $message);
+	}
+
+	/**
+	 * Asserts that a string starts not with a given prefix.
+	 *
+	 * @param string $prefix
+	 * @param string $string
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringStartsNotWith($prefix, $string, string $message = ''): void
+	{
+		static::assertThat(
+			$string,
+			new LogicalNot(
+				new StringStartsWith($prefix)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringContainsString(string $needle, string $haystack, string $message = ''): void
+	{
+		$constraint = new StringContains($needle, false);
+
+		static::assertThat($haystack, $constraint, $message);
+	}
+
+	/**
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringContainsStringIgnoringCase(string $needle, string $haystack, string $message = ''): void
+	{
+		$constraint = new StringContains($needle, true);
+
+		static::assertThat($haystack, $constraint, $message);
+	}
+
+	/**
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringNotContainsString(string $needle, string $haystack, string $message = ''): void
+	{
+		$constraint = new LogicalNot(new StringContains($needle));
+
+		static::assertThat($haystack, $constraint, $message);
+	}
+
+	/**
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringNotContainsStringIgnoringCase(string $needle, string $haystack, string $message = ''): void
+	{
+		$constraint = new LogicalNot(new StringContains($needle, true));
+
+		static::assertThat($haystack, $constraint, $message);
+	}
+
+	/**
+	 * Asserts that a string ends with a given suffix.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringEndsWith(string $suffix, string $string, string $message = ''): void
+	{
+		static::assertThat($string, new StringEndsWith($suffix), $message);
+	}
+
+	/**
+	 * Asserts that a string ends not with a given suffix.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertStringEndsNotWith(string $suffix, string $string, string $message = ''): void
+	{
+		static::assertThat(
+			$string,
+			new LogicalNot(
+				new StringEndsWith($suffix)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that two XML files are equal.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws Exception
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertXmlFileEqualsXmlFile(string $expectedFile, string $actualFile, string $message = ''): void
+	{
+		$expected = (new XmlLoader)->loadFile($expectedFile);
+		$actual   = (new XmlLoader)->loadFile($actualFile);
+
+		static::assertEquals($expected, $actual, $message);
+	}
+
+	/**
+	 * Asserts that two XML files are not equal.
+	 *
+	 * @throws \PHPUnit\Util\Exception
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertXmlFileNotEqualsXmlFile(string $expectedFile, string $actualFile, string $message = ''): void
+	{
+		$expected = (new XmlLoader)->loadFile($expectedFile);
+		$actual   = (new XmlLoader)->loadFile($actualFile);
+
+		static::assertNotEquals($expected, $actual, $message);
+	}
+
+	/**
+	 * Asserts that two XML documents are equal.
+	 *
+	 * @param DOMDocument|string $actualXml
+	 *
+	 * @throws \PHPUnit\Util\Xml\Exception
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertXmlStringEqualsXmlFile(string $expectedFile, $actualXml, string $message = ''): void
+	{
+		if (!is_string($actualXml)) {
+			self::createWarning('Passing an argument of type DOMDocument for the $actualXml parameter is deprecated. Support for this will be removed in PHPUnit 10.');
+
+			$actual = $actualXml;
+		} else {
+			$actual = (new XmlLoader)->load($actualXml);
+		}
+
+		$expected = (new XmlLoader)->loadFile($expectedFile);
+
+		static::assertEquals($expected, $actual, $message);
+	}
+
+	/**
+	 * Asserts that two XML documents are not equal.
+	 *
+	 * @param DOMDocument|string $actualXml
+	 *
+	 * @throws \PHPUnit\Util\Xml\Exception
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertXmlStringNotEqualsXmlFile(string $expectedFile, $actualXml, string $message = ''): void
+	{
+		if (!is_string($actualXml)) {
+			self::createWarning('Passing an argument of type DOMDocument for the $actualXml parameter is deprecated. Support for this will be removed in PHPUnit 10.');
+
+			$actual = $actualXml;
+		} else {
+			$actual = (new XmlLoader)->load($actualXml);
+		}
+
+		$expected = (new XmlLoader)->loadFile($expectedFile);
+
+		static::assertNotEquals($expected, $actual, $message);
+	}
+
+	/**
+	 * Asserts that two XML documents are equal.
+	 *
+	 * @param DOMDocument|string $expectedXml
+	 * @param DOMDocument|string $actualXml
+	 *
+	 * @throws \PHPUnit\Util\Xml\Exception
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertXmlStringEqualsXmlString($expectedXml, $actualXml, string $message = ''): void
+	{
+		if (!is_string($expectedXml)) {
+			self::createWarning('Passing an argument of type DOMDocument for the $expectedXml parameter is deprecated. Support for this will be removed in PHPUnit 10.');
+
+			$expected = $expectedXml;
+		} else {
+			$expected = (new XmlLoader)->load($expectedXml);
+		}
+
+		if (!is_string($actualXml)) {
+			self::createWarning('Passing an argument of type DOMDocument for the $actualXml parameter is deprecated. Support for this will be removed in PHPUnit 10.');
+
+			$actual = $actualXml;
+		} else {
+			$actual = (new XmlLoader)->load($actualXml);
+		}
+
+		static::assertEquals($expected, $actual, $message);
+	}
+
+	/**
+	 * Asserts that two XML documents are not equal.
+	 *
+	 * @param DOMDocument|string $expectedXml
+	 * @param DOMDocument|string $actualXml
+	 *
+	 * @throws \PHPUnit\Util\Xml\Exception
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertXmlStringNotEqualsXmlString($expectedXml, $actualXml, string $message = ''): void
+	{
+		if (!is_string($expectedXml)) {
+			self::createWarning('Passing an argument of type DOMDocument for the $expectedXml parameter is deprecated. Support for this will be removed in PHPUnit 10.');
+
+			$expected = $expectedXml;
+		} else {
+			$expected = (new XmlLoader)->load($expectedXml);
+		}
+
+		if (!is_string($actualXml)) {
+			self::createWarning('Passing an argument of type DOMDocument for the $actualXml parameter is deprecated. Support for this will be removed in PHPUnit 10.');
+
+			$actual = $actualXml;
+		} else {
+			$actual = (new XmlLoader)->load($actualXml);
+		}
+
+		static::assertNotEquals($expected, $actual, $message);
+	}
+
+	/**
+	 * Asserts that a hierarchy of DOMElements matches.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws AssertionFailedError
+	 * @throws ExpectationFailedException
+	 *
+	 * @codeCoverageIgnore
+	 *
+	 * @deprecated https://github.com/sebastianbergmann/phpunit/issues/4091
+	 */
+	public static function assertEqualXMLStructure(DOMElement $expectedElement, DOMElement $actualElement, bool $checkAttributes = false, string $message = ''): void
+	{
+		self::createWarning('assertEqualXMLStructure() is deprecated and will be removed in PHPUnit 10.');
+
+		$expectedElement = Xml::import($expectedElement);
+		$actualElement   = Xml::import($actualElement);
+
+		static::assertSame(
+			$expectedElement->tagName,
+			$actualElement->tagName,
+			$message
+		);
+
+		if ($checkAttributes) {
+			static::assertSame(
+				$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);
+
+				assert($expectedAttribute instanceof DOMAttr);
+
+				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::assertSame(
+			$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.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertThat($value, Constraint $constraint, string $message = ''): void
+	{
+		self::$count += count($constraint);
+
+		$constraint->evaluate($value, $message);
+	}
+
+	/**
+	 * Asserts that a string is a valid JSON string.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertJson(string $actualJson, string $message = ''): void
+	{
+		static::assertThat($actualJson, static::isJson(), $message);
+	}
+
+	/**
+	 * Asserts that two given JSON encoded objects or arrays are equal.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertJsonStringEqualsJsonString(string $expectedJson, string $actualJson, string $message = ''): void
+	{
+		static::assertJson($expectedJson, $message);
+		static::assertJson($actualJson, $message);
+
+		static::assertThat($actualJson, new JsonMatches($expectedJson), $message);
+	}
+
+	/**
+	 * Asserts that two given JSON encoded objects or arrays are not equal.
+	 *
+	 * @param string $expectedJson
+	 * @param string $actualJson
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertJsonStringNotEqualsJsonString($expectedJson, $actualJson, string $message = ''): void
+	{
+		static::assertJson($expectedJson, $message);
+		static::assertJson($actualJson, $message);
+
+		static::assertThat(
+			$actualJson,
+			new LogicalNot(
+				new JsonMatches($expectedJson)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that the generated JSON encoded object and the content of the given file are equal.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertJsonStringEqualsJsonFile(string $expectedFile, string $actualJson, string $message = ''): void
+	{
+		static::assertFileExists($expectedFile, $message);
+		$expectedJson = file_get_contents($expectedFile);
+
+		static::assertJson($expectedJson, $message);
+		static::assertJson($actualJson, $message);
+
+		static::assertThat($actualJson, new JsonMatches($expectedJson), $message);
+	}
+
+	/**
+	 * Asserts that the generated JSON encoded object and the content of the given file are not equal.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertJsonStringNotEqualsJsonFile(string $expectedFile, string $actualJson, string $message = ''): void
+	{
+		static::assertFileExists($expectedFile, $message);
+		$expectedJson = file_get_contents($expectedFile);
+
+		static::assertJson($expectedJson, $message);
+		static::assertJson($actualJson, $message);
+
+		static::assertThat(
+			$actualJson,
+			new LogicalNot(
+				new JsonMatches($expectedJson)
+			),
+			$message
+		);
+	}
+
+	/**
+	 * Asserts that two JSON files are equal.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertJsonFileEqualsJsonFile(string $expectedFile, string $actualFile, string $message = ''): void
+	{
+		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.
+	 *
+	 * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
+	 * @throws ExpectationFailedException
+	 */
+	public static function assertJsonFileNotEqualsJsonFile(string $expectedFile, string $actualFile, string $message = ''): void
+	{
+		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);
+	}
+
+	/**
+	 * @throws Exception
+	 */
+	public static function logicalAnd(): LogicalAnd
+	{
+		$constraints = func_get_args();
+
+		$constraint = new LogicalAnd;
+		$constraint->setConstraints($constraints);
+
+		return $constraint;
+	}
+
+	public static function logicalOr(): LogicalOr
+	{
+		$constraints = func_get_args();
+
+		$constraint = new LogicalOr;
+		$constraint->setConstraints($constraints);
+
+		return $constraint;
+	}
+
+	public static function logicalNot(Constraint $constraint): LogicalNot
+	{
+		return new LogicalNot($constraint);
+	}
+
+	public static function logicalXor(): LogicalXor
+	{
+		$constraints = func_get_args();
+
+		$constraint = new LogicalXor;
+		$constraint->setConstraints($constraints);
+
+		return $constraint;
+	}
+
+	public static function anything(): IsAnything
+	{
+		return new IsAnything;
+	}
+
+	public static function isTrue(): IsTrue
+	{
+		return new IsTrue;
+	}
+
+	/**
+	 * @psalm-template CallbackInput of mixed
+	 *
+	 * @psalm-param callable(CallbackInput $callback): bool $callback
+	 *
+	 * @psalm-return Callback<CallbackInput>
+	 */
+	public static function callback(callable $callback): Callback
+	{
+		return new Callback($callback);
+	}
+
+	public static function isFalse(): IsFalse
+	{
+		return new IsFalse;
+	}
+
+	public static function isJson(): IsJson
+	{
+		return new IsJson;
+	}
+
+	public static function isNull(): IsNull
+	{
+		return new IsNull;
+	}
+
+	public static function isFinite(): IsFinite
+	{
+		return new IsFinite;
+	}
+
+	public static function isInfinite(): IsInfinite
+	{
+		return new IsInfinite;
+	}
+
+	public static function isNan(): IsNan
+	{
+		return new IsNan;
+	}
+
+	public static function containsEqual($value): TraversableContainsEqual
+	{
+		return new TraversableContainsEqual($value);
+	}
+
+	public static function containsIdentical($value): TraversableContainsIdentical
+	{
+		return new TraversableContainsIdentical($value);
+	}
+
+	public static function containsOnly(string $type): TraversableContainsOnly
+	{
+		return new TraversableContainsOnly($type);
+	}
+
+	public static function containsOnlyInstancesOf(string $className): TraversableContainsOnly
+	{
+		return new TraversableContainsOnly($className, false);
+	}
+
+	/**
+	 * @param int|string $key
+	 */
+	public static function arrayHasKey($key): ArrayHasKey
+	{
+		return new ArrayHasKey($key);
+	}
+
+	public static function equalTo($value): IsEqual
+	{
+		return new IsEqual($value, 0.0, false, false);
+	}
+
+	public static function equalToCanonicalizing($value): IsEqualCanonicalizing
+	{
+		return new IsEqualCanonicalizing($value);
+	}
+
+	public static function equalToIgnoringCase($value): IsEqualIgnoringCase
+	{
+		return new IsEqualIgnoringCase($value);
+	}
+
+	public static function equalToWithDelta($value, float $delta): IsEqualWithDelta
+	{
+		return new IsEqualWithDelta($value, $delta);
+	}
+
+	public static function isEmpty(): IsEmpty
+	{
+		return new IsEmpty;
+	}
+
+	public static function isWritable(): IsWritable
+	{
+		return new IsWritable;
+	}
+
+	public static function isReadable(): IsReadable
+	{
+		return new IsReadable;
+	}
+
+	public static function directoryExists(): DirectoryExists
+	{
+		return new DirectoryExists;
+	}
+
+	public static function fileExists(): FileExists
+	{
+		return new FileExists;
+	}
+
+	public static function greaterThan($value): GreaterThan
+	{
+		return new GreaterThan($value);
+	}
+
+	public static function greaterThanOrEqual($value): LogicalOr
+	{
+		return static::logicalOr(
+			new IsEqual($value),
+			new GreaterThan($value)
+		);
+	}
+
+	public static function classHasAttribute(string $attributeName): ClassHasAttribute
+	{
+		return new ClassHasAttribute($attributeName);
+	}
+
+	public static function classHasStaticAttribute(string $attributeName): ClassHasStaticAttribute
+	{
+		return new ClassHasStaticAttribute($attributeName);
+	}
+
+	public static function objectHasAttribute($attributeName): ObjectHasAttribute
+	{
+		return new ObjectHasAttribute($attributeName);
+	}
+
+	public static function identicalTo($value): IsIdentical
+	{
+		return new IsIdentical($value);
+	}
+
+	public static function isInstanceOf(string $className): IsInstanceOf
+	{
+		return new IsInstanceOf($className);
+	}
+
+	public static function isType(string $type): IsType
+	{
+		return new IsType($type);
+	}
+
+	public static function lessThan($value): LessThan
+	{
+		return new LessThan($value);
+	}
+
+	public static function lessThanOrEqual($value): LogicalOr
+	{
+		return static::logicalOr(
+			new IsEqual($value),
+			new LessThan($value)
+		);
+	}
+
+	public static function matchesRegularExpression(string $pattern): RegularExpression
+	{
+		return new RegularExpression($pattern);
+	}
+
+	public static function matches(string $string): StringMatchesFormatDescription
+	{
+		return new StringMatchesFormatDescription($string);
+	}
+
+	public static function stringStartsWith($prefix): StringStartsWith
+	{
+		return new StringStartsWith($prefix);
+	}
+
+	public static function stringContains(string $string, bool $case = true): StringContains
+	{
+		return new StringContains($string, $case);
+	}
+
+	public static function stringEndsWith(string $suffix): StringEndsWith
+	{
+		return new StringEndsWith($suffix);
+	}
+
+	public static function countOf(int $count): Count
+	{
+		return new Count($count);
+	}
+
+	public static function objectEquals(object $object, string $method = 'equals'): ObjectEquals
+	{
+		return new ObjectEquals($object, $method);
+	}
+
+	/**
+	 * Fails a test with the given message.
+	 *
+	 * @throws AssertionFailedError
+	 *
+	 * @psalm-return never-return
+	 */
+	public static function fail(string $message = ''): void
+	{
+		self::$count++;
+
+		throw new AssertionFailedError($message);
+	}
+
+	/**
+	 * Mark the test as incomplete.
+	 *
+	 * @throws IncompleteTestError
+	 *
+	 * @psalm-return never-return
+	 */
+	public static function markTestIncomplete(string $message = ''): void
+	{
+		throw new IncompleteTestError($message);
+	}
+
+	/**
+	 * Mark the test as skipped.
+	 *
+	 * @throws SkippedTestError
+	 * @throws SyntheticSkippedError
+	 *
+	 * @psalm-return never-return
+	 */
+	public static function markTestSkipped(string $message = ''): void
+	{
+		if ($hint = self::detectLocationHint($message)) {
+			$trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
+			array_unshift($trace, $hint);
+
+			throw new SyntheticSkippedError($hint['message'], 0, $hint['file'], (int) $hint['line'], $trace);
+		}
+
+		throw new SkippedTestError($message);
+	}
+
+	/**
+	 * Return the current assertion count.
+	 */
+	public static function getCount(): int
+	{
+		return self::$count;
+	}
+
+	/**
+	 * Reset the assertion counter.
+	 */
+	public static function resetCount(): void
+	{
+		self::$count = 0;
+	}
+
+	private static function detectLocationHint(string $message): ?array
+	{
+		$hint  = null;
+		$lines = preg_split('/\r\n|\r|\n/', $message);
+
+		while (strpos($lines[0], '__OFFSET') !== false) {
+			$offset = explode('=', array_shift($lines));
+
+			if ($offset[0] === '__OFFSET_FILE') {
+				$hint['file'] = $offset[1];
+			}
+
+			if ($offset[0] === '__OFFSET_LINE') {
+				$hint['line'] = $offset[1];
+			}
+		}
+
+		if ($hint) {
+			$hint['message'] = implode(PHP_EOL, $lines);
+		}
+
+		return $hint;
+	}
+
+	private static function isValidObjectAttributeName(string $attributeName): bool
+	{
+		return (bool) preg_match('/[^\x00-\x1f\x7f-\x9f]+/', $attributeName);
+	}
+
+	private static function isValidClassAttributeName(string $attributeName): bool
+	{
+		return (bool) preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/', $attributeName);
+	}
+
+	/**
+	 * @codeCoverageIgnore
+	 */
+	private static function createWarning(string $warning): void
+	{
+		foreach (debug_backtrace() as $step) {
+			if (isset($step['object']) && $step['object'] instanceof TestCase) {
+				assert($step['object'] instanceof TestCase);
+
+				$step['object']->addWarning($warning);
+
+				break;
+			}
+		}
+	}
 }