PHPUnit

https://docs.phpunit.de/en/13.0/
Admin
PHPUnit is a testing framework for PHP that enables developers to write unit tests and perform...
Tokens:95,731
Snippets:1,341
Trust Score:9.9
Update:1 month ago
Show doc for...
Tokens:
Raw
### PHPUnit Test Class with setUp() and tearDown()

Source: https://docs.phpunit.de/en/13.0/fixtures.html

This example demonstrates a basic PHPUnit test class that utilizes the setUp() method to initialize a test fixture and tearDown() to clean it up after each test method.

```php
<?php declare(strict_types=1);
namespace example;

use PHPUnit\Framework\TestCase;

final class ExampleTest extends TestCase
{
    private ?Example $example;

    public function testSomething(): void
    {
        $this->assertSame(
            'the-result',
            $this->example->doSomething()
        );
    }

    protected function setUp(): void
    {
        $this->example = new Example(
            $this->createStub(Collaborator::class)
        );
    }

    protected function tearDown(): void
    {
        $this->example = null;
    }
}

```

--------------------------------

### Subclass Setup with Attributes

Source: https://docs.phpunit.de/en/13.0/fixtures.html

Shows how a subclass can define its own #[Before] setup method without needing to explicitly call the parent class's setup method. Both parent and subclass setup methods are executed.

```php
<?php declare(strict_types=1);
use PHPUnit\Framework\Attributes\Before;

final class MyTest extends MyTestCase
{
    #[Before]
    protected function setUpFixture(): void
    {
        // Set up the fixture for this test class ...
    }

    public function testSomething(): void
    {
        // Both setUpLogger() and setUpFixture() have been called at this point
        // ...
    }
}

```

--------------------------------

### Project Directory Structure After Installation

Source: https://docs.phpunit.de/en/13.0/installation.html

Illustrates the typical directory structure of a project after PHPUnit has been installed via Composer.

```text
├── composer.json
├── composer.lock
├── public
├── src
├── tests
└── vendor
```

--------------------------------

### Invoke Local PHPUnit Installation

Source: https://docs.phpunit.de/en/13.0/installation.html

Execute the project-local installation of PHPUnit using its symbolic link.

```bash
./tools/phpunit --version

```

--------------------------------

### Execute Project-Local PHPUnit Installation

Source: https://docs.phpunit.de/en/13.0/installation.html

Invokes the locally installed PHPUnit binary from the project's vendor directory to check its version.

```bash
./vendor/bin/phpunit --version
```

--------------------------------

### Install PHP CLI and Extensions on Fedora

Source: https://docs.phpunit.de/en/13.0/installation.html

Installs the PHP command-line interpreter and essential extensions for PHPUnit on Fedora systems.

```bash
sudo dnf install php-cli \
                 php-json \
                 php-mbstring \
                 php-process \
                 php-xml \
                 php-pecl-pcov \
                 php-pecl-xdebug

```

--------------------------------

### Install Phive

Source: https://docs.phpunit.de/en/13.0/installation.html

Download Phive, verify its signature, make it executable, and move it to your system's PATH.

```bash
wget https://phar.io/releases/phive.phar
wget https://phar.io/releases/phive.phar.asc
gpg --keyserver hkps.pool.sks-keyservers.net --recv-keys 0x9B2D5D79
gpg --verify phive.phar.asc phive.phar
chmod +x phive.phar
mv phive.phar /usr/local/bin/phive

```

--------------------------------

### Global PHPUnit Installation using PHAR

Source: https://docs.phpunit.de/en/13.0/installation.html

This snippet demonstrates how to download a PHPUnit PHAR release, make it executable, and move it to a directory in your system's PATH for global access. It also shows how to verify the installation.

```bash
wget -O phpunit.phar https://phar.phpunit.de/phpunit-10.phar
chmod +x phpunit.phar
sudo mv phpunit.phar /usr/local/bin/phpunit
phpunit --version
```

--------------------------------

### Install PHPUnit Locally with Composer

Source: https://docs.phpunit.de/en/13.0/installation.html

Installs PHPUnit as a development dependency for your project using Composer. Ensure Composer is installed and on your PATH.

```bash
composer require --dev phpunit/phpunit
```

--------------------------------

### Install PHP CLI and Extensions on Debian/Ubuntu

Source: https://docs.phpunit.de/en/13.0/installation.html

Installs the PHP command-line interpreter and essential extensions for PHPUnit on Debian and Ubuntu systems.

```bash
sudo apt install php-cli \
                 php-json \
                 php-mbstring \
                 php-xml \
                 php-pcov \
                 php-xdebug

```

--------------------------------

### Install PHPUnit with Phive

Source: https://docs.phpunit.de/en/13.0/installation.html

Install PHPUnit for your project using Phive. This command downloads the PHPUnit PHAR and sets up a symbolic link.

```bash
phive install phpunit

```

--------------------------------

### Example Extension Implementation

Source: https://docs.phpunit.de/en/13.0/extending-phpunit.html

This extension implements the `Extension` interface and registers an `ExampleSubscriber` and an `ExampleTracer`. It demonstrates how to access configuration and parameters to customize behavior.

```php
<?php declare(strict_types=1);
namespace Vendor\ExampleExtensionForPhpunit;

use PHPUnit\Runner\Extension\Extension;
use PHPUnit\Runner\Extension\Facade;
use PHPUnit\Runner\Extension\ParameterCollection;
use PHPUnit\TextUI\Configuration\Configuration;

final class ExampleExtension implements Extension
{
    public function bootstrap(
        Configuration $configuration,
        Facade $facade,
        ParameterCollection $parameters
    ): void {
        if ($configuration->noOutput()) {
            return;
        }

        $message = 'the-default-message';

        if ($parameters->has('message')) {
            $message = $parameters->get('message');
        }

        $facade->registerSubscriber(new ExampleSubscriber($message));
        $facade->registerTracer(new ExampleTracer);
    }
}

```

--------------------------------

### Test Stub Example: Configuring Return Values

Source: https://docs.phpunit.de/en/13.0/test-doubles.html

This example demonstrates how to create and configure a test stub for a Database dependency to simulate query results. It's used when you need to control what a dependency returns to test specific code paths in the System Under Test.

```php
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;

final class ServiceTest extends TestCase
{
    public function testDoSomethingReturnsTrueWhenQueryReturnsRows(): void
    {
        $database = $this->createStub(Database::class);

        $database
            ->method('query')
            ->willReturn([['foo' => 'bar']]);

        $service = new Service($database);

        $this->assertTrue($service->doSomething());
    }
}

```

--------------------------------

### Install PHPUnit with Copy Option

Source: https://docs.phpunit.de/en/13.0/installation.html

Install PHPUnit using Phive and the --copy option to keep the PHAR file within the project's tools directory.

```bash
phive install --copy phpunit

```

--------------------------------

### Concrete Test Class Extending Abstract with setUp()

Source: https://docs.phpunit.de/en/13.0/fixtures.html

A concrete PHPUnit test class that extends an abstract test case class which has its own setUp() method. It's crucial to call parent::setUp() if overriding setUp() to ensure inherited setup logic is executed.

```php
<?php declare(strict_types=1);
namespace example;

use PHPUnit\Framework\TestCase;

final class ExampleTest extends MyTestCase
{
    protected function setUp(): void
    {
        // ...
    }
}

```

--------------------------------

### Install PCOV Extension on macOS

Source: https://docs.phpunit.de/en/13.0/installation.html

Installs and enables the PCOV extension for code coverage on macOS.

```bash
brew install pcov@8.4

```

--------------------------------

### Abstract Test Case Class with setUp()

Source: https://docs.phpunit.de/en/13.0/fixtures.html

An abstract test case class in PHPUnit that defines a setUp() method. This method can be extended by concrete test classes.

```php
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;

abstract class MyTestCase extends TestCase
{
    protected function setUp(): void
    {
        // ...
    }
}

```

--------------------------------

### Install Xdebug Extension on macOS

Source: https://docs.phpunit.de/en/13.0/installation.html

Installs and enables the Xdebug extension for debugging on macOS.

```bash
brew install xdebug@8.4

```

--------------------------------

### Composer Outdated Command Output Example

Source: https://docs.phpunit.de/en/13.0/installation.html

Example output from the 'composer outdated' command, indicating that a patch or minor release is available for PHPUnit.

```text
Legend:
! patch or minor release available - update recommended
~ major release available - update possible

Direct dependencies required in composer.json:
phpunit/phpunit 9.6.0 ! 9.6.3 The PHP Unit Testing framework.
```

--------------------------------

### Project File Structure

Source: https://docs.phpunit.de/en/13.0/error-handling.html

The file structure for the PHPUnit error handling examples.

```text
.\n├── phpunit.xml\n├── src\n│   └── FirstPartyClass.php\n├── tests\n│   └── FirstPartyClassTest.php\n└── vendor\n    ├── autoload.php\n    └── ThirdPartyClass.php\n\n4 directories, 5 files\n
```

--------------------------------

### Creating a Configured Test Stub

Source: https://docs.phpunit.de/en/13.0/test-doubles.html

Create a test stub with methods pre-configured to return specific values. This is a convenience method for simple stub setups.

```PHP
$stub = $this->createConfiguredStub(
    InterfaceName::class,
    [
        'methodOne' => 'return value one',
        'methodTwo' => 'return value two',
    ]
);

// $stub->methodOne() will return "return value one"
// $stub->methodTwo() will return "return value two"

```

--------------------------------

### PHPUnit assertStringMatchesFormatFile Example

Source: https://docs.phpunit.de/en/13.0/assertions.html

Use assertStringMatchesFormatFile to compare a string against the content of a format file. This example illustrates a failing test scenario.

```php
<?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',
        );
    }
}

```

--------------------------------

### TestDox Plain Text Output Example

Source: https://docs.phpunit.de/en/13.0/testdox.html

Example of plain text output from TestDox. Successful tests are marked with [x] and failed tests with [ ].

```text
Greeter
 [x] Greets with name
 [x] Greets with good morning before noon
 [x] Greets with good afternoon after noon
 [x] Greets with good evening after 6 pm


```

--------------------------------

### Tap PHP Formulae on macOS

Source: https://docs.phpunit.de/en/13.0/installation.html

Adds the necessary Homebrew repositories for installing PHP and its extensions on macOS.

```bash
brew tap shivammathur/php
brew tap shivammathur/extensions

```

--------------------------------

### PHAR Manifest Example

Source: https://docs.phpunit.de/en/13.0/extending-phpunit.html

An example PHAR manifest.xml file required for making a PHPUnit extension loadable as a PHAR. It specifies package details, compatibility, and licensing.

```xml
<?xml version="1.0" encoding="utf-8" ?>
<phar xmlns="https://phar.io/xml/manifest/1.0">
  <contains name="phpunit/phpunit-test-extension" version="1.0.0" type="extension">
    <extension for="phpunit/phpunit" compatible="^10.0"/>
  </contains>

  <requires>
    <php version="^8.1"/>
  </requires>

  <copyright>
    <author name="Sebastian Bergmann" email="sebastian@phpunit.de"/>
    <license type="BSD-3-Clause" url="https://github.com/sebastianbergmann/phpunit/blob/master/LICENSE"/>
  </copyright>
</phar>

```

--------------------------------

### PHPUnit PHAR Configuration

Source: https://docs.phpunit.de/en/13.0/installation.html

Example of a phive configuration file specifying the PHPUnit version constraint.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<phive xmlns="https://phar.io/phive">
  <phar name="phpunit"
        version="^9.6" installed="9.6.3"
        location="./tools/phpunit" copy="true"/>
</phive>

```

--------------------------------

### Check PHPUnit Version

Source: https://docs.phpunit.de/en/13.0/installation.html

Verify the installed PHPUnit version by running the downloaded PHAR file with the --version flag.

```bash
php phpunit.phar --version
```

--------------------------------

### Verify PHP Version

Source: https://docs.phpunit.de/en/13.0/installation.html

Checks if the PHP command-line interpreter is installed, on the system's PATH, and displays its version.

```bash
php --version

```

--------------------------------

### Example Event Subscriber Implementation

Source: https://docs.phpunit.de/en/13.0/extending-phpunit.html

This subscriber implements the `ExecutionFinishedSubscriber` interface. It prints a custom message when PHPUnit finishes execution, demonstrating how to react to specific events.

```php
<?php declare(strict_types=1);
namespace Vendor\ExampleExtensionForPhpunit;

use PHPUnit\Event\TestRunner\ExecutionFinished;
use PHPUnit\Event\TestRunner\ExecutionFinishedSubscriber;

final class ExampleSubscriber implements ExecutionFinishedSubscriber
{
    public function __construct(private readonly string $message)
    {
    }

    public function notify(ExecutionFinished $event): void
    {
        print __METHOD__ . PHP_EOL . $this->message . PHP_EOL;
    }
}

```

--------------------------------

### PHPUnit Test Execution Output

Source: https://docs.phpunit.de/en/13.0/textui.html

Example output from running a PHPUnit test that fails due to weak comparison differences.

```text
./tools/phpunit tests/ArrayWeakComparisonTest.php
PHPUnit 13.0.0 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.5.4

F                                                                   1 / 1 (100%)

Time: 00:00.001, Memory: 25.94 MB

There was 1 failure:

1) ArrayWeakComparisonTest::testEquality
Failed asserting that two arrays are equal.
--- Expected
+++ Actual
@@ @@
 Array (
-    0 => 1
+    0 => '1'
     1 => 2
-    2 => 3
+    2 => 33
     3 => 4
     4 => 5
     5 => 6
 )

/path/to/tests/ArrayWeakComparisonTest.php:8

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

```

--------------------------------

### Set GET Variable with <get>

Source: https://docs.phpunit.de/en/13.0/configuration.html

Use the <get> element to set a value in the $_GET super-global array.

```xml
<php>
  <get name="foo" value="bar"/>
</php>
```

```php
$_GET['foo'] = 'bar';
```

--------------------------------

### Using assertPreConditions() and assertPostConditions()

Source: https://docs.phpunit.de/en/13.0/fixtures.html

Demonstrates how to use assertPreConditions() and assertPostConditions() to verify fixture state before and after test execution. These methods are called after setUp() and before tearDown(), respectively, and failures are reported as test failures.

```php
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;

final class SomeTest extends TestCase
{
    private ?SomeObject $object;

    protected function setUp(): void
    {
        $this->object = new SomeObject;
    }

    protected function assertPreConditions(): void
    {
        $this->assertTrue($this->object->isReady());
    }

    protected function assertPostConditions(): void
    {
        $this->assertFalse($this->object->hasErrors());
    }

    protected function tearDown(): void
    {
        $this->object = null;
    }

    public function testSomething(): void
    {
        $this->object->doSomething();

        $this->assertSame('expected', $this->object->result());
    }
}

```

--------------------------------

### Using #[Before] and #[After] Attributes

Source: https://docs.phpunit.de/en/13.0/fixtures.html

Illustrates using PHP attributes like #[Before] and #[After] as alternatives to template methods for setting up and tearing down fixtures. This allows for multiple setup/teardown methods per phase, especially useful in class hierarchies.

```php
<?php declare(strict_types=1);
use PHPUnit\Framework\Attributes\After;
use PHPUnit\Framework\Attributes\Before;
use PHPUnit\Framework\TestCase;

abstract class MyTestCase extends TestCase
{
    #[Before]
    protected function setUpLogger(): void
    {
        // Set up logging for all tests ...
    }

    #[After]
    protected function tearDownLogger(): void
    {
        // Tear down logging after all tests ...
    }
}

```

--------------------------------

### Run All Tests with Configuration

Source: https://docs.phpunit.de/en/13.0/textui.html

Execute all configured test suites by simply running the 'phpunit' command when a 'phpunit.xml' configuration file is present in the current directory.

```bash
$ ./tools/phpunit
PHPUnit 13.0.0 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.5.3
Configuration: /path/to/project/phpunit.xml

..                                                                  2 / 2 (100%)

Time: 00:00.077, Memory: 10.00 MB

OK (2 tests, 2 assertions)
```

--------------------------------

### Install PHP 8.4 on macOS

Source: https://docs.phpunit.de/en/13.0/installation.html

Installs PHP version 8.4 using Homebrew on macOS.

```bash
brew install shivammathur/php/php@8.4

```

--------------------------------

### Instantiating System Under Test with Stub

Source: https://docs.phpunit.de/en/13.0/test-doubles.html

This snippet shows how to instantiate the System Under Test (SUT) by injecting a created test stub. This ensures the SUT uses the controlled dependency for testing.

```php
$service = new Service($database);

```

--------------------------------

### Install PHPUnit PHAR in Project Tools Directory

Source: https://docs.phpunit.de/en/13.0/installation.html

Download and make the PHPUnit PHAR executable, then move it to a project's 'tools' directory for per-project usage. This is a common practice for managing different PHPUnit versions.

```bash
wget -O phpunit.phar https://phar.phpunit.de/phpunit-10.phar
chmod +x phpunit.phar
mv phpunit.phar tools
```

--------------------------------

### Running PHPUnit with --testdox

Source: https://docs.phpunit.de/en/13.0/testdox.html

This command demonstrates how to run PHPUnit tests with the --testdox option to generate human-readable documentation from test method names.

```bash
$ ./tools/phpunit --no-progress --testdox tests/GreeterTest.php
PHPUnit 13.0.0 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.5.3

Time: 00:00.077, Memory: 10.00 MB

Greeter
 ✔ Greets with name
 ✔ Greets with good morning before noon
 ✔ Greets with good afternoon after noon
 ✔ Greets with good evening after 6 pm

OK (4 tests, 4 assertions)

```

--------------------------------

### PHPUnit assertStringMatchesFormat Example

Source: https://docs.phpunit.de/en/13.0/assertions.html

Use assertStringMatchesFormat to verify if a string conforms to a specified format string. This example shows a failing test.

```php
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;

final class StringMatchesFormatTest extends TestCase
{
    public function testFailure(): void
    {
        $this->assertStringMatchesFormat('%i', 'foo');
    }
}

```

--------------------------------

### PHPUnit assertInstanceOf() Example

Source: https://docs.phpunit.de/en/13.0/assertions.html

Use assertInstanceOf() to check if a variable is an instance of a specific class. This example shows a test designed to fail.

```php
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;

final class InstanceOfTest extends TestCase
{
    public function testFailure(): void
    {
        $this->assertInstanceOf(RuntimeException::class, new Exception);
    }
}

```

--------------------------------

### PHPUnit assertLessThanOrEqual() Example

Source: https://docs.phpunit.de/en/13.0/assertions.html

Use assertLessThanOrEqual() to ensure a value is less than or equal to an expected value. This example illustrates a failing assertion.

```php
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;

final class LessThanOrEqualTest extends TestCase
{
    public function testFailure(): void
    {
        $this->assertLessThanOrEqual(1, 2);
    }
}

```

--------------------------------

### Instantiate System Under Test with Mock Dependency

Source: https://docs.phpunit.de/en/13.0/test-doubles.html

Creates an instance of ServiceImplementation, injecting the configured mock ErrorHandler. This allows testing the service in isolation.

```php
$service = new ServiceImplementation($errorHandler);

```

--------------------------------

### PHPUnit assertMatchesRegularExpression Example

Source: https://docs.phpunit.de/en/13.0/assertions.html

Use assertMatchesRegularExpression to check if a string matches a given PCRE pattern. This example demonstrates a failing test case.

```php
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;

final class MatchesRegularExpressionTest extends TestCase
{
    public function testFailure(): void
    {
        $this->assertMatchesRegularExpression('/foo/', 'bar');
    }
}

```

--------------------------------

### PHPUnit assertGreaterThanOrEqual() Example

Source: https://docs.phpunit.de/en/13.0/assertions.html

Use assertGreaterThanOrEqual() to check if a value is greater than or equal to an expected value. This example demonstrates a failing test case.

```php
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;

final class GreaterThanOrEqualTest extends TestCase
{
    public function testFailure(): void
    {
        $this->assertGreaterThanOrEqual(2, 1);
    }
}

```

--------------------------------

### Implement PHPUnit Extension Entry Point

Source: https://docs.phpunit.de/en/13.0/extending-phpunit.html

This class implements the `PHPUnit\Runner\Extension\Extension` interface, defining the `bootstrap()` method to register custom output and event subscribers with PHPUnit's facade.

```php
<?php declare(strict_types=1);
namespace PHPUnit\ExtensionExample\Printer;

use PHPUnit\Runner\Extension\Extension as ExtensionInterface;
use PHPUnit\Runner\Extension\Facade;
use PHPUnit\Runner\Extension\ParameterCollection;
use PHPUnit\TextUI\Configuration\Configuration;

final class Extension implements ExtensionInterface
{
    public function bootstrap(Configuration $configuration, Facade $facade, ParameterCollection $parameters): void
    {
        $facade->replaceOutput();

        $printer = new Printer;

        $facade->registerSubscribers(
            new Subscriber\TestPreparationStartedSubscriber($printer),
            new Subscriber\TestPassedSubscriber($printer),
            new Subscriber\TestFailedSubscriber($printer),
            new Subscriber\TestErroredSubscriber($printer),
            new Subscriber\TestSkippedSubscriber($printer),
            new Subscriber\TestMarkedIncompleteSubscriber($printer),
            new Subscriber\TestFinishedSubscriber($printer),
        );
    }
}

```

--------------------------------

### Using createStub() as an Alternative to any()

Source: https://docs.phpunit.de/en/13.0/test-doubles.html

When you only need to control return values without verifying call counts, `createStub()` is the preferred method over `createMock()` with `any()`. This avoids the contradiction of mocking communication while ignoring it.

```php
$stub = $this->createStub(InterfaceName::class);

$stub
    ->method('doSomething')
    ->willReturn('value');

```

--------------------------------

### Create Configured Mock Object

Source: https://docs.phpunit.de/en/13.0/test-doubles.html

Creates a mock object with predefined return values for specific methods. This is a convenient way to set up mocks for simple scenarios.

```PHP
$mock = $this->createConfiguredMock(
    InterfaceName::class,
    [
        'methodOne' => 'return value one',
        'methodTwo' => 'return value two',
    ]
);

// $mock->methodOne() will return "return value one"
// $mock->methodTwo() will return "return value two"

```

--------------------------------

### Share Database Connection with setUpBeforeClass and tearDownAfterClass

Source: https://docs.phpunit.de/en/13.0/fixtures.html

Connect to an in-memory SQLite database before the first test and disconnect after the last test in a test case class. This method is useful for performance optimization when a resource is expensive to set up.

```php
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;

final class DatabaseTest extends TestCase
{
    private static $dbh;

    public static function setUpBeforeClass(): void
    {
        self::$dbh = new PDO('sqlite::memory:');
    }

    public static function tearDownAfterClass(): void
    {
        self::$dbh = null;
    }
}

```

--------------------------------

### Using assertFileEquals() for File Content Comparison

Source: https://docs.phpunit.de/en/13.0/assertions.html

Demonstrates how to use `assertFileEquals()` to check if two files have identical content. The assertion fails if the contents differ, as shown in the example output.

```PHP
<?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',
        );
    }
}

```

--------------------------------

### PHPUnit Version Output

Source: https://docs.phpunit.de/en/13.0/installation.html

The output displayed after invoking the local PHPUnit installation.

```text
PHPUnit 10.0.0 by Sebastian Bergmann and contributors.

```

--------------------------------

### ExampleTracer Implementation

Source: https://docs.phpunit.de/en/13.0/extending-phpunit.html

Implement the PHPUnit\Event\Tracer\Tracer interface to create a custom event tracer. This tracer will receive all events emitted by PHPUnit.

```php
<?php declare(strict_types=1);
namespace Vendor\ExampleExtensionForPhpunit;

use PHPUnit\Event\Event;
use PHPUnit\Event\Tracer\Tracer;

final class ExampleTracer implements Tracer
{
    public function trace(Event $event): void
    {
        // ...
    }
}

```

--------------------------------

### assertStringStartsWith

Source: https://docs.phpunit.de/en/13.0/assertions.html

Reports an error if the string does not start with the specified prefix. The inverse assertion is `assertStringStartsNotWith()`.

```APIDOC
## assertStringStartsWith()

### Description
Reports an error if the `$string` does not start with `$prefix`.

### Method
`assertStringStartsWith(string $prefix, string $string[, string $message])`

### Parameters
- **prefix** (string) - Required - The prefix to check for.
- **string** (string) - Required - The string to check.
- **message** (string) - Optional - The message to report on failure.

### Related Assertions
- `assertStringStartsNotWith()`
```

--------------------------------

### Configure Extension Parameters

Source: https://docs.phpunit.de/en/13.0/configuration.html

Passes parameters to a registered test runner extension during bootstrapping.

```xml
<extensions>
    <bootstrap class="Vendor\ExampleExtensionForPhpunit\Extension">
        <parameter name="message" value="the-message"/>
    </bootstrap>
</extensions>
```

--------------------------------

### Generate Baseline XML

Source: https://docs.phpunit.de/en/13.0/error-handling.html

Use the --generate-baseline CLI option to create an XML file listing all triggered issues.

```bash
$ phpunit --generate-baseline baseline.xml
PHPUnit 11.1.0 by Sebastian Bergmann and contributors.

Runtime:       PHP 8.2.10
Configuration: /path/to/example/phpunit.xml

D                                                                   1 / 1 (100%)

Time: 00:00.008, Memory: 4.00 MB

OK, but there were issues!
Tests: 1, Assertions: 1, Deprecations: 1.

Baseline written to /path/to/example/baseline.xml.


```

--------------------------------

### Interface with a get-hooked property

Source: https://docs.phpunit.de/en/13.0/test-doubles.html

Example of an interface declaring a get-hooked property, introduced in PHP 8.4.

```PHP
<?php declare(strict_types=1);
interface InterfaceWithGetHookedProperty
{
    public string $property { get; }
}
```

--------------------------------

### Directory Structure for Tests

Source: https://docs.phpunit.de/en/13.0/organizing-tests.html

This example shows a typical project structure where unit tests in 'tests/unit' mirror the source code in 'src'. Integration tests are kept in 'tests/integration'.

```text
src                                          tests/unit
├── autoload.php                             ├── CameraTest.php
├── Camera.php                               ├── canvas
├── canvas                                   │	   ├── AnsiMapperTest.php
│   ├── AnsiMapper.php                       │   ├── CanvasTest.php
│   ├── CanvasIterator.php                   │   └── PortablePixmapMapperTest.php
│   ├── Canvas.php                           ├── ColorTest.php
│   ├── PortablePixmapMapper.php             ├── intersection
│   └── WebpMapper.php                       │   ├── IntersectionCollectionTest.php
├── Color.php                                │   └── IntersectionTest.php
├── exceptions                               ├── material
│   ├── Exception.php                        │   ├── CheckersPatternTest.php
│   ├── IntersectionHasNoHitException.php    │   ├── GradientPatternTest.php
│   ├── InvalidArgumentException.php         │   ├── MaterialTest.php
│   ├── OutOfBoundsException.php             │   ├── PatternTest.php
│   ├── RuntimeException.php                 │   ├── RingPatternTest.php
│   └── WorldHasNoLightException.php         │   └── StripePatternTest.php
├── intersection                             ├── math
│   ├── IntersectionCollectionIterator.php   │   ├── MatrixTest.php
│   ├── IntersectionCollection.php           │   ├── RayTest.php
│   ├── Intersection.php                     │   ├── TransformationsTest.php
│   └── PreparedComputation.php              │   └── TupleTest.php
├── material                                 ├── PointLightTest.php
│   ├── CheckersPattern.php                  ├── shapes
│   ├── GradientPattern.php                  │   ├── PlaneTest.php
│   ├── Material.php                         │   ├── ShapeCollectionTest.php
│   ├── Pattern.php                          │   ├── ShapeTest.php
│   ├── RingPattern.php                      │   └── SphereTest.php
│   └── StripePattern.php                    └── WorldTest.php
├── math
│   ├── Matrix.php                           tests/integration
│   ├── Ray.php                              └── PuttingItTogetherTest.php
│   ├── Transformations.php
│   └── Tuple.php
├── PointLight.php
├── shapes
│   ├── Plane.php
│   ├── ShapeCollectionIterator.php
│   ├── ShapeCollection.php
│   ├── Shape.php
│   └── Sphere.php
└── World.php

```

--------------------------------

### Using assertThat() with logicalNot() and equalTo()

Source: https://docs.phpunit.de/en/13.0/assertions.html

This example demonstrates how to use assertThat() with logicalNot() and equalTo() constraints to express an assertion equivalent to assertNotEquals(). It requires the PHPUnit TestCase class.

```PHP
<?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),
            ),
        );
    }
}

```

--------------------------------

### PHPUnit assertGreaterThan() Example

Source: https://docs.phpunit.de/en/13.0/assertions.html

Use assertGreaterThan() to verify if the actual value is strictly greater than the expected value.

```php
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;

final class GreaterThanTest extends TestCase
{
    public function testFailure(): void
    {
        $this->assertGreaterThan(2, 1);
    }
}

```

--------------------------------

### PHPUnit assertEmpty() Example

Source: https://docs.phpunit.de/en/13.0/assertions.html

Use assertEmpty() to assert that a variable or structure is empty. This assertion does not support generators.

```php
<?php declare(strict_types=1);
use PHPUnit\Framework\TestCase;

final class EmptyTest extends TestCase
{
    public function testFailure(): void
    {
        $this->assertEmpty(['foo']);
    }
}

```

--------------------------------

### Registering Extension from PHAR with Parameters

Source: https://docs.phpunit.de/en/13.0/extending-phpunit.html

Configure PHPUnit to load extensions from a PHAR file located in a specified directory. This example shows how to set the extensionsDirectory attribute and register an extension with a parameter.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<phpunit
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.0/phpunit.xsd"
    extensionsDirectory="../phpunit-extensions/"
>
    <!-- ... -->

    <extensions>
        <bootstrap class="Vendor\ExampleExtensionForPhpunit\ExampleExtension">
            <parameter name="message" value="the-message"/>
        </bootstrap>
    </extensions>

    <!-- ... -->
</phpunit>

```

--------------------------------

### Creating a Test Stub

Source: https://docs.phpunit.de/en/13.0/test-doubles.html

This snippet shows how to create a basic test stub for a class. The `createStub()` method generates a stub where all methods return default values unless explicitly configured.

```php
$database = $this->createStub(Database::class);

```
Tokens:
Raw