2. Constraints

This section lists the various constraint methods provided by sub-packages of phptailors/phpunit-extensions. The methods may be added to your test class by including appropriate trait as shown in prerequisite tables below.

arrayValuesEqualTo()

Prerequisites for arrayValuesEqualTo()

Package	phptailors/phpunit-arrays
Trait	ArrayValuesEqualToTrait

Synopsis:

function arrayValuesEqualTo(array $expected)

Creates ArrayValuesEqualTo constraint.

The constraint accepts arrays and ArrayAccess objects having values under certain keys equal to these specified in $expected. The constraint uses operator == for comparison.

Usage of arrayValuesEqualTo()

<?php declare(strict_types=1);

final class arrayValuesEqualToTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\ArrayValuesEqualToTrait;

    public function testSuccess(): void
    {
        $this->assertThat(            ['int' => '123', 1 => null,'foo' => 'FOO'],
            $this->arrayValuesEqualTo(['int'  => 123,  1 => '' ])
        );
    }

    public function testFailure(): void
    {
        $this->assertThat(            ['int' => '123', 1 => null,'foo' => 'FOO'],
            $this->arrayValuesEqualTo(['int'  => 123,  1 => '',  'foo' => 'BAR'])
        );
    }
}

PHPUnit 11.1.2 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.3.6
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.007, Memory: 8.00 MB

There was 1 failure:

1) arrayValuesEqualToTest::testFailure
Failed asserting that array is an array or ArrayAccess with values equal to specified.
--- Expected
+++ Actual
@@ @@
-Tailors\PHPUnit\Arrays\ExpectedArrayValues Object #447 (
-    'int' => 123,
-    1 => '',
-    'foo' => 'BAR',
+Tailors\PHPUnit\Arrays\ActualArrayValues Object #444 (
+    'int' => '123',
+    1 => null,
+    'foo' => 'FOO',
 )

arrayValuesEqualToTest.php:16

FAILURES!
Tests: 2, Assertions: 2, Failures: 1.

Since versions *.1 (1.1, 2.1, 3.1, …) it’s possible to nest recursively specification of array values. For more details, see arrayValues().

Usage of arrayValuesEqualTo() with arrayValues()

<?php declare(strict_types=1);

final class arrayValuesEqualToRecursiveTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\ArrayValuesEqualToTrait;
    use \Tailors\PHPUnit\ArrayValuesTrait;

    private $array = [
        'int' => '123',
        'sub' => [
            'int' => 321,
            'bar' => 'BAR',
        ],
        'foo' => 'FOO'
    ];

    public function testSuccess(): void
    {
        $this->assertThat(
            $this->array,
            $this->arrayValuesEqualTo([
                'sub' => $this->arrayValues([
                    'int' => '321'
                ]),
                'int'  => 123,
            ])
        );
    }

    public function testFailure(): void
    {
        $this->assertThat(
            $this->array,
            $this->arrayValuesEqualTo([
                'sub' => [
                    'int' => '321'
                ],
                'int'  => 123,
            ])
        );
    }
}

PHPUnit 10.5.63 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.2.30
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.016, Memory: 8.00 MB

There was 1 failure:

1) arrayValuesEqualToRecursiveTest::testFailure
Failed asserting that array is an array or ArrayAccess with values equal to specified.
--- Expected
+++ Actual
@@ @@
-Tailors\PHPUnit\Arrays\ExpectedArrayValues Object #452 (
+Tailors\PHPUnit\Arrays\ActualArrayValues Object #343 (
     'sub' => Array &0 [
-        'int' => '321',
+        'int' => 321,
+        'bar' => 'BAR',
     ],
-    'int' => 123,
+    'int' => '123',
 )

arrayValuesEqualToRecursiveTest.php:32

FAILURES!
Tests: 2, Assertions: 2, Failures: 1.

arrayValuesIdenticalTo()

Prerequisites for arrayValuesIdenticalTo()

Package	phptailors/phpunit-arrays
Trait	ArrayValuesIdenticalToTrait

Synopsis:

function arrayValuesIdenticalTo(array $expected)

Creates ArrayValuesIdenticalTo constraint.

The constraint accepts arrays and ArrayAccess instances having selected values identical to $expected.

Usage of arrayValuesIdenticalTo()

<?php declare(strict_types=1);

final class arrayValuesIdenticalToTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\ArrayValuesIdenticalToTrait;

    public function testSuccess(): void
    {
        $this->assertThat(                ['int' => 123, 1 => null, 'foo' => 'FOO'],
            $this->arrayValuesIdenticalTo(['int' => 123, 1 => null])
        );
    }

    public function testFailure(): void
    {
        $this->assertThat(                ['int' => 123, 1 => ''],
            $this->arrayValuesIdenticalTo(['int' => 123, 1 => null])
        );
    }
}

PHPUnit 11.1.2 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.3.6
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.007, Memory: 8.00 MB

There was 1 failure:

1) arrayValuesIdenticalToTest::testFailure
Failed asserting that array is an array or ArrayAccess with values identical to specified.
--- Expected
+++ Actual
@@ @@
-Tailors\PHPUnit\Arrays\ExpectedArrayValues Object #447 (
+Tailors\PHPUnit\Arrays\ActualArrayValues Object #444 (
     'int' => 123,
-    1 => null,
+    1 => '',
 )

arrayValuesIdenticalToTest.php:16

FAILURES!
Tests: 2, Assertions: 2, Failures: 1.

Since versions *.1 (1.1, 2.1, 3.1, …) it’s possible to nest recursively specification of array values. For more details, see arrayValues().

Usage of arrayValuesIdenticalTo() with nested selectors

<?php declare(strict_types=1);

final class arrayValuesIdenticalToRecursiveTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\ArrayValuesIdenticalToTrait;
    use \Tailors\PHPUnit\ArrayValuesTrait;

    private $array = [
        'int' => 123,
        'sub' => [
            'int' => 321,
            'bar' => 'BAR',
        ],
        'foo' => 'FOO'
    ];

    public function testSuccess(): void
    {
        $this->assertThat(
            $this->array,
            $this->arrayValuesIdenticalTo([
                'sub' => $this->arrayValues([
                    'int' => 321
                ]),
                'int'  => 123,
            ])
        );
    }

    public function testFailure(): void
    {
        $this->assertThat(
            $this->array,
            $this->arrayValuesIdenticalTo([
                'sub' => [
                    'int' => 321
                ],
                'int'  => 123,
            ])
        );
    }
}

PHPUnit 10.5.63 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.2.30
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.016, Memory: 8.00 MB

There was 1 failure:

1) arrayValuesIdenticalToRecursiveTest::testFailure
Failed asserting that array is an array or ArrayAccess with values identical to specified.
--- Expected
+++ Actual
@@ @@
-Tailors\PHPUnit\Arrays\ExpectedArrayValues Object #426 (
+Tailors\PHPUnit\Arrays\ActualArrayValues Object #343 (
     'sub' => Array &0 [
         'int' => 321,
+        'bar' => 'BAR',
     ],
     'int' => 123,
 )

arrayValuesIdenticalToRecursiveTest.php:32

FAILURES!
Tests: 2, Assertions: 2, Failures: 1.

classPropertiesEqualTo()

Prerequisites for classPropertiesEqualTo()

Package	phptailors/phpunit-properties
Trait	ClassPropertiesEqualToTrait

Synopsis:

function classPropertiesEqualTo(array $expected)

Creates ClassPropertiesEqualTo constraint.

The constraint accepts classes having selected properties equal to $expected.

Usage of classPropertiesEqualTo()

<?php declare(strict_types=1);

final class classPropertiesEqualToTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\ClassPropertiesEqualToTrait;

    public static $attribute = 123;

    public static function getValue(): int
    {
        return 321;
    }

    public function testSuccess(): void
    {
        // assert that:
        $this->assertThat(self::class, $this->classPropertiesEqualTo([
            'attribute'  => '123', // - self::$attribute is 123, equals '123' (ok)
            'getValue()' => 321,   // - self::getValue() is 321 (ok)
        ]));
    }

    public function testFailure(): void
    {
        // assert that:
        $this->assertThat(self::class, $this->classPropertiesEqualTo([
            'attribute'  => '123', // - self::$attribute is 123, equals '123' (ok)
            'getValue()' => null,  // - self::getValue() is 321, not equals null (fail)
        ]));
    }
}

PHPUnit 11.1.2 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.3.6
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.007, Memory: 8.00 MB

There was 1 failure:

1) classPropertiesEqualToTest::testFailure
Failed asserting that classPropertiesEqualToTest is a class with properties equal to specified.
--- Expected
+++ Actual
@@ @@
-Tailors\PHPUnit\Properties\ExpectedClassProperties Object #451 (
-    'attribute' => '123',
-    'getValue()' => null,
+Tailors\PHPUnit\Properties\ActualClassProperties Object #448 (
+    'attribute' => 123,
+    'getValue()' => 321,
 )

classPropertiesEqualToTest.php:26

FAILURES!
Tests: 2, Assertions: 2, Failures: 1.

Since versions *.1 (1.1, 2.1, 3.1, …) it’s possible to nest recursively specifications of class properties. For more details, see arrayValues().

Usage of classPropertiesEqualTo() with classProperties()

<?php declare(strict_types=1);

final class classPropertiesEqualToRecursiveTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\ClassPropertiesEqualToTrait;
    use \Tailors\PHPUnit\ClassPropertiesTrait;

    public static $attribute = 123;
    public static $nested = self::class;
    public static $other = 321;

    public function testSuccess(): void
    {
        $this->assertThat(self::class, $this->classPropertiesEqualTo([
            'attribute'  => '123',
            'nested' => $this->classProperties([
                'other' => '321',
            ])
        ]));
    }

    public function testFailure(): void
    {
        $this->assertThat(self::class, $this->classPropertiesEqualTo([
            'attribute'  => '123',
            'nested' => [
                'other' => '321',
            ]
        ]));
    }
}

PHPUnit 10.5.63 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.2.30
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.016, Memory: 8.00 MB

There was 1 failure:

1) classPropertiesEqualToRecursiveTest::testFailure
Failed asserting that classPropertiesEqualToRecursiveTest is a class with properties equal to specified.
--- Expected
+++ Actual
@@ @@
-Tailors\PHPUnit\Properties\ExpectedClassProperties Object #461 (
-    'attribute' => '123',
-    'nested' => Array &0 [
-        'other' => '321',
-    ],
+Tailors\PHPUnit\Properties\ActualClassProperties Object #343 (
+    'attribute' => 123,
+    'nested' => 'classPropertiesEqualToRecursiveTest',
 )

classPropertiesEqualToRecursiveTest.php:24

FAILURES!
Tests: 2, Assertions: 2, Failures: 1.

classPropertiesIdenticalTo()

Prerequisites for classPropertiesIdenticalTo()

Package	phptailors/phpunit-properties
Trait	ClassPropertiesIdenticalToTrait

Synopsis:

function classPropertiesIdenticalTo(array $expected)

Creates ClassPropertiesIdenticalTo constraint.

The constraint accepts classes having selected properties identical to $expected.

Usage of classPropertiesIdenticalTo()

<?php declare(strict_types=1);

final class classPropertiesIdenticalToTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\ClassPropertiesIdenticalToTrait;

    public static $attribute = 123;

    public static function getValue(): int
    {
        return 321;
    }

    public function testSuccess(): void
    {
        // assert that:
        $this->assertThat(self::class, $this->classPropertiesIdenticalTo([
            'attribute'  => 123,   // - self::$attribute is 123 (ok)
            'getValue()' => 321,   // - self::getValue() is 321 (ok)
        ]));
    }

    public function testFailure(): void
    {
        // assert that:
        $this->assertThat(self::class, $this->classPropertiesIdenticalTo([
            'attribute'  => '123', // - self::$attribute is 123, not '123' (fail)
            'getValue()' => null,  // - self::getValue() is 321, not null (fail)
        ]));
    }
}

PHPUnit 11.1.2 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.3.6
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.007, Memory: 8.00 MB

There was 1 failure:

1) classPropertiesIdenticalToTest::testFailure
Failed asserting that classPropertiesIdenticalToTest is a class with properties identical to specified.
--- Expected
+++ Actual
@@ @@
-Tailors\PHPUnit\Properties\ExpectedClassProperties Object #451 (
-    'attribute' => '123',
-    'getValue()' => null,
+Tailors\PHPUnit\Properties\ActualClassProperties Object #448 (
+    'attribute' => 123,
+    'getValue()' => 321,
 )

classPropertiesIdenticalToTest.php:26

FAILURES!
Tests: 2, Assertions: 2, Failures: 1.

Since versions *.1 (1.1, 2.1, 3.1, …) it’s possible to nest recursively specifications of class properties. For more details, see arrayValues().

Usage of classPropertiesIdenticalTo() with classProperties()

<?php declare(strict_types=1);

final class classPropertiesIdenticalToRecursiveTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\ClassPropertiesIdenticalToTrait;
    use \Tailors\PHPUnit\ClassPropertiesTrait;

    public static $attribute = 123;
    public static $nested = self::class;
    public static $other = 321;

    public function testSuccess(): void
    {
        $this->assertThat(self::class, $this->classPropertiesIdenticalTo([
            'attribute'  => 123,
            'nested' => $this->classProperties([
                'other' => 321,
            ])
        ]));
    }

    public function testFailure(): void
    {
        $this->assertThat(self::class, $this->classPropertiesIdenticalTo([
            'attribute'  => 123,
            'nested' => [
                'other' => 321,
            ]
        ]));
    }
}

PHPUnit 10.5.63 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.2.30
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.016, Memory: 8.00 MB

There was 1 failure:

1) classPropertiesIdenticalToRecursiveTest::testFailure
Failed asserting that classPropertiesIdenticalToRecursiveTest is a class with properties identical to specified.
--- Expected
+++ Actual
@@ @@
-Tailors\PHPUnit\Properties\ExpectedClassProperties Object #461 (
+Tailors\PHPUnit\Properties\ActualClassProperties Object #343 (
     'attribute' => 123,
-    'nested' => Array &0 [
-        'other' => 321,
-    ],
+    'nested' => 'classPropertiesIdenticalToRecursiveTest',
 )

classPropertiesIdenticalToRecursiveTest.php:24

FAILURES!
Tests: 2, Assertions: 2, Failures: 1.

extendsClass()

Prerequisites for extendsClass()

Package	phptailors/phpunit-inheritance
Trait	ExtendsClassTrait

Synopsis:

function extendsClass(string $parent)

Creates ExtendsClass constraint.

The constraint accepts objects (and classes) that extend $parent class. The examined $subject may be an object or a class name as string:

• if the $subject is an object, then this object’s class, as returned by get_class($subject), is examined against $parent, the constraint returns true only if the class extends the $parent class,

• otherwise, the necessary conditions for the constraint to be satisfied are that

  • $subject is a string,

  • class_exists($subject) is true, and

  • the $subject class extends the $parent class.

Usage of extendsClass()

<?php declare(strict_types=1);

final class extendsClassTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\ExtendsClassTrait;

    public function testExtendsClass(): void
    {
        $this->assertThat(\RuntimeException::class, $this->extendsClass(\Exception::class));
        $this->assertThat(new \RuntimeException(), $this->extendsClass(\Exception::class));
    }

    public function testExtendsClassFailure(): void
    {
        $this->assertThat(self::class, $this->extendsClass(\Exception::class));
    }
}

PHPUnit 11.1.2 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.3.6
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.006, Memory: 8.00 MB

There was 1 failure:

1) extendsClassTest::testExtendsClassFailure
Failed asserting that extendsClassTest extends class Exception.

extendsClassTest.php:15

FAILURES!
Tests: 2, Assertions: 3, Failures: 1.

hasMethod()

Prerequisites for hasMethod()

Package	phptailors/phpunit-methods
Trait	HasMethodTrait

Synopsis:

function hasMethod(array $methodSpec)

Creates HasMethod constraint.

The constraint accepts values having a method that matches $methodSpec. The $methodSpec specifies matching method via its name and modifiers (optional).

Note

The constraint only matches a value being an object, class, trait or interface. For any other values it always returns false.

The syntax for $methodSpec string is the following

methodSpec  :=  [modifiers "function"] name
            |   name

name        :=  [_a-zA-Z][_0-9a-zA-Z]*

modifiers   :=  [abstract] [final] [access] [static]    ; order arbitrary

abstract    :=  "abstract"
            |   "!abstract"

final       :=  "final"
            |   "!final"

access      :=  "public"
            |   "!public"
            |   "protected"
            |   "!protected"

static      :=  "static"
            |   "!static"

The only allowed combination of abstract and final is "!abstract" + "!final". All other combinations are treated as syntax error.

Presence of a modifier (such as "final") requires the modifier to be present in a matched method. Presence of negated modifier (such as "!final") requires the modifier to be absent in a matched method. Absence of a modifier in $methodSpec means that it may be either present or absent in a matched method.

Usage of hasMethod()

<?php declare(strict_types=1);

abstract class ClassWithSomeMethods
{
    abstract protected function abstractProtectedMethod();
    public function publicMethod() { }
}

final class hasMethodTest extends PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\HasMethodTrait;

    public function testHasMethod(): void
    {
        // ClassWithSomeMethods::publicMethod
        $this->assertThat(ClassWithSomeMethods::class, $this->hasMethod('publicMethod'));
        $this->assertThat(ClassWithSomeMethods::class, $this->hasMethod('public function publicMethod'));
        $this->assertThat(ClassWithSomeMethods::class, $this->hasMethod('!abstract !final public function publicMethod'));

        // ClassWithSomeMethods::abstractProtectedMethod
        $this->assertThat(ClassWithSomeMethods::class, $this->hasMethod('protected function abstractProtectedMethod'));
        $this->assertThat(ClassWithSomeMethods::class, $this->hasMethod('abstract function abstractProtectedMethod'));
        $this->assertThat(ClassWithSomeMethods::class, $this->hasMethod('abstract protected function abstractProtectedMethod'));


        $this->assertThat(ClassWithSomeMethods::class, $this->logicalNot($this->hasMethod('!abstract function abstractProtectedMethod')));
    }

    public function testHasMethodFailure(): void
    {
        $this->assertThat(ClassWithSomeMethods::class, $this->hasMethod('!abstract function abstractProtectedMethod'));
    }
}

PHPUnit 11.1.2 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.3.6
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.009, Memory: 8.00 MB

There was 1 failure:

1) hasMethodTest::testHasMethodFailure
Failed asserting that 'ClassWithSomeMethods' has !abstract method abstractProtectedMethod().

hasMethodTest.php:31

FAILURES!
Tests: 2, Assertions: 8, Failures: 1.

hasPregCaptures()

Prerequisites for hasPregCaptures()

Package	phptailors/phpunit-regexp
Trait	HasPregCapturesTrait

Synopsis:

function hasPregCaptures(array $expected)

Creates HasPregCaptures constraint.

The constraint accepts arrays of matches returned from preg_match() having capture groups as specified in $expected. Only entries present in $expected are checked, so $expected = [] accepts any array. Special values may be used in the expectations:

• ['foo' => false] asserts that group 'foo' was not captured,

• ['foo' => true] asserts that group 'foo' was captured,

• ['foo' => 'FOO'] asserts that group 'foo' was captured and its value equals 'FOO'.

Boolean expectations (['foo' => true] or ['foo' => false]) work properly only with arrays obtained from preg_match() invoked with PREG_UNMATCHED_AS_NULL flag.

Usage of hasPregCaptures()

<?php declare(strict_types=1);

final class hasPregCapturesTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\HasPregCapturesTrait;

    private $regexp;
    private $subject;
    private $matches;

    public function setUp(): void
    {
        $this->regexp  = '/(?<name>\w+) (?<surname>\w+)(?:, (?<age>\d+))?(?:, (?<city>\w+))?/';
        $this->subject = 'John Smith, London';
        preg_match($this->regexp, $this->subject, $this->matches, PREG_UNMATCHED_AS_NULL);
    }

    public function testHasPregCaptures(): void
    {
        // assert that:
        $this->assertThat($this->matches, $this->hasPregCaptures([
            'name'    => 'John',  // - name is 'John' (ok),
            'surname' => 'Smith', // - surname is 'Smith' (ok),
            'age'     => false,   // - age is absent (ok),
            'city'    => true,    // - city is present (ok).
        ]));
    }

    public function testHasPregCapturesFailure(): void
    {
        // assert that:
        $this->assertThat($this->matches, $this->hasPregCaptures([
            'name'    => 'John',  // - name is 'John' (ok),
            'surname' => 'Brown', // - surname is 'Brown' (fail),
            'age'     => true,    // - age is present (fail),
            'city'    => false,   // - city is absent (fail).
        ]));
    }
}

PHPUnit 11.1.2 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.3.6
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.006, Memory: 8.00 MB

There was 1 failure:

1) hasPregCapturesTest::testHasPregCapturesFailure
Failed asserting that array has expected PCRE capture groups.
--- Expected
+++ Actual
@@ @@
 Array &0 [
     'name' => 'John',
-    'surname' => 'Brown',
-    'age' => true,
-    'city' => false,
+    'surname' => 'Smith',
+    'age' => null,
+    'city' => 'London',
 ]

hasPregCapturesTest.php:32

FAILURES!
Tests: 2, Assertions: 2, Failures: 1.

implementsInterface()

Prerequisites for implementsInterface()

Package	phptailors/phpunit-inheritance
Trait	ImplementsInterfaceTrait

Synopsis:

function implementsInterface(array $interface)

Creates ImplementsInterface constraint.

The constraint accepts objects (and classes/interfaces) that implement given $interface.

Usage of implementsInterface()

<?php declare(strict_types=1);

final class implementsInterfaceTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\ImplementsInterfaceTrait;

    public function testImplementsInterface(): void
    {
        $this->assertThat(\RuntimeException::class, $this->implementsInterface(\Throwable::class));
        $this->assertThat(new \RuntimeException(), $this->implementsInterface(\Throwable::class));
    }

    public function testImplementsInterfaceFailure(): void
    {
        $this->assertThat(self::class, $this->implementsInterface(\Throwable::class));
    }
}

PHPUnit 11.1.2 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.3.6
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.013, Memory: 8.00 MB

There was 1 failure:

1) implementsInterfaceTest::testImplementsInterfaceFailure
Failed asserting that implementsInterfaceTest implements interface Throwable.

implementsInterfaceTest.php:15

FAILURES!
Tests: 2, Assertions: 3, Failures: 1.

ksortedArrayEqualTo()

Prerequisites for ksortedArrayEqualTo()

Package	phptailors/phpunit-arrays
Trait	KsortedArrayEqualToTrait

Synopsis:

function ksortedArrayEqualTo(array $expected)

Creates KsortedArrayEqualTo constraint.

The constraint accepts arrays that are equal to $expected when key-sorted.

Usage of ksortedArrayEqualTo()

<?php declare(strict_types=1);

final class ksortedArrayEqualToTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\KsortedArrayEqualToTrait;

    public function testSuccess(): void
    {
        $this->assertThat(             ['int' => '123', 1 => null,'foo' => 'FOO'],
            $this->ksortedArrayEqualTo(['foo' => 'FOO', 'int' => 123, 1 => '' ])
        );
    }

    public function testFailure(): void
    {
        $this->assertThat(             ['int' => '123', 1 => '', 'foo' => 'FOO'],
            $this->ksortedArrayEqualTo(['int'  => 123,  1 => '', 'foo' => 'BAR'])
        );
    }
}

PHPUnit 11.1.2 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.3.6
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.006, Memory: 8.00 MB

There was 1 failure:

1) ksortedArrayEqualToTest::testFailure
Failed asserting that array is an array equal to specified one when ksorted.
--- Expected
+++ Actual
@@ @@
 Array &0 [
     1 => '',
-    'foo' => 'BAR',
-    'int' => 123,
+    'foo' => 'FOO',
+    'int' => '123',
 ]

ksortedArrayEqualToTest.php:16

FAILURES!
Tests: 2, Assertions: 2, Failures: 1.

ksortedArrayIdenticalTo()

Prerequisites for ksortedArrayIdenticalTo()

Package	phptailors/phpunit-arrays
Trait	KsortedArrayIdenticalToTrait

Synopsis:

function ksortedArrayIdenticalTo(array $expected)

Creates KsortedArrayIdenticalTo constraint.

The constraint accepts arrays identical to $expected when key-sorted.

Usage of ksortedArrayIdenticalTo()

<?php declare(strict_types=1);

final class ksortedArrayIdenticalToTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\KsortedArrayIdenticalToTrait;

    public function testSuccess(): void
    {
        $this->assertThat(                 ['int' => 123, 1 => null, 'foo' => 'FOO'],
            $this->ksortedArrayIdenticalTo(['foo' => 'FOO', 'int' => 123, 1 => null])
        );
    }

    public function testFailure(): void
    {
        $this->assertThat(                 ['int' => 123, 1 => '', 'foo' => 'FOO'],
            $this->ksortedArrayIdenticalTo(['int' => 123, 1 => null, 'foo' => 'FOO'])
        );
    }
}

PHPUnit 11.1.2 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.3.6
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.051, Memory: 8.00 MB

There was 1 failure:

1) ksortedArrayIdenticalToTest::testFailure
Failed asserting that array is an array identical to specified one when ksorted.
--- Expected
+++ Actual
@@ @@
 Array &0 [
-    1 => null,
+    1 => '',
     'foo' => 'FOO',
     'int' => 123,
 ]

ksortedArrayIdenticalToTest.php:16

FAILURES!
Tests: 2, Assertions: 2, Failures: 1.

objectPropertiesEqualTo()

Prerequisites for objectPropertiesEqualTo()

Package	phptailors/phpunit-properties
Trait	ObjectPropertiesEqualToTrait

Synopsis:

function objectPropertiesEqualTo(array $expected)

Creates ObjectPropertiesEqualTo constraint.

The constraint accepts objects having selected properties equal to $expected.

Usage of objectPropertiesEqualTo()

<?php declare(strict_types=1);

final class objectPropertiesEqualToTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\ObjectPropertiesEqualToTrait;

    public $attribute = 123;

    public function getValue(): int
    {
        return 321;
    }

    public function testSuccess(): void
    {
        // assert that:
        $this->assertThat($this, $this->objectPropertiesEqualTo([
            'attribute'  => '123', // - $this->attribute is 123, equals '123' (ok)
            'getValue()' => 321,   // - $this->getValue() is 321 (ok)
        ]));
    }

    public function testFailure(): void
    {
        // assert that:
        $this->assertThat($this, $this->objectPropertiesEqualTo([
            'attribute'  => '123', // - $this->attribute is 123, equals '123' (ok)
            'getValue()' => null,  // - $this->getValue() is 321, not equals null (fail)
        ]));
    }
}

PHPUnit 11.1.2 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.3.6
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.009, Memory: 8.00 MB

There was 1 failure:

1) objectPropertiesEqualToTest::testFailure
Failed asserting that object objectPropertiesEqualToTest is an object with properties equal to specified.
--- Expected
+++ Actual
@@ @@
-Tailors\PHPUnit\Properties\ExpectedObjectProperties Object #451 (
-    'attribute' => '123',
-    'getValue()' => null,
+Tailors\PHPUnit\Properties\ActualObjectProperties Object #448 (
+    'attribute' => 123,
+    'getValue()' => 321,
 )

objectPropertiesEqualToTest.php:26

FAILURES!
Tests: 2, Assertions: 2, Failures: 1.

Since versions *.1 (1.1, 2.1, 3.1, …) it’s possible to nest recursively specifications of object properties. For more details, see arrayValues().

Usage of objectPropertiesEqualTo() with objectProperties()

<?php declare(strict_types=1);

final class objectPropertiesEqualToRecursiveTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\ObjectPropertiesEqualToTrait;
    use \Tailors\PHPUnit\ObjectPropertiesTrait;

    public $attribute = 123;
    public $other = 321;

    public function nested(): \Exception
    {
        return new \Exception('FOO', 456);
    }

    public function testSuccess(): void
    {
        $this->assertThat($this, $this->objectPropertiesEqualTo([
            'attribute'  => '123',
            'nested()' => $this->objectProperties([
                'getMessage()' => 'FOO',
                'getCode()' => '456',
            ])
        ]));
    }

    public function testFailure(): void
    {
        $this->assertThat($this, $this->objectPropertiesEqualTo([
            'attribute'  => '123',
            'nested()' => [
                'getMessage()' => 'FOO',
                'getCode()' => '456',
            ]
        ]));
    }
}

PHPUnit 10.5.63 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.2.30
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.010, Memory: 8.00 MB

There was 1 failure:

1) objectPropertiesEqualToRecursiveTest::testFailure
Failed asserting that object objectPropertiesEqualToRecursiveTest is an object with properties equal to specified.
--- Expected
+++ Actual
@@ @@
-Tailors\PHPUnit\Properties\ExpectedObjectProperties Object #466 (
-    'attribute' => '123',
-    'nested()' => Array &0 [
-        'getMessage()' => 'FOO',
-        'getCode()' => '456',
-    ],
+Tailors\PHPUnit\Properties\ActualObjectProperties Object #484 (
+    'attribute' => 123,
+    'nested()' => Exception Object #464 (
+        'message' => 'FOO',
+        'string' => '',
+        'code' => 456,
+        'file' => 'objectPropertiesEqualToRecursiveTest.php',
+        'line' => 13,
+        'previous' => null,
+    ),
 )

objectPropertiesEqualToRecursiveTest.php:29

FAILURES!
Tests: 2, Assertions: 2, Failures: 1.

objectPropertiesIdenticalTo()

Prerequisites for objectPropertiesIdenticalTo()

Package	phptailors/phpunit-properties
Trait	ObjectPropertiesIdenticalToTrait

Synopsis:

function objectPropertiesIdenticalTo(array $expected)

Creates ObjectPropertiesIdenticalTo constraint.

The constraint accepts objects having selected properties identical to $expected.

Usage of objectPropertiesIdenticalTo()

<?php declare(strict_types=1);

final class objectPropertiesIdenticalToTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\ObjectPropertiesIdenticalToTrait;

    public $attribute = 123;

    public function getValue(): int
    {
        return 321;
    }

    public function testSuccess(): void
    {
        // assert that:
        $this->assertThat($this, $this->objectPropertiesIdenticalTo([
            'attribute'  => 123,   // - $this->attribute is 123 (ok)
            'getValue()' => 321,   // - $this->getValue() is 321 (ok)
        ]));
    }

    public function testFailure(): void
    {
        // assert that:
        $this->assertThat($this, $this->objectPropertiesIdenticalTo([
            'attribute'  => '123', // - $this->attribute is 123, not '123' (fail)
            'getValue()' => null,  // - $this->getValue() is 321, not null (fail)
        ]));
    }
}

PHPUnit 11.1.2 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.3.6
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.007, Memory: 8.00 MB

There was 1 failure:

1) objectPropertiesIdenticalToTest::testFailure
Failed asserting that object objectPropertiesIdenticalToTest is an object with properties identical to specified.
--- Expected
+++ Actual
@@ @@
-Tailors\PHPUnit\Properties\ExpectedObjectProperties Object #451 (
-    'attribute' => '123',
-    'getValue()' => null,
+Tailors\PHPUnit\Properties\ActualObjectProperties Object #448 (
+    'attribute' => 123,
+    'getValue()' => 321,
 )

objectPropertiesIdenticalToTest.php:26

FAILURES!
Tests: 2, Assertions: 2, Failures: 1.

Since versions *.1 (1.1, 2.1, 3.1, …) it’s possible to nest recursively specifications of object properties. For more details, see arrayValues().

Usage of objectPropertiesIdenticalTo() with objectProperties()

<?php declare(strict_types=1);

final class objectPropertiesIdenticalToRecursiveTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\ObjectPropertiesIdenticalToTrait;
    use \Tailors\PHPUnit\ObjectPropertiesTrait;

    public $attribute = 123;
    public $other = 321;

    public function nested(): \Exception
    {
        return new \Exception('FOO', 456);
    }

    public function testSuccess(): void
    {
        $this->assertThat($this, $this->objectPropertiesIdenticalTo([
            'attribute'  => 123,
            'nested()' => $this->objectProperties([
                'getMessage()' => 'FOO',
                'getCode()' => 456,
            ])
        ]));
    }

    public function testFailure(): void
    {
        $this->assertThat($this, $this->objectPropertiesIdenticalTo([
            'attribute'  => 123,
            'nested()' => [
                'getMessage()' => 'FOO',
                'getCode()' => 456,
            ]
        ]));
    }
}

PHPUnit 10.5.63 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.2.30
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.014, Memory: 8.00 MB

There was 1 failure:

1) objectPropertiesIdenticalToRecursiveTest::testFailure
Failed asserting that object objectPropertiesIdenticalToRecursiveTest is an object with properties identical to specified.
--- Expected
+++ Actual
@@ @@
-Tailors\PHPUnit\Properties\ExpectedObjectProperties Object #467 (
+Tailors\PHPUnit\Properties\ActualObjectProperties Object #485 (
     'attribute' => 123,
-    'nested()' => Array &0 [
-        'getMessage()' => 'FOO',
-        'getCode()' => 456,
-    ],
+    'nested()' => Exception Object #465 (
+        'message' => 'FOO',
+        'string' => '',
+        'code' => 456,
+        'file' => 'objectPropertiesIdenticalToRecursiveTest.php',
+        'line' => 13,
+        'previous' => null,
+    ),
 )

objectPropertiesIdenticalToRecursiveTest.php:29

FAILURES!
Tests: 2, Assertions: 2, Failures: 1.

usesTrait()

Prerequisites for usesTrait()

Package	phptailors/phpunit-inheritance
Trait	UsesTraitTrait

Synopsis:

function usesTrait(array $trait)

Creates UsesTrait constraint.

The constraint accepts objects (and classes) that use given $trait.

Usage of usesTrait()

<?php declare(strict_types=1);

trait ExampleTraitForUsesTraitTest
{
}

final class UsesTraitTest extends \PHPUnit\Framework\TestCase
{
    use \Tailors\PHPUnit\UsesTraitTrait;
    use ExampleTraitForUsesTraitTest;

    public function testUsesTrait(): void
    {
        $this->assertThat(self::class, $this->usesTrait(ExampleTraitForUsesTraitTest::class));
        $this->assertThat($this, $this->usesTrait(ExampleTraitForUsesTraitTest::class));
    }

    public function testUsesTraitFailure(): void
    {
        $this->assertThat(\RuntimeException::class, $this->usesTrait(ExampleTraitForUsesTraitTest::class));
    }
}

PHPUnit 11.1.2 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.3.6
Configuration: phpunit.xml

.F                                                                  2 / 2 (100%)

Time: 00:00.011, Memory: 8.00 MB

There was 1 failure:

1) UsesTraitTest::testUsesTraitFailure
Failed asserting that RuntimeException uses trait ExampleTraitForUsesTraitTest.

usesTraitTest.php:20

FAILURES!
Tests: 2, Assertions: 3, Failures: 1.