1. Assertions
This appendix lists the various assertion methods that are available.
Static vs. Non-Static Usage of Assertion Methods
PHPUnit’s assertions are implemented in PHPUnit\Framework\Assert.
PHPUnit\Framework\TestCase inherits from PHPUnit\Framework\Assert.
The assertion methods are declared static and can be invoked
from any context using PHPUnit\Framework\Assert::assertTrue(),
for instance, or using $this->assertTrue() or self::assertTrue(),
for instance, in a class that extends PHPUnit\Framework\TestCase.
You can even use global function wrappers such as assertTrue().
A common question, especially from developers new to PHPUnit, is whether
using $this->assertTrue() or self::assertTrue(),
for instance, is “the right way” to invoke an assertion. The short answer
is: there is no right way. And there is no wrong way, either. It is a
matter of personal preference.
For most people it just “feels right” to use $this->assertTrue()
because the test method is invoked on a test object. The fact that the
assertion methods are declared static allows for (re)using
them outside the scope of a test object. Lastly, the global function
wrappers allow developers to type less characters (assertTrue() instead
of $this->assertTrue() or self::assertTrue()).
Boolean
assertTrue()
assertTrue(bool $condition[, string $message])
Reports an error identified by $message if $condition is false.
assertNotTrue() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class TrueTest extends TestCase
{
public function testFailure(): void
{
$this->assertTrue(false);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/TrueTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) TrueTest::testFailure
Failed asserting that false is true.
/path/to/tests/TrueTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertFalse()
assertFalse(bool $condition[, string $message])
Reports an error identified by $message if $condition is true.
assertNotFalse() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class FalseTest extends TestCase
{
public function testFailure(): void
{
$this->assertFalse(true);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/FalseTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) FalseTest::testFailure
Failed asserting that true is false.
/path/to/tests/FalseTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
Identity
assertSame()
assertSame(mixed $expected, mixed $actual[, string $message])
Reports an error identified by $message if the two variables $expected and $actual do not have the same type and value.
assertNotSame() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class SameWithMixedTest extends TestCase
{
public function testFailure(): void
{
$this->assertSame('2204', 2204);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/SameWithMixedTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) SameWithMixedTest::testFailure
Failed asserting that 2204 is identical to '2204'.
/path/to/tests/SameWithMixedTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertSame(object $expected, object $actual[, string $message])
Reports an error identified by $message if the two variables $expected and $actual do not reference the same object.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class SameWithObjectsTest extends TestCase
{
public function testFailure(): void
{
$this->assertSame(new stdClass, new stdClass);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/SameWithObjectsTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) SameWithObjectsTest::testFailure
Failed asserting that two variables reference the same object.
/path/to/tests/SameWithObjectsTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
Identity is checked using the === operator.
assertArrayIsIdenticalToArrayOnlyConsideringListOfKeys()
assertArrayIsIdenticalToArrayOnlyConsideringListOfKeys(array $expected, array $actual, array $keysToBeConsidered[, string $message])
Reports an error identified by $message if two arrays are not identical while only considering array elements for which the keys have been specified.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class ArrayIsIdenticalToArrayOnlyConsideringListOfKeysTest extends TestCase
{
public function testFailure(): void
{
$this->assertArrayIsIdenticalToArrayOnlyConsideringListOfKeys(
[
'timestamp' => time(),
'foo' => 'bar',
],
[
'timestamp' => time(),
'foo' => 'baz',
],
[
'foo',
]
);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/ArrayIsIdenticalToArrayOnlyConsideringListOfKeysTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) ArrayIsIdenticalToArrayOnlyConsideringListOfKeysTest::testFailure
Failed asserting that two arrays are identical.
--- Expected
+++ Actual
@@ @@
Array &0 [
- 'foo' => 'bar',
+ 'foo' => 'baz',
]
/path/to/tests/ArrayIsIdenticalToArrayOnlyConsideringListOfKeysTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertArrayIsIdenticalToArrayIgnoringListOfKeys()
assertArrayIsIdenticalToArrayIgnoringListOfKeys(array $expected, array $actual, array $keysToBeIgnored[, string $message])
Reports an error identified by $message if two arrays are not identical while only ignoring array elements for which the keys have been specified.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class ArrayIsIdenticalToArrayIgnoringListOfKeysTest extends TestCase
{
public function testFailure(): void
{
$this->assertArrayIsIdenticalToArrayIgnoringListOfKeys(
[
'timestamp' => time(),
'foo' => 'bar',
],
[
'timestamp' => time(),
'foo' => 'baz',
],
[
'timestamp',
]
);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/ArrayIsIdenticalToArrayIgnoringListOfKeysTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) ArrayIsIdenticalToArrayIgnoringListOfKeysTest::testFailure
Failed asserting that two arrays are identical.
--- Expected
+++ Actual
@@ @@
Array &0 [
- 'foo' => 'bar',
+ 'foo' => 'baz',
]
/path/to/tests/ArrayIsIdenticalToArrayIgnoringListOfKeysTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
Equality
assertEquals()
assertEquals(mixed $expected, mixed $actual[, string $message])
Reports an error identified by $message if the two variables $expected and $actual are not equal.
assertNotEquals() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class EqualsTest extends TestCase
{
public function testFailure(): void
{
$this->assertEquals(1, 0);
}
public function testFailure2(): void
{
$this->assertEquals('bar', 'baz');
}
public function testFailure3(): void
{
$this->assertEquals("foo\nbar\nbaz\n", "foo\nbah\nbaz\n");
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/EqualsTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
FFF 3 / 3 (100%)
Time: 00:00.001, Memory: 22.86 MB
There were 3 failures:
1) EqualsTest::testFailure
Failed asserting that 0 matches expected 1.
/path/to/tests/EqualsTest.php:8
2) EqualsTest::testFailure2
Failed asserting that two strings are equal.
--- Expected
+++ Actual
@@ @@
-'bar'
+'baz'
/path/to/tests/EqualsTest.php:13
3) EqualsTest::testFailure3
Failed asserting that two strings are equal.
--- Expected
+++ Actual
@@ @@
'foo\n
-bar\n
+bah\n
baz\n
'
/path/to/tests/EqualsTest.php:18
FAILURES!
Tests: 3, Assertions: 3, Failures: 3.
Equality is checked using the == operator, but more specialized comparisons are used for specific
argument types for $expected and $actual, see below.
assertEquals(DateTimeInterface $expected, DateTimeInterface $actual[, string $message])
Reports an error identified by $message if the two points in time represented by the two DateTimeInterface objects $expected and $actual are not equal.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class EqualsWithDateTimeImmutableTest extends TestCase
{
public function testFailure(): void
{
$expected = new DateTimeImmutable('2023-02-23 01:23:45');
$actual = new DateTimeImmutable('2023-02-23 01:23:46');
$this->assertEquals($expected, $actual);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/EqualsWithDateTimeImmutableTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) EqualsWithDateTimeImmutableTest::testFailure
Failed asserting that two DateTime objects are equal.
--- Expected
+++ Actual
@@ @@
-2023-02-23T01:23:45.000000+0100
+2023-02-23T01:23:46.000000+0100
/path/to/tests/EqualsWithDateTimeImmutableTest.php:11
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertEquals(DOMDocument $expected, DOMDocument $actual[, string $message])
Reports an error identified by $message if the uncommented canonical form of the XML documents represented by the two DOMDocument objects $expected and $actual are not equal.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class EqualsWithDomDocumentTest extends TestCase
{
public function testFailure(): void
{
$expected = new DOMDocument;
$expected->loadXML('<foo><bar/></foo>');
$actual = new DOMDocument;
$actual->loadXML('<bar><foo/></bar>');
$this->assertEquals($expected, $actual);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/EqualsWithDomDocumentTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) EqualsWithDomDocumentTest::testFailure
Failed asserting that two DOM documents are equal.
--- Expected
+++ Actual
@@ @@
<?xml version="1.0"?>
-<foo>
- <bar/>
-</foo>
+<bar>
+ <foo/>
+</bar>
/path/to/tests/EqualsWithDomDocumentTest.php:14
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertEquals(object $expected, object $actual[, string $message])
Reports an error identified by $message if the two objects $expected and $actual do not have equal property values.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class EqualsWithObjectsTest extends TestCase
{
public function testFailure(): void
{
$expected = new stdClass;
$expected->foo = 'foo';
$expected->bar = 'bar';
$actual = new stdClass;
$actual->foo = 'bar';
$actual->baz = 'bar';
$this->assertEquals($expected, $actual);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/EqualsWithObjectsTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) EqualsWithObjectsTest::testFailure
Failed asserting that two objects are equal.
--- Expected
+++ Actual
@@ @@
stdClass Object (
- 'foo' => 'foo'
- 'bar' => 'bar'
+ 'foo' => 'bar'
+ 'baz' => 'bar'
)
/path/to/tests/EqualsWithObjectsTest.php:16
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertEquals(array $expected, array $actual[, string $message])
Reports an error identified by $message if the two arrays $expected and $actual are not equal.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class EqualsWithArraysTest extends TestCase
{
public function testFailure(): void
{
$this->assertEquals(['a', 'b', 'c'], ['a', 'c', 'd']);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/EqualsWithArraysTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) EqualsWithArraysTest::testFailure
Failed asserting that two arrays are equal.
--- Expected
+++ Actual
@@ @@
Array (
0 => 'a'
- 1 => 'b'
- 2 => 'c'
+ 1 => 'c'
+ 2 => 'd'
)
/path/to/tests/EqualsWithArraysTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertEqualsCanonicalizing()
assertEqualsCanonicalizing(mixed $expected, mixed $actual[, string $message])
Reports an error identified by $message if the two variables $expected and $actual are not equal.
The contents of $expected and $actual are canonicalized before they are compared. For instance, when the two variables $expected and $actual are arrays, then these arrays are sorted before they are compared. When $expected and $actual are objects, each object is converted to an array containing all private, protected and public properties.
assertNotEqualsCanonicalizing() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class EqualsWithArraysCanonicalizingTest extends TestCase
{
public function testFailure(): void
{
$this->assertEqualsCanonicalizing([3, 2, 1], [2, 3, 0, 1]);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/EqualsWithArraysCanonicalizingTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) EqualsWithArraysCanonicalizingTest::testFailure
Failed asserting that two arrays are equal.
--- Expected
+++ Actual
@@ @@
Array (
- 0 => 1
- 1 => 2
- 2 => 3
+ 0 => 0
+ 1 => 1
+ 2 => 2
+ 3 => 3
)
/path/to/tests/EqualsWithArraysCanonicalizingTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertEqualsIgnoringCase()
assertEqualsIgnoringCase(mixed $expected, mixed $actual[, string $message])
Reports an error identified by $message if the two variables $expected and $actual are not equal.
Differences in casing are ignored for the comparison of $expected and $actual.
assertNotEqualsIgnoringCase() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class EqualsWithStringsIgnoringCaseTest extends TestCase
{
public function testFailure(): void
{
$this->assertEqualsIgnoringCase('foo', 'BAR');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/EqualsWithStringsIgnoringCaseTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) EqualsWithStringsIgnoringCaseTest::testFailure
Failed asserting that two strings are equal.
--- Expected
+++ Actual
@@ @@
-'foo'
+'BAR'
/path/to/tests/EqualsWithStringsIgnoringCaseTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertEqualsWithDelta()
assertEqualsWithDelta(mixed $expected, mixed $actual, float $delta[, string $message])
Reports an error identified by $message if the absolute difference between $expected and $actual is greater than $delta.
Please read “What Every Computer Scientist Should Know About Floating-Point Arithmetic” to understand why $delta is necessary.
assertNotEqualsWithDelta() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class EqualsWithFloatsAndDeltaTest extends TestCase
{
public function testFailure(): void
{
$this->assertEqualsWithDelta(1.0, 1.5, 0.1);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/EqualsWithFloatsAndDeltaTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) EqualsWithFloatsAndDeltaTest::testFailure
Failed asserting that 1.5 matches expected 1.0.
/path/to/tests/EqualsWithFloatsAndDeltaTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertObjectEquals()
assertObjectEquals(object $expected, object $actual, string $method = 'equals'[, string $message])
Reports an error identified by $message if $actual is not equal to $expected according to $actual->$method($expected).
It is a bad practice to use assertEquals() (and its inverse, assertNotEquals()) on objects without registering a custom comparator that customizes how objects are compared. Unfortunately, though, implementing custom comparators for each and every object you want to assert in your tests is inconvenient at best.
The most common use case for custom comparators are Value Objects. These objects usually have an equals(self $other): bool method (or a method just like that but with a different name) for comparing two instances of the Value Object’s type. assertObjectEquals() makes custom comparison of objects convenient for this common use case:
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class ObjectEqualsTest extends TestCase
{
public function testSomething(): void
{
$a = new Email('user@example.org');
$b = new Email('user@example.org');
$c = new Email('user@example.com');
// This passes
$this->assertObjectEquals($a, $b);
// This fails
$this->assertObjectEquals($a, $c);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/ObjectEqualsTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) ObjectEqualsTest::testSomething
Failed asserting that two objects are equal.
/path/to/tests/ObjectEqualsTest.php:16
FAILURES!
Tests: 1, Assertions: 2, Failures: 1.
<?php declare(strict_types=1);
final class Email
{
private string $email;
public function __construct(string $email)
{
$this->ensureIsValidEmail($email);
$this->email = $email;
}
public function asString(): string
{
return $this->email;
}
public function equals(self $other): bool
{
return $this->asString() === $other->asString();
}
private function ensureIsValidEmail(string $email): void
{
// ...
}
}
Please note:
A method with name
$methodmust exist on the$actualobjectThe method must accept exactly one argument
The respective parameter must have a declared type
The
$expectedobject must be compatible with this declared typeThe method must have a declared
boolreturn type
If any of the aforementioned assumptions is not fulfilled or if $actual->$method($expected) returns false then the assertion fails.
assertFileEquals()
assertFileEquals(string $expected, string $actual[, string $message])
Reports an error identified by $message if the file specified by $expected does not have the same contents as the file specified by $actual.
assertFileNotEquals() is the inverse of this assertion and takes the same arguments.
assertFileEqualsCanonicalizing() (and assertFileNotEqualsCanonicalizing()) as well as assertFileEqualsIgnoringCase() (and assertFileNotEqualsIgnoringCase()) do for files what assertEqualsCanonicalizing() (and assertNotEqualsCanonicalizing()) as well as assertEqualsIgnoringCase() (and assertNotEqualsIgnoringCase()) do for strings.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class FileEqualsTest extends TestCase
{
public function testFailure(): void
{
$this->assertFileEquals(
__DIR__ . '/expected.txt',
__DIR__ . '/actual.txt',
);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/FileEqualsTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) FileEqualsTest::testFailure
Failed asserting that two strings are equal.
--- Expected
+++ Actual
@@ @@
-'expected\n
+'actual\n
'
/path/to/tests/FileEqualsTest.php:8
FAILURES!
Tests: 1, Assertions: 3, Failures: 1.
assertArrayIsEqualToArrayOnlyConsideringListOfKeys()
assertArrayIsEqualToArrayOnlyConsideringListOfKeys(array $expected, array $actual, array $keysToBeConsidered[, string $message])
Reports an error identified by $message if two arrays are not equal while only considering array elements for which the keys have been specified.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class ArrayIsEqualToArrayOnlyConsideringListOfKeysTest extends TestCase
{
public function testFailure(): void
{
$this->assertArrayIsEqualToArrayOnlyConsideringListOfKeys(
[
'timestamp' => time(),
'foo' => 'bar',
],
[
'timestamp' => time(),
'foo' => 'baz',
],
[
'foo',
]
);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/ArrayIsEqualToArrayOnlyConsideringListOfKeysTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) ArrayIsEqualToArrayOnlyConsideringListOfKeysTest::testFailure
Failed asserting that two arrays are equal.
--- Expected
+++ Actual
@@ @@
Array (
- 'foo' => 'bar'
+ 'foo' => 'baz'
)
/path/to/tests/ArrayIsEqualToArrayOnlyConsideringListOfKeysTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertArrayIsEqualToArrayIgnoringListOfKeys()
assertArrayIsEqualToArrayIgnoringListOfKeys(array $expected, array $actual, array $keysToBeIgnored[, string $message])
Reports an error identified by $message if two arrays are not equal while only ignoring array elements for which the keys have been specified.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class ArrayIsEqualToArrayIgnoringListOfKeysTest extends TestCase
{
public function testFailure(): void
{
$this->assertArrayIsEqualToArrayIgnoringListOfKeys(
[
'timestamp' => time(),
'foo' => 'bar',
],
[
'timestamp' => time(),
'foo' => 'baz',
],
[
'timestamp',
]
);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/ArrayIsEqualToArrayIgnoringListOfKeysTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) ArrayIsEqualToArrayIgnoringListOfKeysTest::testFailure
Failed asserting that two arrays are equal.
--- Expected
+++ Actual
@@ @@
Array (
- 'foo' => 'bar'
+ 'foo' => 'baz'
)
/path/to/tests/ArrayIsEqualToArrayIgnoringListOfKeysTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
Iterable
assertArrayHasKey()
assertArrayHasKey(int|string $key, array|ArrayAccess $array[, string $message])
Reports an error identified by $message if $array does not have the $key.
assertArrayNotHasKey() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class ArrayHasKeyTest extends TestCase
{
public function testFailure(): void
{
$this->assertArrayHasKey('foo', ['bar' => 'baz']);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/ArrayHasKeyTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) ArrayHasKeyTest::testFailure
Failed asserting that an array has the key 'foo'.
/path/to/tests/ArrayHasKeyTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertContains()
assertContains(mixed $needle, iterable $haystack[, string $message])
Reports an error identified by $message if $needle is not an element of $haystack.
assertNotContains() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class ContainsTest extends TestCase
{
public function testFailure(): void
{
$this->assertContains(4, [1, 2, 3]);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/ContainsTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) ContainsTest::testFailure
Failed asserting that an array contains 4.
/path/to/tests/ContainsTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
Whether $needle is an element of $haystack is checked using the === operator.
You can use assertContainsEquals() (and assertNotContainsEquals()) if you need the
comparison logic implemented by the == operator.
assertContainsOnly()
assertContainsOnly(string $type, iterable $haystack[, boolean $isNativeType = null, string $message = ''])
Reports an error identified by $message if $haystack does not contain only variables of type $type.
$isNativeType is a flag used to indicate whether $type is a native PHP type or not.
assertNotContainsOnly() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class ContainsOnlyTest extends TestCase
{
public function testFailure(): void
{
$this->assertContainsOnly('string', ['1', '2', 3]);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/ContainsOnlyTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) ContainsOnlyTest::testFailure
Failed asserting that Array &0 [
0 => '1',
1 => '2',
2 => 3,
] contains only values of type "string".
/path/to/tests/ContainsOnlyTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertContainsOnlyInstancesOf()
assertContainsOnlyInstancesOf(string $classname, iterable $haystack[, string $message])
Reports an error identified by $message if $haystack does not contain only instances of class $classname.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class ContainsOnlyInstancesOfTest extends TestCase
{
public function testFailure(): void
{
$this->assertContainsOnlyInstancesOf(
Foo::class,
[new Foo, new Bar, new Foo],
);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/ContainsOnlyInstancesOfTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) ContainsOnlyInstancesOfTest::testFailure
Failed asserting that Array &0 [
0 => Foo Object #408 (),
1 => Bar Object #90 (),
2 => Foo Object #84 (),
] contains only values of type "Foo".
/path/to/tests/ContainsOnlyInstancesOfTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
Objects
assertObjectHasProperty()
assertObjectHasProperty(string $propertyName, object $object, string $message = '')
Reports an error identified by $message if $object does not have a property with the name $propertyName.
assertObjectNotHasProperty() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class ObjectHasPropertyTest extends TestCase
{
public function testFailure(): void
{
$this->assertObjectHasProperty('propertyName', new stdClass);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/ObjectHasPropertyTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) ObjectHasPropertyTest::testFailure
Failed asserting that object of class "stdClass" has property "propertyName".
/path/to/tests/ObjectHasPropertyTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
Cardinality
assertCount()
assertCount(int $expectedCount, Countable|iterable $haystack[, string $message])
Reports an error identified by $message if the number of elements in $haystack is not $expectedCount.
assertNotCount() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class CountTest extends TestCase
{
public function testFailure(): void
{
$this->assertCount(0, ['foo']);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/CountTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) CountTest::testFailure
Failed asserting that actual size 1 matches expected size 0.
/path/to/tests/CountTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertSameSize()
assertSameSize(Countable|iterable $expected, Countable|iterable $actual[, string $message])
Reports an error identified by $message if the sizes of $actual and $expected are not the same.
assertNotSameSize() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class SameSizeTest extends TestCase
{
public function testFailure(): void
{
$this->assertSameSize([1, 2], [1]);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/SameSizeTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) SameSizeTest::testFailure
Failed asserting that actual size 1 matches expected size 2.
/path/to/tests/SameSizeTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertEmpty()
assertEmpty(mixed $actual[, string $message])
Reports an error identified by $message if $actual is not empty.
assertNotEmpty() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class EmptyTest extends TestCase
{
public function testFailure(): void
{
$this->assertEmpty(['foo']);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/EmptyTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) EmptyTest::testFailure
Failed asserting that an array is empty.
/path/to/tests/EmptyTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertGreaterThan()
assertGreaterThan(mixed $expected, mixed $actual[, string $message])
Reports an error identified by $message if the value of $actual is not greater than the value of $expected.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class GreaterThanTest extends TestCase
{
public function testFailure(): void
{
$this->assertGreaterThan(2, 1);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/GreaterThanTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) GreaterThanTest::testFailure
Failed asserting that 1 is greater than 2.
/path/to/tests/GreaterThanTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertGreaterThanOrEqual()
assertGreaterThanOrEqual(mixed $expected, mixed $actual[, string $message])
Reports an error identified by $message if the value of $actual is not greater than or equal to the value of $expected.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class GreaterThanOrEqualTest extends TestCase
{
public function testFailure(): void
{
$this->assertGreaterThanOrEqual(2, 1);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/GreaterThanOrEqualTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) GreaterThanOrEqualTest::testFailure
Failed asserting that 1 is equal to 2 or is greater than 2.
/path/to/tests/GreaterThanOrEqualTest.php:8
FAILURES!
Tests: 1, Assertions: 2, Failures: 1.
assertLessThan()
assertLessThan(mixed $expected, mixed $actual[, string $message])
Reports an error identified by $message if the value of $actual is not less than the value of $expected.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class LessThanTest extends TestCase
{
public function testFailure(): void
{
$this->assertLessThan(1, 2);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/LessThanTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) LessThanTest::testFailure
Failed asserting that 2 is less than 1.
/path/to/tests/LessThanTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertLessThanOrEqual()
assertLessThanOrEqual(mixed $expected, mixed $actual[, string $message])
Reports an error identified by $message if the value of $actual is not less than or equal to the value of $expected.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class LessThanOrEqualTest extends TestCase
{
public function testFailure(): void
{
$this->assertLessThanOrEqual(1, 2);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/LessThanOrEqualTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) LessThanOrEqualTest::testFailure
Failed asserting that 2 is equal to 1 or is less than 1.
/path/to/tests/LessThanOrEqualTest.php:8
FAILURES!
Tests: 1, Assertions: 2, Failures: 1.
Types
assertInstanceOf()
assertInstanceOf(string $expected, mixed $actual[, string $message])
Reports an error identified by $message if $actual is not an instance of $expected.
assertNotInstanceOf() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class InstanceOfTest extends TestCase
{
public function testFailure(): void
{
$this->assertInstanceOf(RuntimeException::class, new Exception);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/InstanceOfTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) InstanceOfTest::testFailure
Failed asserting that an object is an instance of class RuntimeException.
/path/to/tests/InstanceOfTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertIsArray()
assertIsArray(mixed $actual[, string $message])
Reports an error identified by $message if $actual is not of type array.
assertIsNotArray() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class IsArrayTest extends TestCase
{
public function testFailure(): void
{
$this->assertIsArray(null);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/IsArrayTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) IsArrayTest::testFailure
Failed asserting that null is of type array.
/path/to/tests/IsArrayTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertIsList()
assertIsList(mixed $actual[, string $message])
Reports an error identified by $message if $actual is not an array where the keys are consecutive numbers from 0 to count($actual) - 1.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class IsListTest extends TestCase
{
public function testFailure(): void
{
$this->assertIsList([1 => 'foo', '3' => 'bar']);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/IsListTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) IsListTest::testFailure
Failed asserting that an array is a list.
/path/to/tests/IsListTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertIsBool()
assertIsBool(mixed $actual[, string $message])
Reports an error identified by $message if $actual is not of type bool.
assertIsNotBool() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class IsBoolTest extends TestCase
{
public function testFailure(): void
{
$this->assertIsBool(null);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/IsBoolTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) IsBoolTest::testFailure
Failed asserting that null is of type bool.
/path/to/tests/IsBoolTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertIsCallable()
assertIsCallable(mixed $actual[, string $message])
Reports an error identified by $message if $actual is not of type callable.
assertIsNotCallable() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class IsCallableTest extends TestCase
{
public function testFailure(): void
{
$this->assertIsCallable(null);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/IsCallableTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) IsCallableTest::testFailure
Failed asserting that null is of type callable.
/path/to/tests/IsCallableTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertIsFloat()
assertIsFloat(mixed $actual[, string $message])
Reports an error identified by $message if $actual is not of type float.
assertIsNotFloat() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class IsFloatTest extends TestCase
{
public function testFailure(): void
{
$this->assertIsFloat(null);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/IsFloatTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) IsFloatTest::testFailure
Failed asserting that null is of type float.
/path/to/tests/IsFloatTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertIsInt()
assertIsInt(mixed $actual[, string $message])
Reports an error identified by $message if $actual is not of type int.
assertIsNotInt() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class IsIntTest extends TestCase
{
public function testFailure(): void
{
$this->assertIsInt(null);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/IsIntTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) IsIntTest::testFailure
Failed asserting that null is of type int.
/path/to/tests/IsIntTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertIsIterable()
assertIsIterable(mixed $actual[, string $message])
Reports an error identified by $message if $actual is not of type iterable.
assertIsNotIterable() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class IsIterableTest extends TestCase
{
public function testFailure(): void
{
$this->assertIsIterable(null);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/IsIterableTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) IsIterableTest::testFailure
Failed asserting that null is of type iterable.
/path/to/tests/IsIterableTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertIsNumeric()
assertIsNumeric(mixed $actual[, string $message])
Reports an error identified by $message if $actual is not of type numeric.
assertIsNotNumeric() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class IsNumericTest extends TestCase
{
public function testFailure(): void
{
$this->assertIsNumeric(null);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/IsNumericTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) IsNumericTest::testFailure
Failed asserting that null is of type numeric.
/path/to/tests/IsNumericTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertIsObject()
assertIsObject(mixed $actual[, string $message])
Reports an error identified by $message if $actual is not of type object.
assertIsNotObject() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class IsObjectTest extends TestCase
{
public function testFailure(): void
{
$this->assertIsObject(null);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/IsObjectTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) IsObjectTest::testFailure
Failed asserting that null is of type object.
/path/to/tests/IsObjectTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertIsResource()
assertIsResource(mixed $actual[, string $message])
Reports an error identified by $message if $actual is not of type resource.
assertIsNotResource() is the inverse of this assertion and takes the same arguments.
assertIsClosedResource() (and assertIsNotClosedResource()) are provided to explicitly check for closed resources.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class IsResourceTest extends TestCase
{
public function testFailure(): void
{
$this->assertIsResource(null);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/IsResourceTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) IsResourceTest::testFailure
Failed asserting that null is of type resource.
/path/to/tests/IsResourceTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertIsScalar()
assertIsScalar(mixed $actual[, string $message])
Reports an error identified by $message if $actual is not of type scalar.
assertIsNotScalar() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class IsScalarTest extends TestCase
{
public function testFailure(): void
{
$this->assertIsScalar(null);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/IsScalarTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) IsScalarTest::testFailure
Failed asserting that null is of type scalar.
/path/to/tests/IsScalarTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertIsString()
assertIsString(mixed $actual[, string $message])
Reports an error identified by $message if $actual is not of type string.
assertIsNotString() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class IsStringTest extends TestCase
{
public function testFailure(): void
{
$this->assertIsString(null);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/IsStringTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) IsStringTest::testFailure
Failed asserting that null is of type string.
/path/to/tests/IsStringTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertNull()
assertNull(mixed $actual[, string $message])
Reports an error identified by $message if $actual is not null.
assertNotNull() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class NullTest extends TestCase
{
public function testFailure(): void
{
$this->assertNull('foo');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/NullTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) NullTest::testFailure
Failed asserting that 'foo' is null.
/path/to/tests/NullTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
Strings
assertStringStartsWith()
assertStringStartsWith(string $prefix, string $string[, string $message])
Reports an error identified by $message if the $string does not start with $prefix.
assertStringStartsNotWith() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class StringStartsWithTest extends TestCase
{
public function testFailure(): void
{
$this->assertStringStartsWith('prefix', 'foo');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/StringStartsWithTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) StringStartsWithTest::testFailure
Failed asserting that 'foo' starts with "prefix".
/path/to/tests/StringStartsWithTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertStringEndsWith()
assertStringEndsWith(string $suffix, string $string[, string $message])
Reports an error identified by $message if the $string does not end with $suffix.
assertStringEndsNotWith() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class StringEndsWithTest extends TestCase
{
public function testFailure(): void
{
$this->assertStringEndsWith('suffix', 'foo');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/StringEndsWithTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) StringEndsWithTest::testFailure
Failed asserting that 'foo' ends with "suffix".
/path/to/tests/StringEndsWithTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertStringContainsString()
assertStringContainsString(string $needle, string $haystack[, string $message])
Reports an error identified by $message if $needle is not a substring of $haystack.
assertStringNotContainsString() is the inverse of this assertion and takes the same arguments.
assertStringContainsStringIgnoringLineEndings() takes the same arguments and can be used if line endings should be ignored.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class StringContainsStringTest extends TestCase
{
public function testFailure(): void
{
$this->assertStringContainsString('foo', 'bar');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/StringContainsStringTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) StringContainsStringTest::testFailure
Failed asserting that 'bar' [ASCII](length: 3) contains "foo" [ASCII](length: 3).
/path/to/tests/StringContainsStringTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertStringContainsStringIgnoringCase()
assertStringContainsStringIgnoringCase(string $needle, string $haystack[, string $message])
Reports an error identified by $message if $needle is not a substring of $haystack.
Differences in casing are ignored when $needle is searched for in $haystack. This also works
for Unicode characters with diacritics (accents, umlauts, circumflex, etc.) as long as both strings
have the same Normalization Form.
assertStringNotContainsStringIgnoringCase() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class StringContainsStringIgnoringCaseTest extends TestCase
{
public function testFailure(): void
{
$this->assertStringContainsStringIgnoringCase('foo', 'bar');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/StringContainsStringIgnoringCaseTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) StringContainsStringIgnoringCaseTest::testFailure
Failed asserting that 'bar' [Encoding ignored](length: 3) contains "foo" [Encoding ignored](length: 3).
/path/to/tests/StringContainsStringIgnoringCaseTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertStringEqualsStringIgnoringLineEndings()
assertStringEqualsStringIgnoringLineEndings(string $expected, string $actual[, string $message])
Reports an error identified by $message if the two strings $expected and $actual are not equal while ignoring line endings.
assertMatchesRegularExpression()
assertMatchesRegularExpression(string $pattern, string $string[, string $message])
Reports an error identified by $message if $string does not match the regular expression $pattern.
assertDoesNotMatchRegularExpression() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class MatchesRegularExpressionTest extends TestCase
{
public function testFailure(): void
{
$this->assertMatchesRegularExpression('/foo/', 'bar');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/MatchesRegularExpressionTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) MatchesRegularExpressionTest::testFailure
Failed asserting that 'bar' matches PCRE pattern "/foo/".
/path/to/tests/MatchesRegularExpressionTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertStringMatchesFormat()
assertStringMatchesFormat(string $format, string $string[, string $message])
Reports an error identified by $message if the $string does not match the $format string.
assertStringNotMatchesFormat() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class StringMatchesFormatTest extends TestCase
{
public function testFailure(): void
{
$this->assertStringMatchesFormat('%i', 'foo');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/StringMatchesFormatTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) StringMatchesFormatTest::testFailure
Failed asserting that string matches format description.
--- Expected
+++ Actual
@@ @@
-%i
+foo
/path/to/tests/StringMatchesFormatTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
The format string may contain the following placeholders:
%e: Represents a directory separator, for example/on Linux.%s: One or more of anything (character or white space) except the end of line character.%S: Zero or more of anything (character or white space) except the end of line character.%a: One or more of anything (character or white space) including the end of line character.%A: Zero or more of anything (character or white space) including the end of line character.%w: Zero or more white space characters.%i: A signed integer value, for example+3142,-3142.%d: An unsigned integer value, for example123456.%x: One or more hexadecimal character. That is, characters in the range0-9,a-f,A-F.%f: A floating point number, for example:3.142,-3.142,3.142E-10,3.142e+10.%c: A single character of any sort.%%: A literal percent character:%.
Deprecation: assertStringNotMatchesFormat() is deprecated
As of PHPUnit 10.4, the assertStringNotMatchesFormat() method is soft-deprecated,
meaning its declaration is annotated with @deprecated so that IDEs and
static analysis tools can warn about its usage.
Starting with PHPUnit 11, using the assertStringNotMatchesFormat() method
will trigger a deprecation warning. The method will be removed in PHPUnit 12.
assertStringMatchesFormatFile()
assertStringMatchesFormatFile(string $formatFile, string $string[, string $message])
Reports an error identified by $message if the $string does not match the contents of the $formatFile.
assertStringNotMatchesFormatFile() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class StringMatchesFormatFileTest extends TestCase
{
public function testFailure(): void
{
$this->assertStringMatchesFormatFile(
__DIR__ . '/expected-format.txt',
'foo',
);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/StringMatchesFormatFileTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) StringMatchesFormatFileTest::testFailure
Failed asserting that string matches format description.
--- Expected
+++ Actual
@@ @@
-%i
+foo
/path/to/tests/StringMatchesFormatFileTest.php:8
FAILURES!
Tests: 1, Assertions: 2, Failures: 1.
Deprecation: assertStringNotMatchesFormatFile() is deprecated
As of PHPUnit 10.4, the assertStringNotMatchesFormatFile() method is soft-deprecated,
meaning its declaration is annotated with @deprecated so that IDEs and
static analysis tools can warn about its usage.
Starting with PHPUnit 11, using the assertStringNotMatchesFormatFile() method
will trigger a deprecation warning. The method will be removed in PHPUnit 12.
assertFileMatchesFormat()
assertFileMatchesFormat(string $format, string $actualFile[, string $message])
Reports an error identified by $message if the contents of $actualFile does not match the $format string.
assertFileMatchesFormatFile()
assertFileMatchesFormat(string $formatFile, string $actualFile[, string $message])
Reports an error identified by $message if the contents of $actualFile does not match the contents of the $formatFile.
assertStringEqualsFile()
assertStringEqualsFile(string $expectedFile, string $actualString[, string $message])
Reports an error identified by $message if the file specified by $expectedFile does not have $actualString as its contents.
assertStringNotEqualsFile() is the inverse of this assertion and takes the same arguments.
assertStringEqualsFileCanonicalizing() (and assertStringNotEqualsFileCanonicalizing()) as well as assertStringEqualsFileIgnoringCase() (and assertStringNotEqualsFileIgnoringCase()) do for files what assertEqualsCanonicalizing() (and assertNotEqualsCanonicalizing()) as well as assertEqualsIgnoringCase() (and assertNotEqualsIgnoringCase()) do for strings.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class StringEqualsFileTest extends TestCase
{
public function testFailure(): void
{
$this->assertStringEqualsFile(
__DIR__ . '/expected.txt',
'actual',
);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/StringEqualsFileTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) StringEqualsFileTest::testFailure
Failed asserting that two strings are equal.
--- Expected
+++ Actual
@@ @@
-'expected\n
-'
+'actual'
/path/to/tests/StringEqualsFileTest.php:8
FAILURES!
Tests: 1, Assertions: 2, Failures: 1.
JSON
assertJson()
assertJson(string $actual[, string $message])
Reports an error identified by $message if the value of $actual is not valid JSON.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class JsonTest extends TestCase
{
public function testFailure(): void
{
$this->assertJson('not-a-json-string');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/JsonTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) JsonTest::testFailure
Failed asserting that a string is valid JSON (Syntax error, malformed JSON).
/path/to/tests/JsonTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertJsonFileEqualsJsonFile()
assertJsonFileEqualsJsonFile(string $expectedFile, string $actualFile[, string $message])
Reports an error identified by $message if the value of $actualFile does not match the value of
$expectedFile.
assertJsonFileNotEqualsJsonFile() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class JsonFileEqualsJsonFileTest extends TestCase
{
public function testFailure(): void
{
$this->assertJsonFileEqualsJsonFile(
__DIR__ . '/expected.json',
__DIR__ . '/actual.json',
);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/JsonFileEqualsJsonFileTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) JsonFileEqualsJsonFileTest::testFailure
Failed asserting that '{"mascot":"elePHPant"}\n
' matches JSON string "{"mascot":"elephant"}
".
--- Expected
+++ Actual
@@ @@
{
- "mascot": "elephant"
+ "mascot": "elePHPant"
}
/path/to/tests/JsonFileEqualsJsonFileTest.php:8
FAILURES!
Tests: 1, Assertions: 5, Failures: 1.
assertJsonStringEqualsJsonFile()
assertJsonStringEqualsJsonFile(string $expectedFile, string $actualJson[, string $message])
Reports an error identified by $message if the value of $actualJson does not match the value of
$expectedFile.
assertJsonStringNotEqualsJsonFile() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class JsonStringEqualsJsonFileTest extends TestCase
{
public function testFailure(): void
{
$this->assertJsonStringEqualsJsonFile(
__DIR__ . '/expected.json',
json_encode(['mascot' => 'elephant']),
);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/JsonStringEqualsJsonFileTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) JsonStringEqualsJsonFileTest::testFailure
Failed asserting that '{"mascot":"elephant"}' matches JSON string "{"mascot":"elePHPant"}
".
--- Expected
+++ Actual
@@ @@
{
- "mascot": "elePHPant"
+ "mascot": "elephant"
}
/path/to/tests/JsonStringEqualsJsonFileTest.php:8
FAILURES!
Tests: 1, Assertions: 4, Failures: 1.
assertJsonStringEqualsJsonString()
assertJsonStringEqualsJsonString(string $expectedJson, string $actualJson[, string $message])
Reports an error identified by $message if the value of $actualJson does not match the value of
$expectedJson.
assertJsonStringNotEqualsJsonString() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class JsonStringEqualsJsonStringTest extends TestCase
{
public function testFailure(): void
{
$this->assertJsonStringEqualsJsonString(
json_encode(['mascot' => 'elePHPant']),
json_encode(['mascot' => 'elephant']),
);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/JsonStringEqualsJsonStringTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) JsonStringEqualsJsonStringTest::testFailure
Failed asserting that '{"mascot":"elephant"}' matches JSON string "{"mascot":"elePHPant"}".
--- Expected
+++ Actual
@@ @@
{
- "mascot": "elePHPant"
+ "mascot": "elephant"
}
/path/to/tests/JsonStringEqualsJsonStringTest.php:8
FAILURES!
Tests: 1, Assertions: 3, Failures: 1.
XML
assertXmlFileEqualsXmlFile()
assertXmlFileEqualsXmlFile(string $expectedFile, string $actualFile[, string $message])
Reports an error identified by $message if the XML document in $actualFile is not equal to the XML document in $expectedFile.
assertXmlFileNotEqualsXmlFile() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class XmlFileEqualsXmlFileTest extends TestCase
{
public function testFailure(): void
{
$this->assertXmlFileEqualsXmlFile(
__DIR__ . '/expected.xml',
__DIR__ . '/actual.xml',
);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/XmlFileEqualsXmlFileTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) XmlFileEqualsXmlFileTest::testFailure
Failed asserting that two DOM documents are equal.
--- Expected
+++ Actual
@@ @@
<?xml version="1.0"?>
<foo>
- <bar/>
+ <baz/>
</foo>
/path/to/tests/XmlFileEqualsXmlFileTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertXmlStringEqualsXmlFile()
assertXmlStringEqualsXmlFile(string $expectedFile, string $actualXml[, string $message])
Reports an error identified by $message if the XML document in $actualXml is not equal to the XML document in $expectedFile.
assertXmlStringNotEqualsXmlFile() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class XmlStringEqualsXmlFileTest extends TestCase
{
public function testFailure(): void
{
$this->assertXmlStringEqualsXmlFile(
__DIR__ . '/expected.xml',
'<foo><baz/></foo>',
);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/XmlStringEqualsXmlFileTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) XmlStringEqualsXmlFileTest::testFailure
Failed asserting that two DOM documents are equal.
--- Expected
+++ Actual
@@ @@
<?xml version="1.0"?>
<foo>
- <bar/>
+ <baz/>
</foo>
/path/to/tests/XmlStringEqualsXmlFileTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertXmlStringEqualsXmlString()
assertXmlStringEqualsXmlString(string $expectedXml, string $actualXml[, string $message])
Reports an error identified by $message if the XML document in $actualXml is not equal to the XML document in $expectedXml.
assertXmlStringNotEqualsXmlString() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class XmlStringEqualsXmlStringTest extends TestCase
{
public function testFailure(): void
{
$this->assertXmlStringEqualsXmlString(
'<foo><bar/></foo>',
'<foo><baz/></foo>',
);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/XmlStringEqualsXmlStringTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) XmlStringEqualsXmlStringTest::testFailure
Failed asserting that two DOM documents are equal.
--- Expected
+++ Actual
@@ @@
<?xml version="1.0"?>
<foo>
- <bar/>
+ <baz/>
</foo>
/path/to/tests/XmlStringEqualsXmlStringTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
Filesystem
assertDirectoryExists()
assertDirectoryExists(string $directory[, string $message])
Reports an error identified by $message if the directory specified by $directory does not exist.
assertDirectoryDoesNotExist() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class DirectoryExistsTest extends TestCase
{
public function testFailure(): void
{
$this->assertDirectoryExists('/path/to/directory');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/DirectoryExistsTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) DirectoryExistsTest::testFailure
Failed asserting that directory "/path/to/directory" exists.
/path/to/tests/DirectoryExistsTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertDirectoryIsReadable()
assertDirectoryIsReadable(string $directory[, string $message])
Reports an error identified by $message if the directory specified by $directory is not a directory or is not readable.
assertDirectoryIsNotReadable() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class DirectoryIsReadableTest extends TestCase
{
public function testFailure(): void
{
$this->assertDirectoryIsReadable('/path/to/directory');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/DirectoryIsReadableTest.php
PHPUnit 10.0.11 by Sebastian Bergmann and contributors.
Runtime: PHP 8.2.3
F
Time: 00:00, Memory: 14.29 MB
There was 1 failure:
1) DirectoryIsReadableTest::testFailure
Failed asserting that "/path/to/directory" is readable.
/path/to/DirectoryIsReadableTest.php:6
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertDirectoryIsWritable()
assertDirectoryIsWritable(string $directory[, string $message])
Reports an error identified by $message if the directory specified by $directory is not a directory or is not writable.
assertDirectoryIsNotWritable() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class DirectoryIsReadableTest extends TestCase
{
public function testFailure(): void
{
$this->assertDirectoryIsReadable('/path/to/directory');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/DirectoryIsWritableTest.php
PHPUnit 10.0.11 by Sebastian Bergmann and contributors.
Runtime: PHP 8.2.3
F
Time: 00:00, Memory: 14.29 MB
There was 1 failure:
1) DirectoryIsWritableTest::testFailure
Failed asserting that "/path/to/directory" is writable.
/path/to/DirectoryIsWritableTest.php:6
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertFileExists()
assertFileExists(string $filename[, string $message])
Reports an error identified by $message if the file specified by $filename does not exist.
assertFileDoesNotExist() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class FileExistsTest extends TestCase
{
public function testFailure(): void
{
$this->assertFileExists('/path/to/file');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/FileExistsTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) FileExistsTest::testFailure
Failed asserting that file "/path/to/file" exists.
/path/to/tests/FileExistsTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertFileIsReadable()
assertFileIsReadable(string $filename[, string $message])
Reports an error identified by $message if the file specified by $filename is not a file or is not readable.
assertFileIsNotReadable() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class FileIsReadableTest extends TestCase
{
public function testFailure(): void
{
$this->assertFileIsReadable('/path/to/file');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/FileIsReadableTest.php
PHPUnit 10.0.11 by Sebastian Bergmann and contributors.
Runtime: PHP 8.2.3
F
Time: 00:00, Memory: 14.29 MB
There was 1 failure:
1) FileIsReadableTest::testFailure
Failed asserting that "/path/to/file" is readable.
/path/to/FileIsReadableTest.php:6
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertFileIsWritable()
assertFileIsWritable(string $filename[, string $message])
Reports an error identified by $message if the file specified by $filename is not a file or is not writable.
assertFileIsNotWritable() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class FileIsWritableTest extends TestCase
{
public function testFailure(): void
{
$this->assertFileIsWritable('/path/to/file');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/FileIsWritableTest.php
PHPUnit 10.0.11 by Sebastian Bergmann and contributors.
Runtime: PHP 8.2.3
F
Time: 00:00, Memory: 14.29 MB
There was 1 failure:
1) FileIsWritableTest::testFailure
Failed asserting that "/path/to/file" is writable.
/path/to/FileIsWritableTest.php:6
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertIsReadable()
assertIsReadable(string $filename[, string $message])
Reports an error identified by $message if the file or directory specified by $filename is not readable.
assertIsNotReadable() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class IsReadableTest extends TestCase
{
public function testFailure(): void
{
$this->assertIsReadable('/path/to/unreadable');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/IsReadableTest.php
PHPUnit 10.0.11 by Sebastian Bergmann and contributors.
Runtime: PHP 8.2.3
F
Time: 00:00, Memory: 14.29 MB
There was 1 failure:
1) IsReadableTest::testFailure
Failed asserting that "/path/to/unreadable" is readable.
/path/to/IsReadableTest.php:6
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertIsWritable()
assertIsWritable(string $filename[, string $message])
Reports an error identified by $message if the file or directory specified by $filename is not writable.
assertIsNotWritable() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class IsWritableTest extends TestCase
{
public function testFailure(): void
{
$this->assertIsWritable('/path/to/unwritable');
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/IsWritableTest.php
PHPUnit 10.0.11 by Sebastian Bergmann and contributors.
Runtime: PHP 8.2.3
F
Time: 00:00, Memory: 14.29 MB
There was 1 failure:
1) IsWritableTest::testFailure
Failed asserting that "/path/to/unwritable" is writable.
/path/to/IsWritableTest.php:6
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
Math
assertInfinite()
assertInfinite(mixed $actual[, string $message])
Reports an error identified by $message if $actual is not INF.
assertFinite() is the inverse of this assertion and takes the same arguments.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class InfiniteTest extends TestCase
{
public function testFailure(): void
{
$this->assertInfinite(1);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/InfiniteTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) InfiniteTest::testFailure
Failed asserting that 1 is infinite.
/path/to/tests/InfiniteTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
assertNan()
assertNan(mixed $actual[, string $message])
Reports an error identified by $message if $actual is not NAN.
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class NanTest extends TestCase
{
public function testFailure(): void
{
$this->assertNan(1);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/NanTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) NanTest::testFailure
Failed asserting that 1 is nan.
/path/to/tests/NanTest.php:8
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
Constraints
assertThat()
assertThat(mixed $value, PHPUnit\Framework\Constraint $constraint[, string $message])
Reports an error identified by $message if the $value does not match the $constraint.
More complex assertions can be formulated using the
PHPUnit\Framework\Constraint classes. They can be
evaluated using the assertThat() method.
This example shows how the logicalNot() and equalTo() constraints can be used,
for instance, to express the same assertion as assertNotEquals():
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class BiscuitTest extends TestCase
{
public function testEquals(): void
{
$theBiscuit = new Biscuit('Ginger');
$myBiscuit = new Biscuit('Ginger');
$this->assertThat(
$theBiscuit,
$this->logicalNot(
$this->equalTo($myBiscuit),
),
);
}
}
Running the test shown above yields the output shown below:
./tools/phpunit tests/BiscuitTest.php
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.
Runtime: PHP 8.3.4
F 1 / 1 (100%)
Time: 00:00, Memory: 22.86 MB
There was 1 failure:
1) BiscuitTest::testEquals
Failed asserting that Biscuit Object #408 (
'name' => 'Ginger',
) is equal to Biscuit Object #90 (
'name' => 'Ginger',
).
/path/to/tests/BiscuitTest.php:11
FAILURES!
Tests: 1, Assertions: 1, Failures: 1.
Table 1.1 shows the
available PHPUnit\Framework\Constraint classes.
Constraint |
Meaning |
|---|---|
|
Constraint that accepts any input value. |
|
Constraint that asserts that the array has a given key. |
|
Constraint that asserts that the |
|
Constraint that asserts that the |
|
Constraint that asserts that the |
|
Constraint that checks if one value is equal to another. |
|
Constraint that checks if the directory exists. |
|
Constraint that checks if the file(name) exists. |
|
Constraint that checks if the file(name) is readable. |
|
Constraint that checks if the file(name) is writable. |
|
Constraint that asserts that the value is greater than a given value. |
|
Constraint that asserts that the value is greater than or equal to a given value. |
|
Constraint that asserts that one value is identical to another. |
|
Constraint that asserts that the value is |
|
Constraint that asserts that the object is an instance of a given class. |
|
Constraint that asserts that the value is |
|
Constraint that asserts that the value is |
|
Constraint that asserts that the value is of a specified type. |
|
Constraint that asserts that the value is smaller than a given value. |
|
Constraint that asserts that the value is smaller than or equal to a given value. |
|
Logical AND. |
|
Logical NOT. |
|
Logical OR. |
|
Logical XOR. |
|
Constraint that asserts that the string matches a regular expression. |
|
Constraint that asserts that the string contains a given string. |
|
Constraint that asserts that the string ends with a given suffix. |
|
Constraint that asserts that the string starts with a given prefix. |