<?php declare(strict_types=1);

/*

* This file is part of PHPUnit.

*

* (c) Sebastian Bergmann <[email protected]>

*

* For the full copyright and license information, please view the LICENSE

* file that was distributed with this source code.

*/

namespace PHPUnit\Framework;

use const DEBUG_BACKTRACE_IGNORE_ARGS;

use const PHP_EOL;

use function array_shift;

use function array_unshift;

use function assert;

use function class_exists;

use function count;

use function debug_backtrace;

use function explode;

use function file_get_contents;

use function func_get_args;

use function implode;

use function interface_exists;

use function is_array;

use function is_bool;

use function is_int;

use function is_iterable;

use function is_object;

use function is_string;

use function preg_match;

use function preg_split;

use function sprintf;

use function strpos;

use ArrayAccess;

use Countable;

use DOMAttr;

use DOMDocument;

use DOMElement;

use PHPUnit\Framework\Constraint\ArrayHasKey;

use PHPUnit\Framework\Constraint\Callback;

use PHPUnit\Framework\Constraint\ClassHasAttribute;

use PHPUnit\Framework\Constraint\ClassHasStaticAttribute;

use PHPUnit\Framework\Constraint\Constraint;

use PHPUnit\Framework\Constraint\Count;

use PHPUnit\Framework\Constraint\DirectoryExists;

use PHPUnit\Framework\Constraint\FileExists;

use PHPUnit\Framework\Constraint\GreaterThan;

use PHPUnit\Framework\Constraint\IsAnything;

use PHPUnit\Framework\Constraint\IsEmpty;

use PHPUnit\Framework\Constraint\IsEqual;

use PHPUnit\Framework\Constraint\IsEqualCanonicalizing;

use PHPUnit\Framework\Constraint\IsEqualIgnoringCase;

use PHPUnit\Framework\Constraint\IsEqualWithDelta;

use PHPUnit\Framework\Constraint\IsFalse;

use PHPUnit\Framework\Constraint\IsFinite;

use PHPUnit\Framework\Constraint\IsIdentical;

use PHPUnit\Framework\Constraint\IsInfinite;

use PHPUnit\Framework\Constraint\IsInstanceOf;

use PHPUnit\Framework\Constraint\IsJson;

use PHPUnit\Framework\Constraint\IsNan;

use PHPUnit\Framework\Constraint\IsNull;

use PHPUnit\Framework\Constraint\IsReadable;

use PHPUnit\Framework\Constraint\IsTrue;

use PHPUnit\Framework\Constraint\IsType;

use PHPUnit\Framework\Constraint\IsWritable;

use PHPUnit\Framework\Constraint\JsonMatches;

use PHPUnit\Framework\Constraint\LessThan;

use PHPUnit\Framework\Constraint\LogicalAnd;

use PHPUnit\Framework\Constraint\LogicalNot;

use PHPUnit\Framework\Constraint\LogicalOr;

use PHPUnit\Framework\Constraint\LogicalXor;

use PHPUnit\Framework\Constraint\ObjectEquals;

use PHPUnit\Framework\Constraint\ObjectHasAttribute;

use PHPUnit\Framework\Constraint\RegularExpression;

use PHPUnit\Framework\Constraint\SameSize;

use PHPUnit\Framework\Constraint\StringContains;

use PHPUnit\Framework\Constraint\StringEndsWith;

use PHPUnit\Framework\Constraint\StringMatchesFormatDescription;

use PHPUnit\Framework\Constraint\StringStartsWith;

use PHPUnit\Framework\Constraint\TraversableContainsEqual;

use PHPUnit\Framework\Constraint\TraversableContainsIdentical;

use PHPUnit\Framework\Constraint\TraversableContainsOnly;

use PHPUnit\Util\Type;

use PHPUnit\Util\Xml;

use PHPUnit\Util\Xml\Loader as XmlLoader;

/**

* @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

* @throws Exception

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

* @throws Exception

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

* @throws Exception

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

* @throws Exception

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

* @throws Exception

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

* @throws Exception

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*

* @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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*

* @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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*

* @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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*

* @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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

public static function assertDirectoryExists(string $directory, string $message = ''): void

{

static::assertThat($directory, new DirectoryExists, $message);

}

/**

* Asserts that a directory does not exist.

*

* @throws ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*

* @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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*

* @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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*

* @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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

public static function assertFileExists(string $filename, string $message = ''): void

{

static::assertThat($filename, new FileExists, $message);

}

/**

* Asserts that a file does not exist.

*

* @throws ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*

* @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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*/

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 ExpectationFailedException

* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException

*

* @codeCoverageIgnore