release: v2.10.1

feat(arch): Adds support for opposite expectations of `toHavePrefix` and `toHaveSuffix`

.github/workflows/static.yml

@@ -30,8 +30,11 @@ jobs:
     - name: Install Dependencies
       run: composer update --prefer-stable --no-interaction --no-progress --ansi
 
-    - name: Types
-      run: composer test:types
+    - name: Type Check
+      run: composer test:type:check
+
+    - name: Type Coverage
+      run: composer test:type:coverage
 
     - name: Refacto
       run: composer test:refacto

CHANGELOG.md

@@ -2,6 +2,111 @@
 
 ## Unreleased
 
+## [v2.10.1 (2023-07-31)](https://github.com/pestphp/pest/compare/v2.10.0...v2.10.1)
+
+### Fixed
+
+- `not->toHaveSuffix` and `toHavePrefix` expectations ([#888](https://github.com/pestphp/pest/pull/888))
+
+## [v2.10.0 (2023-07-31)](https://github.com/pestphp/pest/compare/v2.9.5...v2.10.0)
+
+### Added
+
+- `repeat` feature ([f3f35a2](https://github.com/pestphp/pest/commit/f3f35a2ed119f63eefd323a8c66d3387e908df3f))
+
+### Fixed
+
+- `-v` option ([86a6b32](https://github.com/pestphp/pest/commit/86a6b3271518742dc39761228687a5107551d279))
+
+## [v2.9.5 (2023-07-22)](https://github.com/pestphp/pest/compare/v2.9.4...v2.9.5)
+
+### Fixed
+
+- Assertions count on arch expectations ([632ffc2](https://github.com/pestphp/pest/commit/632ffc2f8e1fe45f739b12b818426ae14700079e))
+
+## [v2.9.4 (2023-07-22)](https://github.com/pestphp/pest/compare/v2.9.3...v2.9.4)
+
+### Fixed
+
+- Output on `describe` `beforeEach` failure ([5637dfa](https://github.com/pestphp/pest/commit/5637dfa75d1a331adc810935536cde7c3196af06))
+
+## [v2.9.3 (2023-07-20)](https://github.com/pestphp/pest/compare/v2.9.2...v2.9.3)
+
+### Fixed
+
+- Snapshots directory on Windows environments ([cf52752](https://github.com/pestphp/pest/commit/cf5275293fe693ec2cf4dbadbadae01daaa08169))
+
+## [v2.9.2 (2023-07-20)](https://github.com/pestphp/pest/compare/v2.9.1...v2.9.2)
+
+### Fixed
+
+- `beforeEach` on Windows environments ([a37a3b9](https://github.com/pestphp/pest/commit/a37a3b9f9931bc1ab1ea9e1d6d38dfb55dde3f74))
+
+## [v2.9.1 (2023-07-20)](https://github.com/pestphp/pest/compare/v2.9.0...v2.9.1)
+
+### Chore
+
+- Bumps PHPUnit to `^10.2.6` ([8fdb0b3](https://github.com/pestphp/pest/commit/8fdb0b3d32ce9ee12bd182f22751c2b41a53e97b))
+
+## [v2.9.0 (2023-07-19)](https://github.com/pestphp/pest/compare/v2.8.1...v2.9.0)
+
+> "Spicy Summer" is the codename assigned to Pest 2.9, for full details check our announcement: [https://pestphp.com/docs/pest-spicy-summer-release](https://pestphp.com/docs/pest-spicy-summer-release)
+
+### Added
+
+- Built-in Snapshot Testing ([c828756](https://github.com/pestphp/pest/commit/c8287567eb8c3dbea5845b2a6f70804b094b4b60))
+- Describe Blocks ([c828756](https://github.com/pestphp/pest/commit/c8287567eb8c3dbea5845b2a6f70804b094b4b60))
+- Architectural Testing++ ([c828756](https://github.com/pestphp/pest/commit/c8287567eb8c3dbea5845b2a6f70804b094b4b60))
+- Type Coverage Plugin ([c828756](https://github.com/pestphp/pest/commit/c8287567eb8c3dbea5845b2a6f70804b094b4b60))
+- Drift Plugin ([c828756](https://github.com/pestphp/pest/commit/c8287567eb8c3dbea5845b2a6f70804b094b4b60))
+
+## [v2.8.1 (2023-06-20)](https://github.com/pestphp/pest/compare/v2.8.0...v2.8.1)
+
+### Fixed
+- Fixes "Cannot find TestCase object on call stack" ([eb7bb34](https://github.com/pestphp/pest/commit/eb7bb348253f412e806a6ba6f0df46c0435d0dfe))
+
+## [v2.8.0 (2023-06-19)](https://github.com/pestphp/pest/compare/v2.7.0...v2.8.0)
+
+### Added
+- Support for `globs` in `uses` ([#829](https://github.com/pestphp/pest/pull/829))
+
+## [v2.7.0 (2023-06-15)](https://github.com/pestphp/pest/compare/v2.6.3...v2.7.0)
+
+### Added
+- Support for unexpected output on printer ([eb9f31e](https://github.com/pestphp/pest/commit/eb9f31edeb00a88c449874f3d48156128a00fff8))
+
+### Chore
+- Bumps PHPUnit to `^10.2.2` ([0e5470b](https://github.com/pestphp/pest/commit/0e5470b192b259ba2db7c02a50371216c98fc0a6))
+
+## [v2.6.3 (2023-06-07)](https://github.com/pestphp/pest/compare/v2.6.2...v2.6.3)
+
+### Chore
+- Bumps PHPUnit to `^10.2.1` ([73a859e](https://github.com/pestphp/pest/commit/73a859ee563fe96944ba39b191dceca28ef703c2))
+
+## [v2.6.2 (2023-06-02)](https://github.com/pestphp/pest/compare/v2.6.1...v2.6.2)
+
+### Chore
+- Bumps PHPUnit to `^10.2.0` ([a0041f1](https://github.com/pestphp/pest/commit/a0041f139cba94fe5d15318c38e275f2e2fb3350))
+
+## [v2.6.1 (2023-04-12)](https://github.com/pestphp/pest/compare/v2.6.0...v2.6.1)
+
+### Fixes
+- PHPStorm issue output problem for tests throwing an exception before the first assertion ([#809](https://github.com/pestphp/pest/pull/809))
+- Allow traits to be covered ([#804](https://github.com/pestphp/pest/pull/804))
+
+### Chore
+- Bumps PHPUnit to `^10.1.3` ([c993252](https://github.com/pestphp/pest/commit/c99325275acf1fd3759b487b93ec50473f706709))
+
+## [v2.6.0 (2023-04-05)](https://github.com/pestphp/pest/compare/v2.5.2...v2.6.0)
+
+### Adds
+- Allows `toThrow` to be used against an exception instance ([#797](https://github.com/pestphp/pest/pull/797))
+
+## [v2.5.2 (2023-04-19)](https://github.com/pestphp/pest/compare/v2.5.1...v2.5.2)
+
+### Chore
+- Removes `myclabs/php-enuma` dependency ([1a05df1](https://github.com/pestphp/pest/commit/1a05df14d0ce7d12583df26ff716807db6f81f13))
+
 ## [v2.5.1 (2023-04-18)](https://github.com/pestphp/pest/compare/v2.5.0...v2.5.1)
 
 ### Chore

README.md

@@ -32,7 +32,6 @@ We cannot thank our sponsors enough for their incredible support in funding Pest
 - [Codecourse](https://codecourse.com/)
 - [Laracasts](https://laracasts.com/)
 - [Localazy](https://localazy.com)
-- [Hyvor](https://hyvor.com/)
 - [Fathom Analytics](https://usefathom.com/)
 - [Meema](https://meema.io)
 - [Zapiet](https://www.zapiet.com)

bin/worker.php

@@ -31,6 +31,7 @@ $bootPest = (static function (): void {
     $getopt = getopt('', [
         'status-file:',
         'progress-file:',
+        'unexpected-output-file:',
         'testresult-file:',
         'teamcity-file:',
         'testdox-file:',
@@ -58,6 +59,7 @@ $bootPest = (static function (): void {
     assert(is_resource($statusFile));
 
     assert(isset($getopt['progress-file']) && is_string($getopt['progress-file']));
+    assert(isset($getopt['unexpected-output-file']) && is_string($getopt['unexpected-output-file']));
     assert(isset($getopt['testresult-file']) && is_string($getopt['testresult-file']));
     assert(! isset($getopt['teamcity-file']) || is_string($getopt['teamcity-file']));
     assert(! isset($getopt['testdox-file']) || is_string($getopt['testdox-file']));
@@ -73,6 +75,7 @@ $bootPest = (static function (): void {
     $application = new ApplicationForWrapperWorker(
         $phpunitArgv,
         $getopt['progress-file'],
+        $getopt['unexpected-output-file'],
         $getopt['testresult-file'],
         $getopt['teamcity-file'] ?? null,
         $getopt['testdox-file'] ?? null,
@@ -88,10 +91,10 @@ $bootPest = (static function (): void {
         $testPath = fgets(STDIN);
         if ($testPath === false || $testPath === WrapperWorker::COMMAND_EXIT) {
             $application->end();
-
             exit;
         }
 
+        // It must be a 1 byte string to ensure filesize() is equal to the number of tests executed
         $exitCode = $application->runTest(realpath(trim($testPath)));
 
         fwrite($statusFile, (string) $exitCode);

composer.json

@@ -1,6 +1,6 @@
 {
     "name": "pestphp/pest",
-    "description": "An elegant PHP Testing Framework.",
+    "description": "The elegant PHP Testing Framework.",
     "keywords": [
         "php",
         "framework",
@@ -18,16 +18,16 @@
     ],
     "require": {
         "php": "^8.1.0",
-        "brianium/paratest": "^7.1.3",
-        "nunomaduro/collision": "^7.5.0",
+        "brianium/paratest": "^7.2.3",
+        "nunomaduro/collision": "^7.7.0",
         "nunomaduro/termwind": "^1.15.1",
         "pestphp/pest-plugin": "^2.0.1",
-        "pestphp/pest-plugin-arch": "^2.1.1",
-        "phpunit/phpunit": "^10.1.1"
+        "pestphp/pest-plugin-arch": "^2.2.3",
+        "phpunit/phpunit": "^10.2.6"
     },
     "conflict": {
         "webmozart/assert": "<1.11.0",
-        "phpunit/phpunit": ">10.1.1"
+        "phpunit/phpunit": ">10.2.6"
     },
     "autoload": {
         "psr-4": {
@@ -42,6 +42,7 @@
         "psr-4": {
             "Tests\\Fixtures\\Covers\\": "tests/Fixtures/Covers",
             "Tests\\Fixtures\\Inheritance\\": "tests/Fixtures/Inheritance",
+            "Tests\\Fixtures\\Arch\\": "tests/Fixtures/Arch",
             "Tests\\": "tests/PHPUnit/"
         },
         "files": [
@@ -49,10 +50,12 @@
         ]
     },
     "require-dev": {
-        "pestphp/pest-dev-tools": "^2.6.0",
-        "symfony/process": "^6.2.8"
+        "pestphp/pest-dev-tools": "^2.12.0",
+        "pestphp/pest-plugin-type-coverage": "^2.0.0",
+        "symfony/process": "^6.3.2"
     },
-    "minimum-stability": "stable",
+    "minimum-stability": "dev",
+    "prefer-stable": true,
     "config": {
         "sort-packages": true,
         "preferred-install": "dist",
@@ -68,16 +71,18 @@
         "lint": "pint",
         "test:refacto": "rector --dry-run",
         "test:lint": "pint --test",
-        "test:types": "phpstan analyse --ansi --memory-limit=-1 --debug",
+        "test:type:check": "phpstan analyse --ansi --memory-limit=-1 --debug",
+        "test:type:coverage": "php bin/pest --type-coverage --min=100",
         "test:unit": "php bin/pest --colors=always --exclude-group=integration --compact",
         "test:inline": "php bin/pest --colors=always --configuration=phpunit.inline.xml",
         "test:parallel": "php bin/pest --colors=always --exclude-group=integration --parallel --processes=10",
         "test:integration": "php bin/pest --colors=always --group=integration",
-        "update:snapshots": "REBUILD_SNAPSHOTS=true php bin/pest --colors=always",
+        "update:snapshots": "REBUILD_SNAPSHOTS=true php bin/pest --colors=always --update-snapshots",
         "test": [
             "@test:refacto",
             "@test:lint",
-            "@test:types",
+            "@test:type:check",
+            "@test:type:coverage",
             "@test:unit",
             "@test:parallel",
             "@test:integration"
@@ -98,6 +103,8 @@
                 "Pest\\Plugins\\ProcessIsolation",
                 "Pest\\Plugins\\Profile",
                 "Pest\\Plugins\\Retry",
+                "Pest\\Plugins\\Snapshot",
+                "Pest\\Plugins\\Verbose",
                 "Pest\\Plugins\\Version",
                 "Pest\\Plugins\\Parallel"
             ]

overrides/Runner/ResultCache/DefaultResultCache.php

@@ -89,7 +89,7 @@ final class DefaultResultCache implements ResultCache
      */
     private array $times = [];
 
-    public function __construct(?string $filepath = null)
+    public function __construct(string $filepath = null)
     {
         if ($filepath !== null && is_dir($filepath)) {
             $filepath .= DIRECTORY_SEPARATOR.self::DEFAULT_RESULT_CACHE_FILENAME;

phpstan.neon

@@ -12,6 +12,7 @@ parameters:
     reportUnmatchedIgnoredErrors: true
 
     ignoreErrors:
+        - "#has a nullable return type declaration.#"
         - "#Language construct isset\\(\\) should not be used.#"
         - "#is not allowed to extend#"
         - "#is concrete, but does not have a Test suffix#"
@@ -20,4 +21,3 @@ parameters:
         - "# with null as default value#"
         - "#has parameter \\$closure with default value.#"
         - "#has parameter \\$description with default value.#"
-        - "#Method Pest\\\\Support\\\\Reflection::getParameterClassName\\(\\) has a nullable return type declaration.#"

src/Bootstrappers/BootExcludeList.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Bootstrappers;
+
+use Pest\Contracts\Bootstrapper;
+use PHPUnit\Util\ExcludeList;
+
+/**
+ * @internal
+ */
+final class BootExcludeList implements Bootstrapper
+{
+    /**
+     * The directories to exclude.
+     *
+     * @var array<int, non-empty-string>
+     */
+    private const EXCLUDE_LIST = [
+        'bin',
+        'overrides',
+        'resources',
+        'src',
+        'stubs',
+    ];
+
+    /**
+     * Boots the "exclude list" for PHPUnit to ignore Pest files.
+     */
+    public function boot(): void
+    {
+        $baseDirectory = dirname(__DIR__, 2);
+
+        foreach (self::EXCLUDE_LIST as $directory) {
+            ExcludeList::addDirectory($baseDirectory.DIRECTORY_SEPARATOR.$directory);
+        }
+    }
+}

src/Concerns/Pipeable.php

@@ -5,7 +5,6 @@ declare(strict_types=1);
 namespace Pest\Concerns;
 
 use Closure;
-use Pest\Expectation;
 
 /**
  * @internal
@@ -37,7 +36,7 @@ trait Pipeable
     /**
      * Register an interceptor that should replace an existing expectation.
      *
-     * @param string|Closure(mixed $value, mixed ...$arguments):bool $filter
+     * @param  string|Closure(mixed $value, mixed ...$arguments):bool  $filter
      */
     public function intercept(string $name, string|Closure $filter, Closure $handler): void
     {

src/Concerns/Testable.php

@@ -23,37 +23,42 @@ use Throwable;
 trait Testable
 {
     /**
-     * Test method description.
+     * The test's description.
      */
     private string $__description;
 
     /**
-     * Test "latest" method description.
+     * The test's latest description.
      */
     private static string $__latestDescription;
 
     /**
-     * The Test Case "test" closure.
+     * The test's describing, if any.
+     */
+    public ?string $__describing = null;
+
+    /**
+     * The test's test closure.
      */
     private Closure $__test;
 
     /**
-     * The Test Case "setUp" closure.
+     * The test's before each closure.
      */
     private ?Closure $__beforeEach = null;
 
     /**
-     * The Test Case "tearDown" closure.
+     * The test's after each closure.
      */
     private ?Closure $__afterEach = null;
 
     /**
-     * The Test Case "setUpBeforeClass" closure.
+     * The test's before all closure.
      */
     private static ?Closure $__beforeAll = null;
 
     /**
-     * The test "tearDownAfterClass" closure.
+     * The test's after all closure.
      */
     private static ?Closure $__afterAll = null;
 
@@ -78,6 +83,7 @@ trait Testable
         if ($test->hasMethod($name)) {
             $method = $test->getMethod($name);
             $this->__description = self::$__latestDescription = $method->description;
+            $this->__describing = $method->describing;
             $this->__test = $method->getClosure($this);
         }
     }
@@ -92,7 +98,7 @@ trait Testable
         }
 
         self::$__beforeAll = (self::$__beforeAll instanceof Closure)
-            ? ChainableClosure::fromStatic(self::$__beforeAll, $hook)
+            ? ChainableClosure::boundStatically(self::$__beforeAll, $hook)
             : $hook;
     }
 
@@ -106,7 +112,7 @@ trait Testable
         }
 
         self::$__afterAll = (self::$__afterAll instanceof Closure)
-            ? ChainableClosure::fromStatic(self::$__afterAll, $hook)
+            ? ChainableClosure::boundStatically(self::$__afterAll, $hook)
             : $hook;
     }
 
@@ -136,7 +142,7 @@ trait Testable
         }
 
         $this->{$property} = ($this->{$property} instanceof Closure)
-            ? ChainableClosure::from($this->{$property}, $hook)
+            ? ChainableClosure::bound($this->{$property}, $hook)
             : $hook;
     }
 
@@ -150,7 +156,7 @@ trait Testable
         $beforeAll = TestSuite::getInstance()->beforeAll->get(self::$__filename);
 
         if (self::$__beforeAll instanceof Closure) {
-            $beforeAll = ChainableClosure::fromStatic(self::$__beforeAll, $beforeAll);
+            $beforeAll = ChainableClosure::boundStatically(self::$__beforeAll, $beforeAll);
         }
 
         call_user_func(Closure::bind($beforeAll, null, self::class));
@@ -164,7 +170,7 @@ trait Testable
         $afterAll = TestSuite::getInstance()->afterAll->get(self::$__filename);
 
         if (self::$__afterAll instanceof Closure) {
-            $afterAll = ChainableClosure::fromStatic(self::$__afterAll, $afterAll);
+            $afterAll = ChainableClosure::boundStatically(self::$__afterAll, $afterAll);
         }
 
         call_user_func(Closure::bind($afterAll, null, self::class));
@@ -179,12 +185,33 @@ trait Testable
     {
         TestSuite::getInstance()->test = $this;
 
+        $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
+
+        $description = $this->dataName() ? $method->description.' with '.$this->dataName() : $method->description;
+
+        if ($method->repetitions > 1) {
+            $matches = [];
+            preg_match('/\((.*?)\)/', $description, $matches);
+
+            if (count($matches) > 1) {
+                if (str_contains($description, 'with '.$matches[0].' /')) {
+                    $description = str_replace('with '.$matches[0].' /', '', $description);
+                } else {
+                    $description = str_replace('with '.$matches[0], '', $description);
+                }
+            }
+
+            $description .= ' @ repetition '.($matches[1].' of '.$method->repetitions);
+        }
+
+        $this->__description = self::$__latestDescription = $description;
+
         parent::setUp();
 
-        $beforeEach = TestSuite::getInstance()->beforeEach->get(self::$__filename);
+        $beforeEach = TestSuite::getInstance()->beforeEach->get(self::$__filename)[1];
 
         if ($this->__beforeEach instanceof Closure) {
-            $beforeEach = ChainableClosure::from($this->__beforeEach, $beforeEach);
+            $beforeEach = ChainableClosure::bound($this->__beforeEach, $beforeEach);
         }
 
         $this->__callClosure($beforeEach, func_get_args());
@@ -198,7 +225,7 @@ trait Testable
         $afterEach = TestSuite::getInstance()->afterEach->get(self::$__filename);
 
         if ($this->__afterEach instanceof Closure) {
-            $afterEach = ChainableClosure::from($this->__afterEach, $afterEach);
+            $afterEach = ChainableClosure::bound($this->__afterEach, $afterEach);
         }
 
         $this->__callClosure($afterEach, func_get_args());
@@ -230,7 +257,9 @@ trait Testable
     {
         $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
 
-        $this->__description = self::$__latestDescription = $this->dataName() ? $method->description.' with '.$this->dataName() : $method->description;
+        if ($method->repetitions > 1) {
+            array_shift($arguments);
+        }
 
         $underlyingTest = Reflection::getFunctionVariable($this->__test, 'closure');
         $testParameterTypes = array_values(Reflection::getFunctionArguments($underlyingTest));

src/Exceptions/AfterAllWithinDescribe.php

@@ -12,13 +12,13 @@ use Symfony\Component\Console\Exception\ExceptionInterface;
 /**
  * @internal
  */
-final class BeforeEachAlreadyExist extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
+final class AfterAllWithinDescribe extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
 {
     /**
      * Creates a new Exception instance.
      */
     public function __construct(string $filename)
     {
-        parent::__construct(sprintf('The beforeEach already exists in the filename `%s`.', $filename));
+        parent::__construct(sprintf('The afterAll method can not be used within describe functions. Filename `%s`.', $filename));
     }
 }

src/Exceptions/BeforeAllAlreadyExist.php

@@ -12,13 +12,13 @@ use Symfony\Component\Console\Exception\ExceptionInterface;
 /**
  * @internal
  */
-final class AfterEachAlreadyExist extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
+final class BeforeAllAlreadyExist extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
 {
     /**
      * Creates a new Exception instance.
      */
     public function __construct(string $filename)
     {
-        parent::__construct(sprintf('The afterEach already exists in the filename `%s`.', $filename));
+        parent::__construct(sprintf('The beforeAll already exists in the filename `%s`.', $filename));
     }
 }

src/Exceptions/BeforeAllWithinDescribe.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use InvalidArgumentException;
+use NunoMaduro\Collision\Contracts\RenderlessEditor;
+use NunoMaduro\Collision\Contracts\RenderlessTrace;
+use Symfony\Component\Console\Exception\ExceptionInterface;
+
+/**
+ * @internal
+ */
+final class BeforeAllWithinDescribe extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
+{
+    /**
+     * Creates a new Exception instance.
+     */
+    public function __construct(string $filename)
+    {
+        parent::__construct(sprintf('The beforeAll method can not be used within describe functions. Filename `%s`.', $filename));
+    }
+}

src/Exceptions/InvalidArgumentException.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use InvalidArgumentException as BaseInvalidArgumentException;
+use NunoMaduro\Collision\Contracts\RenderlessEditor;
+use NunoMaduro\Collision\Contracts\RenderlessTrace;
+use Symfony\Component\Console\Exception\ExceptionInterface;
+
+/**
+ * @internal
+ */
+final class InvalidArgumentException extends BaseInvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
+{
+    /**
+     * Creates a new Exception instance.
+     */
+    public function __construct(string $message)
+    {
+        parent::__construct($message, 1);
+    }
+}

src/Expectation.php

@@ -7,12 +7,15 @@ namespace Pest;
 use BadMethodCallException;
 use Closure;
 use Pest\Arch\Contracts\ArchExpectation;
+use Pest\Arch\Expectations\Targeted;
 use Pest\Arch\Expectations\ToBeUsedIn;
 use Pest\Arch\Expectations\ToBeUsedInNothing;
 use Pest\Arch\Expectations\ToOnlyBeUsedIn;
 use Pest\Arch\Expectations\ToOnlyUse;
 use Pest\Arch\Expectations\ToUse;
 use Pest\Arch\Expectations\ToUseNothing;
+use Pest\Arch\PendingArchExpectation;
+use Pest\Arch\Support\FileLineFinder;
 use Pest\Concerns\Extendable;
 use Pest\Concerns\Pipeable;
 use Pest\Concerns\Retrievable;
@@ -24,6 +27,7 @@ use Pest\Expectations\HigherOrderExpectation;
 use Pest\Expectations\OppositeExpectation;
 use Pest\Matchers\Any;
 use Pest\Support\ExpectationPipeline;
+use PHPUnit\Architecture\Elements\ObjectDescription;
 use PHPUnit\Framework\Assert;
 use PHPUnit\Framework\ExpectationFailedException;
 
@@ -34,8 +38,13 @@ use PHPUnit\Framework\ExpectationFailedException;
  *
  * @property OppositeExpectation $not Creates the opposite expectation.
  * @property EachExpectation $each Creates an expectation on each element on the traversable value.
+ * @property PendingArchExpectation $classes
+ * @property PendingArchExpectation $traits
+ * @property PendingArchExpectation $interfaces
+ * @property PendingArchExpectation $enums
  *
  * @mixin Mixins\Expectation<TValue>
+ * @mixin PendingArchExpectation
  */
 final class Expectation
 {
@@ -167,7 +176,7 @@ final class Expectation
      *
      * @template TSequenceValue
      *
-     * @param (callable(self<TValue>, self<string|int>): void)|TSequenceValue ...$callbacks
+     * @param  (callable(self<TValue>, self<string|int>): void)|TSequenceValue  ...$callbacks
      * @return self<TValue>
      */
     public function sequence(mixed ...$callbacks): self
@@ -210,8 +219,8 @@ final class Expectation
      *
      * @template TMatchSubject of array-key
      *
-     * @param (callable(): TMatchSubject)|TMatchSubject $subject
-     * @param array<TMatchSubject, (callable(self<TValue>): mixed)|TValue> $expressions
+     * @param  (callable(): TMatchSubject)|TMatchSubject  $subject
+     * @param  array<TMatchSubject, (callable(self<TValue>): mixed)|TValue>  $expressions
      * @return self<TValue>
      */
     public function match(mixed $subject, array $expressions): self
@@ -248,7 +257,7 @@ final class Expectation
     /**
      * Apply the callback if the given "condition" is falsy.
      *
-     * @param (callable(): bool)|bool $condition
+     * @param  (callable(): bool)|bool  $condition
      * @param  callable(Expectation<TValue>): mixed  $callback
      * @return self<TValue>
      */
@@ -264,7 +273,7 @@ final class Expectation
     /**
      * Apply the callback if the given "condition" is truthy.
      *
-     * @param (callable(): bool)|bool $condition
+     * @param  (callable(): bool)|bool  $condition
      * @param  callable(self<TValue>): mixed  $callback
      * @return self<TValue>
      */
@@ -287,9 +296,23 @@ final class Expectation
      * @param  array<int, mixed>  $parameters
      * @return Expectation<TValue>|HigherOrderExpectation<Expectation<TValue>, TValue>
      */
-    public function __call(string $method, array $parameters): Expectation|HigherOrderExpectation
+    public function __call(string $method, array $parameters): Expectation|HigherOrderExpectation|PendingArchExpectation
     {
         if (! self::hasMethod($method)) {
+            if (! is_object($this->value) && method_exists(PendingArchExpectation::class, $method)) {
+                $pendingArchExpectation = new PendingArchExpectation($this, []);
+
+                return $pendingArchExpectation->$method(...$parameters); // @phpstan-ignore-line
+            }
+
+            if (! is_object($this->value)) {
+                throw new BadMethodCallException(sprintf(
+                    'Method "%s" does not exist in %s.',
+                    $method,
+                    gettype($this->value)
+                ));
+            }
+
             /* @phpstan-ignore-next-line */
             return new HigherOrderExpectation($this, call_user_func_array($this->value->$method(...), $parameters));
         }
@@ -333,6 +356,11 @@ final class Expectation
     public function __get(string $name)
     {
         if (! self::hasMethod($name)) {
+            if (! is_object($this->value) && method_exists(PendingArchExpectation::class, $name)) {
+                /* @phpstan-ignore-next-line */
+                return $this->{$name}();
+            }
+
             /* @phpstan-ignore-next-line */
             return new HigherOrderExpectation($this, $this->retrieve($name, $this->value));
         }
@@ -369,6 +397,252 @@ final class Expectation
         return ToUse::make($this, $targets);
     }
 
+    /**
+     * Asserts that the given expectation target use the "declare(strict_types=1)" declaration.
+     */
+    public function toUseStrictTypes(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => str_contains((string) file_get_contents($object->path), 'declare(strict_types=1);'),
+            'to use strict types',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, '<?php')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target is final.
+     */
+    public function toBeFinal(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && $object->reflectionClass->isFinal(),
+            'to be final',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target is readonly.
+     */
+    public function toBeReadonly(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && $object->reflectionClass->isReadOnly() && assert(true), // @phpstan-ignore-line
+            'to be readonly',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target is trait.
+     */
+    public function toBeTrait(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->isTrait(),
+            'to be trait',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are traits.
+     */
+    public function toBeTraits(): ArchExpectation
+    {
+        return $this->toBeTrait();
+    }
+
+    /**
+     * Asserts that the given expectation target is abstract.
+     */
+    public function toBeAbstract(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->isAbstract(),
+            'to be abstract',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target is enum.
+     */
+    public function toBeEnum(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->isEnum(),
+            'to be enum',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are enums.
+     */
+    public function toBeEnums(): ArchExpectation
+    {
+        return $this->toBeEnum();
+    }
+
+    /**
+     * Asserts that the given expectation targets is an class.
+     */
+    public function toBeClass(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => class_exists($object->name) && ! enum_exists($object->name),
+            'to be class',
+            FileLineFinder::where(fn (string $line): bool => true),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are classes.
+     */
+    public function toBeClasses(): ArchExpectation
+    {
+        return $this->toBeClass();
+    }
+
+    /**
+     * Asserts that the given expectation target is interface.
+     */
+    public function toBeInterface(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->isInterface(),
+            'to be interface',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are interfaces.
+     */
+    public function toBeInterfaces(): ArchExpectation
+    {
+        return $this->toBeInterface();
+    }
+
+    /**
+     * Asserts that the given expectation target to be subclass of the given class.
+     *
+     * @param  class-string  $class
+     */
+    public function toExtend(string $class): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $class === $object->reflectionClass->getName() || $object->reflectionClass->isSubclassOf($class),
+            sprintf("to extend '%s'", $class),
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to be have a parent class.
+     */
+    public function toExtendNothing(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->getParentClass() === false,
+            'to extend nothing',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to not implement any interfaces.
+     */
+    public function toImplementNothing(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->getInterfaceNames() === [],
+            'to implement nothing',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to only implement the given interfaces.
+     *
+     * @param  array<int, class-string>|class-string  $interfaces
+     */
+    public function toOnlyImplement(array|string $interfaces): ArchExpectation
+    {
+        $interfaces = is_array($interfaces) ? $interfaces : [$interfaces];
+
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => count($interfaces) === count($object->reflectionClass->getInterfaceNames())
+                && array_diff($interfaces, $object->reflectionClass->getInterfaceNames()) === [],
+            "to only implement '".implode("', '", $interfaces)."'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to have the given suffix.
+     */
+    public function toHavePrefix(string $prefix): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => str_starts_with($object->reflectionClass->getShortName(), $prefix),
+            "to have prefix '{$prefix}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to have the given suffix.
+     */
+    public function toHaveSuffix(string $suffix): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => str_ends_with($object->reflectionClass->getName(), $suffix),
+            "to have suffix '{$suffix}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to implement the given interfaces.
+     *
+     * @param  array<int, class-string>|class-string  $interfaces
+     */
+    public function toImplement(array|string $interfaces): ArchExpectation
+    {
+        $interfaces = is_array($interfaces) ? $interfaces : [$interfaces];
+
+        return Targeted::make(
+            $this,
+            function (ObjectDescription $object) use ($interfaces): bool {
+                foreach ($interfaces as $interface) {
+                    if (! $object->reflectionClass->implementsInterface($interface)) {
+                        return false;
+                    }
+                }
+
+                return true;
+            },
+            "to implement '".implode("', '", $interfaces)."'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
     /**
      * Asserts that the given expectation target "only" use on the given dependencies.
      *

src/Expectations/OppositeExpectation.php

@@ -5,15 +5,20 @@ declare(strict_types=1);
 namespace Pest\Expectations;
 
 use Pest\Arch\Contracts\ArchExpectation;
+use Pest\Arch\Expectations\Targeted;
 use Pest\Arch\Expectations\ToBeUsedIn;
 use Pest\Arch\Expectations\ToBeUsedInNothing;
 use Pest\Arch\Expectations\ToUse;
 use Pest\Arch\GroupArchExpectation;
+use Pest\Arch\PendingArchExpectation;
 use Pest\Arch\SingleArchExpectation;
+use Pest\Arch\Support\FileLineFinder;
 use Pest\Exceptions\InvalidExpectation;
 use Pest\Expectation;
 use Pest\Support\Arr;
 use Pest\Support\Exporter;
+use PHPUnit\Architecture\Elements\ObjectDescription;
+use PHPUnit\Framework\AssertionFailedError;
 use PHPUnit\Framework\ExpectationFailedException;
 
 /**
@@ -72,6 +77,246 @@ final class OppositeExpectation
     }
 
     /**
+     * Asserts that the given expectation target does not use the "declare(strict_types=1)" declaration.
+     */
+    public function toUseStrictTypes(): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! str_contains((string) file_get_contents($object->path), 'declare(strict_types=1);'),
+            'not to use strict types',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, '<?php')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target is not final.
+     */
+    public function toBeFinal(): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && ! $object->reflectionClass->isFinal(),
+            'not to be final',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target is not readonly.
+     */
+    public function toBeReadonly(): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && ! $object->reflectionClass->isReadOnly() && assert(true), // @phpstan-ignore-line
+            'not to be readonly',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target is not trait.
+     */
+    public function toBeTrait(): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isTrait(),
+            'not to be trait',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are not traits.
+     */
+    public function toBeTraits(): ArchExpectation
+    {
+        return $this->toBeTrait();
+    }
+
+    /**
+     * Asserts that the given expectation target is not abstract.
+     */
+    public function toBeAbstract(): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isAbstract(),
+            'not to be abstract',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target is not enum.
+     */
+    public function toBeEnum(): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isEnum(),
+            'not to be enum',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are not enums.
+     */
+    public function toBeEnums(): ArchExpectation
+    {
+        return $this->toBeEnum();
+    }
+
+    /**
+     * Asserts that the given expectation targets is an class.
+     */
+    public function toBeClass(): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! class_exists($object->name),
+            'not to be class',
+            FileLineFinder::where(fn (string $line): bool => true),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are not classes.
+     */
+    public function toBeClasses(): ArchExpectation
+    {
+        return $this->toBeClass();
+    }
+
+    /**
+     * Asserts that the given expectation target is not interface.
+     */
+    public function toBeInterface(): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isInterface(),
+            'not to be interface',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are not interfaces.
+     */
+    public function toBeInterfaces(): ArchExpectation
+    {
+        return $this->toBeInterface();
+    }
+
+    /**
+     * Asserts that the given expectation target to be subclass of the given class.
+     *
+     * @param  class-string  $class
+     */
+    public function toExtend(string $class): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isSubclassOf($class),
+            sprintf("not to extend '%s'", $class),
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to be not have any parent class.
+     */
+    public function toExtendNothing(): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->getParentClass() !== false,
+            'to extend a class',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target not to implement the given interfaces.
+     *
+     * @param  array<int, class-string>|string  $interfaces
+     */
+    public function toImplement(array|string $interfaces): ArchExpectation
+    {
+        $interfaces = is_array($interfaces) ? $interfaces : [$interfaces];
+
+        return Targeted::make(
+            $this->original,
+            function (ObjectDescription $object) use ($interfaces): bool {
+                foreach ($interfaces as $interface) {
+                    if ($object->reflectionClass->implementsInterface($interface)) {
+                        return false;
+                    }
+                }
+
+                return true;
+            },
+            "not to implement '".implode("', '", $interfaces)."'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to not implement any interfaces.
+     */
+    public function toImplementNothing(): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->getInterfaceNames() !== [],
+            'to implement an interface',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Not supported.
+     *
+     * @param  array<int, class-string>|string  $interfaces
+     */
+    public function toOnlyImplement(array|string $interfaces): never
+    {
+        throw InvalidExpectation::fromMethods(['not', 'toOnlyImplement']);
+    }
+
+    /**
+     * Not supported.
+     */
+    public function toHavePrefix(string $prefix): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! str_starts_with($object->reflectionClass->getShortName(), $prefix),
+            "not to have prefix '{$prefix}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Not supported.
+     */
+    public function toHaveSuffix(string $suffix): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! str_ends_with($object->reflectionClass->getName(), $suffix),
+            "not to have suffix '{$suffix}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Not supported.
+     *
      * @param  array<int, string>|string  $targets
      */
     public function toOnlyUse(array|string $targets): never
@@ -79,6 +324,9 @@ final class OppositeExpectation
         throw InvalidExpectation::fromMethods(['not', 'toOnlyUse']);
     }
 
+    /**
+     * Not supported.
+     */
     public function toUseNothing(): never
     {
         throw InvalidExpectation::fromMethods(['not', 'toUseNothing']);
@@ -126,9 +374,13 @@ final class OppositeExpectation
     public function __call(string $name, array $arguments): Expectation
     {
         try {
+            if (! is_object($this->original->value) && method_exists(PendingArchExpectation::class, $name)) {
+                throw InvalidExpectation::fromMethods(['not', $name]);
+            }
+
             /* @phpstan-ignore-next-line */
             $this->original->{$name}(...$arguments);
-        } catch (ExpectationFailedException) {
+        } catch (ExpectationFailedException|AssertionFailedError) {
             return $this->original;
         }
 
@@ -143,8 +395,12 @@ final class OppositeExpectation
     public function __get(string $name): Expectation
     {
         try {
+            if (! is_object($this->original->value) && method_exists(PendingArchExpectation::class, $name)) {
+                throw InvalidExpectation::fromMethods(['not', $name]);
+            }
+
             $this->original->{$name}; // @phpstan-ignore-line
-        } catch (ExpectationFailedException) {  // @phpstan-ignore-line
+        } catch (ExpectationFailedException) {
             return $this->original;
         }
 
@@ -162,8 +418,13 @@ final class OppositeExpectation
 
         $exporter = Exporter::default();
 
-        $toString = fn ($argument): string => $exporter->shortenedExport($argument);
+        $toString = fn (mixed $argument): string => $exporter->shortenedExport($argument);
 
-        throw new ExpectationFailedException(sprintf('Expecting %s not %s %s.', $toString($this->original->value), strtolower((string) preg_replace('/(?<!\ )[A-Z]/', ' $0', $name)), implode(' ', array_map(fn ($argument): string => $toString($argument), $arguments))));
+        throw new ExpectationFailedException(sprintf(
+            'Expecting %s not %s %s.',
+            $toString($this->original->value),
+            strtolower((string) preg_replace('/(?<!\ )[A-Z]/', ' $0', $name)),
+            implode(' ', array_map(fn (mixed $argument): string => $toString($argument), $arguments)),
+        ));
     }
 }

src/Factories/TestCaseFactory.php

@@ -98,7 +98,7 @@ final class TestCaseFactory
     {
         if ('\\' === DIRECTORY_SEPARATOR) {
             // In case Windows, strtolower drive name, like in UsesCall.
-            $filename = (string) preg_replace_callback('~^(?P<drive>[a-z]+:\\\)~i', static fn ($match): string => strtolower($match['drive']), $filename);
+            $filename = (string) preg_replace_callback('~^(?P<drive>[a-z]+:\\\)~i', static fn (array $match): string => strtolower($match['drive']), $filename);
         }
 
         $filename = str_replace('\\\\', '\\', addslashes((string) realpath($filename)));
@@ -134,7 +134,7 @@ final class TestCaseFactory
 
         $hasPrintableTestCaseClassFQN = sprintf('\%s', HasPrintableTestCaseName::class);
         $traitsCode = sprintf('use %s;', implode(', ', array_map(
-            static fn ($trait): string => sprintf('\%s', $trait), $this->traits))
+            static fn (string $trait): string => sprintf('\%s', $trait), $this->traits))
         );
 
         $partsFQN = explode('\\', $classFQN);

src/Factories/TestCaseMethodFactory.php

@@ -22,40 +22,50 @@ final class TestCaseMethodFactory
     use HigherOrderable;
 
     /**
-     * Determines if the Test Case Method is a "todo".
+     * The test's describing, if any.
+     */
+    public ?string $describing = null;
+
+    /**
+     * The test's number of repetitions.
+     */
+    public int $repetitions = 1;
+
+    /**
+     * Determines if the test is a "todo".
      */
     public bool $todo = false;
 
     /**
-     * The Test Case Dataset, if any.
+     * The test's datasets.
      *
      * @var array<Closure|iterable<int|string, mixed>|string>
      */
     public array $datasets = [];
 
     /**
-     * The Test Case depends, if any.
+     * The test's dependencies.
      *
      * @var array<int, string>
      */
     public array $depends = [];
 
     /**
-     * The Test Case groups, if any.
+     * The test's groups.
      *
      * @var array<int, string>
      */
     public array $groups = [];
 
     /**
-     * The covered classes and functions, if any.
+     * The covered classes and functions.
      *
      * @var array<int, \Pest\Factories\Covers\CoversClass|\Pest\Factories\Covers\CoversFunction|\Pest\Factories\Covers\CoversNothing>
      */
     public array $covers = [];
 
     /**
-     * Creates a new Factory instance.
+     * Creates a new test case method factory instance.
      */
     public function __construct(
         public string $filename,
@@ -70,7 +80,7 @@ final class TestCaseMethodFactory
     }
 
     /**
-     * Makes the Test Case classes.
+     * Creates the test's closure.
      */
     public function getClosure(TestCase $concrete): Closure
     {
@@ -90,7 +100,7 @@ final class TestCaseMethodFactory
         $method = $this;
 
         return function () use ($testCase, $method, $closure): mixed { // @phpstan-ignore-line
-        /* @var TestCase $this */
+            /* @var TestCase $this */
             $testCase->proxies->proxy($this);
             $method->proxies->proxy($this);
 
@@ -135,18 +145,18 @@ final class TestCaseMethodFactory
             $attributes = (new $attribute())->__invoke($this, $attributes);
         }
 
-        if ($this->datasets !== []) {
+        if ($this->datasets !== [] || $this->repetitions > 1) {
             $dataProviderName = $methodName.'_dataset';
             $annotations[] = "@dataProvider $dataProviderName";
             $datasetsCode = $this->buildDatasetForEvaluation($methodName, $dataProviderName);
         }
 
         $annotations = implode('', array_map(
-            static fn ($annotation): string => sprintf("\n     * %s", $annotation), $annotations,
+            static fn (string $annotation): string => sprintf("\n     * %s", $annotation), $annotations,
         ));
 
         $attributes = implode('', array_map(
-            static fn ($attribute): string => sprintf("\n        %s", $attribute), $attributes,
+            static fn (string $attribute): string => sprintf("\n        %s", $attribute), $attributes,
         ));
 
         return <<<PHP
@@ -172,7 +182,13 @@ final class TestCaseMethodFactory
      */
     private function buildDatasetForEvaluation(string $methodName, string $dataProviderName): string
     {
-        DatasetsRepository::with($this->filename, $methodName, $this->datasets);
+        $datasets = $this->datasets;
+
+        if ($this->repetitions > 1) {
+            $datasets = [range(1, $this->repetitions), ...$datasets];
+        }
+
+        DatasetsRepository::with($this->filename, $methodName, $datasets);
 
         return <<<EOF
 

src/Functions.php

@@ -2,9 +2,13 @@
 
 declare(strict_types=1);
 
+use Pest\Concerns\Expectable;
+use Pest\Exceptions\AfterAllWithinDescribe;
+use Pest\Exceptions\BeforeAllWithinDescribe;
 use Pest\Expectation;
 use Pest\PendingCalls\AfterEachCall;
 use Pest\PendingCalls\BeforeEachCall;
+use Pest\PendingCalls\DescribeCall;
 use Pest\PendingCalls\TestCall;
 use Pest\PendingCalls\UsesCall;
 use Pest\Repositories\DatasetsRepository;
@@ -35,6 +39,12 @@ if (! function_exists('beforeAll')) {
      */
     function beforeAll(Closure $closure): void
     {
+        if (! is_null(DescribeCall::describing())) {
+            $filename = Backtrace::file();
+
+            throw new BeforeAllWithinDescribe($filename);
+        }
+
         TestSuite::getInstance()->beforeAll->set($closure);
     }
 }
@@ -43,7 +53,7 @@ if (! function_exists('beforeEach')) {
     /**
      * Runs the given closure before each test in the current file.
      *
-     * @return HigherOrderTapProxy<TestCall|TestCase>|TestCall|mixed
+     * @return HigherOrderTapProxy<Expectable|TestCall|TestCase>|Expectable|TestCall|TestCase|mixed
      */
     function beforeEach(Closure $closure = null): BeforeEachCall
     {
@@ -67,6 +77,22 @@ if (! function_exists('dataset')) {
     }
 }
 
+if (! function_exists('describe')) {
+    /**
+     * Adds the given closure as a group of tests. The first argument
+     * is the group description; the second argument is a closure
+     * that contains the group tests.
+     *
+     * @return HigherOrderTapProxy<Expectable|TestCall|TestCase>|Expectable|TestCall|TestCase|mixed
+     */
+    function describe(string $description, Closure $tests): DescribeCall
+    {
+        $filename = Backtrace::testFile();
+
+        return new DescribeCall(TestSuite::getInstance(), $filename, $description, $tests);
+    }
+}
+
 if (! function_exists('uses')) {
     /**
      * The uses function binds the given
@@ -88,7 +114,7 @@ if (! function_exists('test')) {
      * is the test description; the second argument is
      * a closure that contains the test expectations.
      *
-     * @return TestCall|TestCase|mixed
+     * @return Expectable|TestCall|TestCase|mixed
      */
     function test(string $description = null, Closure $closure = null): HigherOrderTapProxy|TestCall
     {
@@ -108,7 +134,7 @@ if (! function_exists('it')) {
      * is the test description; the second argument is
      * a closure that contains the test expectations.
      *
-     * @return TestCall|TestCase|mixed
+     * @return Expectable|TestCall|TestCase|mixed
      */
     function it(string $description, Closure $closure = null): TestCall
     {
@@ -127,7 +153,7 @@ if (! function_exists('todo')) {
      * is marked as incomplete. Yet, Collision, Pest's
      * printer, will display it as a "todo" test.
      *
-     * @return TestCall|TestCase|mixed
+     * @return Expectable|TestCall|TestCase|mixed
      */
     function todo(string $description): TestCall
     {
@@ -143,7 +169,7 @@ if (! function_exists('afterEach')) {
     /**
      * Runs the given closure after each test in the current file.
      *
-     * @return HigherOrderTapProxy<TestCall|TestCase>|TestCall|mixed
+     * @return Expectable|HigherOrderTapProxy<Expectable|TestCall|TestCase>|TestCall|mixed
      */
     function afterEach(Closure $closure = null): AfterEachCall
     {
@@ -159,6 +185,12 @@ if (! function_exists('afterAll')) {
      */
     function afterAll(Closure $closure): void
     {
+        if (! is_null(DescribeCall::describing())) {
+            $filename = Backtrace::file();
+
+            throw new AfterAllWithinDescribe($filename);
+        }
+
         TestSuite::getInstance()->afterAll->set($closure);
     }
 }

src/Kernel.php

@@ -33,6 +33,7 @@ final class Kernel
         Bootstrappers\BootFiles::class,
         Bootstrappers\BootView::class,
         Bootstrappers\BootKernelDump::class,
+        Bootstrappers\BootExcludeList::class,
     ];
 
     /**
@@ -67,10 +68,14 @@ final class Kernel
 
         CallsBoot::execute();
 
-        return new self(
+        $kernel = new self(
             new Application(),
             $output,
         );
+
+        Container::getInstance()->add(self::class, $kernel);
+
+        return $kernel;
     }
 
     /**

src/Logging/TeamCity/Converter.php

@@ -11,6 +11,12 @@ use Pest\Support\Str;
 use PHPUnit\Event\Code\Test;
 use PHPUnit\Event\Code\TestMethod;
 use PHPUnit\Event\Code\Throwable;
+use PHPUnit\Event\Test\BeforeFirstTestMethodErrored;
+use PHPUnit\Event\Test\ConsideredRisky;
+use PHPUnit\Event\Test\Errored;
+use PHPUnit\Event\Test\Failed;
+use PHPUnit\Event\Test\MarkedIncomplete;
+use PHPUnit\Event\Test\Skipped;
 use PHPUnit\Event\TestSuite\TestSuite;
 use PHPUnit\Framework\Exception as FrameworkException;
 use PHPUnit\TestRunner\TestResult\TestResult as PhpUnitTestResult;
@@ -147,7 +153,7 @@ final class Converter
     /**
      * Gets the test suite location.
      */
-    public function getTestSuiteLocation(TestSuite $testSuite): string|null
+    public function getTestSuiteLocation(TestSuite $testSuite): ?string
     {
         $tests = $testSuite->tests()->asArray();
 
@@ -188,12 +194,30 @@ final class Converter
      */
     public function getStateFromResult(PhpUnitTestResult $result): State
     {
-        $numberOfPassedTests = $result->numberOfTestsRun()
-            - $result->numberOfTestErroredEvents()
-            - $result->numberOfTestFailedEvents()
-            - $result->numberOfTestSkippedEvents()
-            - $result->numberOfTestsWithTestConsideredRiskyEvents()
-            - $result->numberOfTestMarkedIncompleteEvents();
+        $events = [
+            ...$result->testErroredEvents(),
+            ...$result->testFailedEvents(),
+            ...$result->testSkippedEvents(),
+            ...array_merge(...array_values($result->testConsideredRiskyEvents())),
+            ...$result->testMarkedIncompleteEvents(),
+        ];
+
+        $numberOfNotPassedTests = count(
+            array_unique(
+                array_map(
+                    function (BeforeFirstTestMethodErrored|Errored|Failed|Skipped|ConsideredRisky|MarkedIncomplete $event): string {
+                        if ($event instanceof BeforeFirstTestMethodErrored) {
+                            return $event->testClassName();
+                        }
+
+                        return $this->getTestCaseLocation($event->test());
+                    },
+                    $events
+                )
+            )
+        );
+
+        $numberOfPassedTests = $result->numberOfTestsRun() - $numberOfNotPassedTests;
 
         return $this->stateGenerator->fromPhpUnitTestResult($numberOfPassedTests, $result);
     }

src/Logging/TeamCity/ServiceMessage.php

@@ -9,7 +9,7 @@ namespace Pest\Logging\TeamCity;
  */
 final class ServiceMessage
 {
-    private static int|null $flowId = null;
+    private static ?int $flowId = null;
 
     /**
      * @param  array<string, string|int|null>  $parameters
@@ -25,14 +25,14 @@ final class ServiceMessage
         $paramsToString = '';
 
         foreach ([...$this->parameters, 'flowId' => self::$flowId] as $key => $value) {
-            $value = self::escapeServiceMessage((string) $value);
+            $value = $this->escapeServiceMessage((string) $value);
             $paramsToString .= " $key='$value'";
         }
 
         return "##teamcity[$this->type$paramsToString]";
     }
 
-    public static function testSuiteStarted(string $name, string|null $location): self
+    public static function testSuiteStarted(string $name, ?string $location): self
     {
         return new self('testSuiteStarted', [
             'name' => $name,
@@ -127,7 +127,7 @@ final class ServiceMessage
         ]);
     }
 
-    private static function escapeServiceMessage(string $text): string
+    private function escapeServiceMessage(string $text): string
     {
         return str_replace(
             ['|', "'", "\n", "\r", ']', '['],

src/Logging/TeamCity/TeamCityLogger.php

@@ -16,6 +16,7 @@ use Pest\Logging\TeamCity\Subscriber\TestPreparedSubscriber;
 use Pest\Logging\TeamCity\Subscriber\TestSkippedSubscriber;
 use Pest\Logging\TeamCity\Subscriber\TestSuiteFinishedSubscriber;
 use Pest\Logging\TeamCity\Subscriber\TestSuiteStartedSubscriber;
+use PHPUnit\Event\Code\Test;
 use PHPUnit\Event\EventFacadeIsSealedException;
 use PHPUnit\Event\Facade;
 use PHPUnit\Event\Telemetry\Duration;
@@ -47,6 +48,11 @@ final class TeamCityLogger
 
     private bool $isSummaryTestCountPrinted = false;
 
+    /**
+     * @var array<string, bool>
+     */
+    private array $testEvents = [];
+
     /**
      * @throws EventFacadeIsSealedException
      * @throws UnknownSubscriberTypeException
@@ -54,7 +60,7 @@ final class TeamCityLogger
     public function __construct(
         private readonly OutputInterface $output,
         private readonly Converter $converter,
-        private readonly int|null $flowId,
+        private readonly ?int $flowId,
         private readonly bool $withoutDuration,
     ) {
         $this->registerSubscribers();
@@ -108,12 +114,14 @@ final class TeamCityLogger
 
     public function testSkipped(Skipped $event): void
     {
-        $message = ServiceMessage::testIgnored(
-            $this->converter->getTestCaseMethodName($event->test()),
-            'This test was ignored.'
-        );
+        $this->whenFirstEventForTest($event->test(), function () use ($event): void {
+            $message = ServiceMessage::testIgnored(
+                $this->converter->getTestCaseMethodName($event->test()),
+                'This test was ignored.'
+            );
 
-        $this->output($message);
+            $this->output($message);
+        });
     }
 
     /**
@@ -122,17 +130,19 @@ final class TeamCityLogger
      */
     public function testErrored(Errored $event): void
     {
-        $testName = $this->converter->getTestCaseMethodName($event->test());
-        $message = $this->converter->getExceptionMessage($event->throwable());
-        $details = $this->converter->getExceptionDetails($event->throwable());
+        $this->whenFirstEventForTest($event->test(), function () use ($event): void {
+            $testName = $this->converter->getTestCaseMethodName($event->test());
+            $message = $this->converter->getExceptionMessage($event->throwable());
+            $details = $this->converter->getExceptionDetails($event->throwable());
 
-        $message = ServiceMessage::testFailed(
-            $testName,
-            $message,
-            $details,
-        );
+            $message = ServiceMessage::testFailed(
+                $testName,
+                $message,
+                $details,
+            );
 
-        $this->output($message);
+            $this->output($message);
+        });
     }
 
     /**
@@ -141,28 +151,30 @@ final class TeamCityLogger
      */
     public function testFailed(Failed $event): void
     {
-        $testName = $this->converter->getTestCaseMethodName($event->test());
-        $message = $this->converter->getExceptionMessage($event->throwable());
-        $details = $this->converter->getExceptionDetails($event->throwable());
+        $this->whenFirstEventForTest($event->test(), function () use ($event): void {
+            $testName = $this->converter->getTestCaseMethodName($event->test());
+            $message = $this->converter->getExceptionMessage($event->throwable());
+            $details = $this->converter->getExceptionDetails($event->throwable());
 
-        if ($event->hasComparisonFailure()) {
-            $comparison = $event->comparisonFailure();
-            $message = ServiceMessage::comparisonFailure(
-                $testName,
-                $message,
-                $details,
-                $comparison->actual(),
-                $comparison->expected()
-            );
-        } else {
-            $message = ServiceMessage::testFailed(
-                $testName,
-                $message,
-                $details,
-            );
-        }
+            if ($event->hasComparisonFailure()) {
+                $comparison = $event->comparisonFailure();
+                $message = ServiceMessage::comparisonFailure(
+                    $testName,
+                    $message,
+                    $details,
+                    $comparison->actual(),
+                    $comparison->expected()
+                );
+            } else {
+                $message = ServiceMessage::testFailed(
+                    $testName,
+                    $message,
+                    $details,
+                );
+            }
 
-        $this->output($message);
+            $this->output($message);
+        });
     }
 
     /**
@@ -171,12 +183,14 @@ final class TeamCityLogger
      */
     public function testConsideredRisky(ConsideredRisky $event): void
     {
-        $message = ServiceMessage::testIgnored(
-            $this->converter->getTestCaseMethodName($event->test()),
-            $event->message()
-        );
+        $this->whenFirstEventForTest($event->test(), function () use ($event): void {
+            $message = ServiceMessage::testIgnored(
+                $this->converter->getTestCaseMethodName($event->test()),
+                $event->message()
+            );
 
-        $this->output($message);
+            $this->output($message);
+        });
     }
 
     public function testFinished(Finished $event): void
@@ -264,4 +278,14 @@ final class TeamCityLogger
 
         ServiceMessage::setFlowId($this->flowId);
     }
+
+    private function whenFirstEventForTest(Test $test, callable $callback): void
+    {
+        $testIdentifier = $this->converter->getTestCaseLocation($test);
+
+        if (! isset($this->testEvents[$testIdentifier])) {
+            $this->testEvents[$testIdentifier] = true;
+            $callback();
+        }
+    }
 }

src/Mixins/Expectation.php

@@ -9,17 +9,21 @@ use Closure;
 use DateTimeInterface;
 use Error;
 use InvalidArgumentException;
+use JsonSerializable;
 use Pest\Exceptions\InvalidExpectationValue;
 use Pest\Matchers\Any;
 use Pest\Support\Arr;
 use Pest\Support\Exporter;
 use Pest\Support\NullClosure;
+use Pest\TestSuite;
 use PHPUnit\Framework\Assert;
 use PHPUnit\Framework\Constraint\Constraint;
 use PHPUnit\Framework\ExpectationFailedException;
+use PHPUnit\Framework\TestCase;
 use ReflectionFunction;
 use ReflectionNamedType;
 use Throwable;
+use Traversable;
 
 /**
  * @internal
@@ -33,7 +37,7 @@ final class Expectation
     /**
      * The exporter instance, if any.
      */
-    private Exporter|null $exporter = null;
+    private ?Exporter $exporter = null;
 
     /**
      * Creates a new expectation.
@@ -794,6 +798,46 @@ final class Expectation
         return $this;
     }
 
+    /**
+     * Asserts that the value "stringable" matches the given snapshot..
+     *
+     * @return self<TValue>
+     */
+    public function toMatchSnapshot(string $message = ''): self
+    {
+        $string = match (true) {
+            is_string($this->value) => $this->value,
+            is_object($this->value) && method_exists($this->value, '__toString') => $this->value->__toString(),
+            is_object($this->value) && method_exists($this->value, 'toString') => $this->value->toString(),
+            $this->value instanceof \Illuminate\Testing\TestResponse => $this->value->getContent(), // @phpstan-ignore-line
+            is_array($this->value) => json_encode($this->value, JSON_THROW_ON_ERROR | JSON_PRETTY_PRINT),
+            $this->value instanceof Traversable => json_encode(iterator_to_array($this->value), JSON_THROW_ON_ERROR | JSON_PRETTY_PRINT),
+            $this->value instanceof JsonSerializable => json_encode($this->value->jsonSerialize(), JSON_THROW_ON_ERROR | JSON_PRETTY_PRINT),
+            is_object($this->value) && method_exists($this->value, 'toArray') => json_encode($this->value->toArray(), JSON_THROW_ON_ERROR | JSON_PRETTY_PRINT),
+            default => InvalidExpectationValue::expected('array|object|string'),
+        };
+
+        $testCase = TestSuite::getInstance()->test;
+        assert($testCase instanceof TestCase);
+        $snapshots = TestSuite::getInstance()->snapshots;
+
+        if ($snapshots->has($testCase, $string)) {
+            [$filename, $content] = $snapshots->get($testCase, $string);
+
+            Assert::assertSame(
+                $content,
+                $string,
+                $message === '' ? "Failed asserting that the string value matches its snapshot ($filename)." : $message
+            );
+        } else {
+            $filename = $snapshots->save($testCase, $string);
+
+            $testCase::markTestIncomplete('Snapshot created at ['.$filename.'].');
+        }
+
+        return $this;
+    }
+
     /**
      * Asserts that the value matches a regular expression.
      *
@@ -839,10 +883,10 @@ final class Expectation
     /**
      * Asserts that executing value throws an exception.
      *
-     * @param (Closure(Throwable): mixed)|string $exception
+     * @param  (Closure(Throwable): mixed)|string  $exception
      * @return self<TValue>
      */
-    public function toThrow(callable|string $exception, string $exceptionMessage = null, string $message = ''): self
+    public function toThrow(callable|string|Throwable $exception, string $exceptionMessage = null, string $message = ''): self
     {
         $callback = NullClosure::create();
 
@@ -864,6 +908,15 @@ final class Expectation
         try {
             ($this->value)();
         } catch (Throwable $e) {
+
+            if ($exception instanceof Throwable) {
+                expect($e)
+                    ->toBeInstanceOf($exception::class, $message)
+                    ->and($e->getMessage())->toBe($exceptionMessage ?? $exception->getMessage(), $message);
+
+                return $this;
+            }
+
             if (! class_exists($exception)) {
                 if ($e instanceof Error && $e->getMessage() === "Class \"$exception\" not found") {
                     Assert::assertTrue(true);
@@ -888,7 +941,7 @@ final class Expectation
 
         Assert::assertTrue(true);
 
-        if (! class_exists($exception)) {
+        if (! $exception instanceof Throwable && ! class_exists($exception)) {
             throw new ExpectationFailedException("Exception with message \"$exception\" not thrown.");
         }
 

src/PendingCalls/AfterEachCall.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Pest\PendingCalls;
 
 use Closure;
+use Pest\PendingCalls\Concerns\Describable;
 use Pest\Support\Backtrace;
 use Pest\Support\ChainableClosure;
 use Pest\Support\HigherOrderMessageCollection;
@@ -16,6 +17,8 @@ use Pest\TestSuite;
  */
 final class AfterEachCall
 {
+    use Describable;
+
     /**
      * The "afterEach" closure.
      */
@@ -37,6 +40,8 @@ final class AfterEachCall
         $this->closure = $closure instanceof Closure ? $closure : NullClosure::create();
 
         $this->proxies = new HigherOrderMessageCollection();
+
+        $this->describing = DescribeCall::describing();
     }
 
     /**
@@ -44,14 +49,23 @@ final class AfterEachCall
      */
     public function __destruct()
     {
+        $describing = $this->describing;
+
         $proxies = $this->proxies;
 
+        $afterEachTestCase = ChainableClosure::boundWhen(
+            fn (): bool => is_null($describing) || $this->__describing === $describing, // @phpstan-ignore-line
+            ChainableClosure::bound(fn () => $proxies->chain($this), $this->closure)->bindTo($this, self::class), // @phpstan-ignore-line
+        )->bindTo($this, self::class);
+
+        assert($afterEachTestCase instanceof Closure);
+
         $this->testSuite->afterEach->set(
             $this->filename,
-            ChainableClosure::from(function () use ($proxies): void {
-                $proxies->chain($this);
-            }, $this->closure)
+            $this,
+            $afterEachTestCase,
         );
+
     }
 
     /**

src/PendingCalls/BeforeEachCall.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Pest\PendingCalls;
 
 use Closure;
+use Pest\PendingCalls\Concerns\Describable;
 use Pest\Support\Backtrace;
 use Pest\Support\ChainableClosure;
 use Pest\Support\HigherOrderMessageCollection;
@@ -16,27 +17,37 @@ use Pest\TestSuite;
  */
 final class BeforeEachCall
 {
+    use Describable;
+
     /**
      * Holds the before each closure.
      */
-    private readonly \Closure $closure;
+    private readonly Closure $closure;
 
     /**
-     * The calls that should be proxied.
+     * The test call proxies.
      */
-    private readonly HigherOrderMessageCollection $proxies;
+    private readonly HigherOrderMessageCollection $testCallProxies;
+
+    /**
+     * The test case proxies.
+     */
+    private readonly HigherOrderMessageCollection $testCaseProxies;
 
     /**
      * Creates a new Pending Call.
      */
     public function __construct(
-        private readonly TestSuite $testSuite,
+        public readonly TestSuite $testSuite,
         private readonly string $filename,
         Closure $closure = null
     ) {
         $this->closure = $closure instanceof Closure ? $closure : NullClosure::create();
 
-        $this->proxies = new HigherOrderMessageCollection();
+        $this->testCallProxies = new HigherOrderMessageCollection();
+        $this->testCaseProxies = new HigherOrderMessageCollection();
+
+        $this->describing = DescribeCall::describing();
     }
 
     /**
@@ -44,13 +55,31 @@ final class BeforeEachCall
      */
     public function __destruct()
     {
-        $proxies = $this->proxies;
+        $describing = $this->describing;
+        $testCaseProxies = $this->testCaseProxies;
+
+        $beforeEachTestCall = function (TestCall $testCall) use ($describing): void {
+            if ($describing !== $this->describing) {
+                return;
+            }
+            if ($describing !== $testCall->describing) {
+                return;
+            }
+            $this->testCallProxies->chain($testCall);
+        };
+
+        $beforeEachTestCase = ChainableClosure::boundWhen(
+            fn (): bool => is_null($describing) || $this->__describing === $describing,  // @phpstan-ignore-line
+            ChainableClosure::bound(fn () => $testCaseProxies->chain($this), $this->closure)->bindTo($this, self::class), // @phpstan-ignore-line
+        )->bindTo($this, self::class);
+
+        assert($beforeEachTestCase instanceof Closure);
 
         $this->testSuite->beforeEach->set(
             $this->filename,
-            ChainableClosure::from(function () use ($proxies): void {
-                $proxies->chain($this);
-            }, $this->closure)
+            $this,
+            $beforeEachTestCall,
+            $beforeEachTestCase,
         );
     }
 
@@ -61,7 +90,13 @@ final class BeforeEachCall
      */
     public function __call(string $name, array $arguments): self
     {
-        $this->proxies
+        if (method_exists(TestCall::class, $name)) {
+            $this->testCallProxies->add(Backtrace::file(), Backtrace::line(), $name, $arguments);
+
+            return $this;
+        }
+
+        $this->testCaseProxies
             ->add(Backtrace::file(), Backtrace::line(), $name, $arguments);
 
         return $this;

src/PendingCalls/Concerns/Describable.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\PendingCalls\Concerns;
+
+/**
+ * @internal
+ */
+trait Describable
+{
+    public ?string $describing = null;
+}

src/PendingCalls/DescribeCall.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\PendingCalls;
+
+use Closure;
+use Pest\Support\Backtrace;
+use Pest\TestSuite;
+
+/**
+ * @internal
+ */
+final class DescribeCall
+{
+    /**
+     * The current describe call.
+     */
+    private static ?string $describing = null;
+
+    /**
+     * Creates a new Pending Call.
+     */
+    public function __construct(
+        public readonly TestSuite $testSuite,
+        public readonly string $filename,
+        public readonly string $description,
+        public readonly Closure $tests
+    ) {
+        //
+    }
+
+    /**
+     * What is the current describing.
+     */
+    public static function describing(): ?string
+    {
+        return self::$describing;
+    }
+
+    /**
+     * Creates the Call.
+     */
+    public function __destruct()
+    {
+        self::$describing = $this->description;
+
+        try {
+            ($this->tests)();
+        } finally {
+            self::$describing = null;
+        }
+    }
+
+    /**
+     * Dynamically calls methods on each test call.
+     *
+     * @param  array<int, mixed>  $arguments
+     */
+    public function __call(string $name, array $arguments): BeforeEachCall
+    {
+        $filename = Backtrace::file();
+
+        $beforeEachCall = new BeforeEachCall(TestSuite::getInstance(), $filename);
+
+        $beforeEachCall->describing = $this->description;
+
+        return $beforeEachCall->{$name}(...$arguments); // @phpstan-ignore-line
+    }
+}

src/PendingCalls/TestCall.php

@@ -5,11 +5,12 @@ declare(strict_types=1);
 namespace Pest\PendingCalls;
 
 use Closure;
-use InvalidArgumentException;
+use Pest\Exceptions\InvalidArgumentException;
 use Pest\Factories\Covers\CoversClass;
 use Pest\Factories\Covers\CoversFunction;
 use Pest\Factories\Covers\CoversNothing;
 use Pest\Factories\TestCaseMethodFactory;
+use Pest\PendingCalls\Concerns\Describable;
 use Pest\Plugins\Only;
 use Pest\Support\Backtrace;
 use Pest\Support\Exporter;
@@ -25,10 +26,12 @@ use PHPUnit\Framework\TestCase;
  */
 final class TestCall
 {
+    use Describable;
+
     /**
      * The Test Case Factory.
      */
-    private readonly TestCaseMethodFactory $testCaseMethod;
+    public readonly TestCaseMethodFactory $testCaseMethod;
 
     /**
      * If test call is descriptionLess.
@@ -40,12 +43,17 @@ final class TestCall
      */
     public function __construct(
         private readonly TestSuite $testSuite,
-        string $filename,
+        private readonly string $filename,
         string $description = null,
         Closure $closure = null
     ) {
         $this->testCaseMethod = new TestCaseMethodFactory($filename, $description, $closure);
+
         $this->descriptionLess = $description === null;
+
+        $this->describing = DescribeCall::describing();
+
+        $this->testSuite->beforeEach->get($this->filename)[0]($this);
     }
 
     /**
@@ -81,7 +89,7 @@ final class TestCall
     /**
      * Asserts that the test throws the given `$exceptionClass` when called if the given condition is true.
      *
-     * @param (callable(): bool)|bool $condition
+     * @param  (callable(): bool)|bool  $condition
      */
     public function throwsIf(callable|bool $condition, string|int $exception, string $exceptionMessage = null, int $exceptionCode = null): self
     {
@@ -167,7 +175,7 @@ final class TestCall
 
         $this->testCaseMethod
             ->chains
-            ->addWhen($condition, Backtrace::file(), Backtrace::line(), 'markTestSkipped', [$message]);
+            ->addWhen($condition, $this->filename, Backtrace::line(), 'markTestSkipped', [$message]);
 
         return $this;
     }
@@ -206,6 +214,20 @@ final class TestCall
             : $this;
     }
 
+    /**
+     * Repeats the current test the given number of times.
+     */
+    public function repeat(int $times): self
+    {
+        if ($times < 1) {
+            throw new InvalidArgumentException('The number of repetitions must be greater than 0.');
+        }
+
+        $this->testCaseMethod->repetitions = $times;
+
+        return $this;
+    }
+
     /**
      * Sets the test as "todo".
      */
@@ -224,7 +246,7 @@ final class TestCall
     public function covers(string ...$classesOrFunctions): self
     {
         foreach ($classesOrFunctions as $classOrFunction) {
-            $isClass = class_exists($classOrFunction);
+            $isClass = class_exists($classOrFunction) || trait_exists($classOrFunction);
             $isMethod = function_exists($classOrFunction);
 
             if (! $isClass && ! $isMethod) {
@@ -313,12 +335,14 @@ final class TestCall
     private function addChain(string $file, int $line, string $name, array $arguments = null): self
     {
         $exporter = Exporter::default();
+
         $this->testCaseMethod
             ->chains
             ->add($file, $line, $name, $arguments);
 
         if ($this->descriptionLess) {
             Exporter::default();
+
             if ($this->testCaseMethod->description !== null) {
                 $this->testCaseMethod->description .= ' → ';
             }
@@ -335,6 +359,11 @@ final class TestCall
      */
     public function __destruct()
     {
+        if (! is_null($this->describing)) {
+            $this->testCaseMethod->describing = $this->describing;
+            $this->testCaseMethod->description = sprintf('`%s` → %s', $this->describing, $this->testCaseMethod->description);
+        }
+
         $this->testSuite->tests->set($this->testCaseMethod);
     }
 }

src/PendingCalls/UsesCall.php

@@ -66,11 +66,11 @@ final class UsesCall
      */
     public function in(string ...$targets): void
     {
-        $targets = array_map(function ($path): string {
+        $targets = array_map(function (string $path): string {
             $startChar = DIRECTORY_SEPARATOR;
 
             if ('\\' === DIRECTORY_SEPARATOR || preg_match('~\A[A-Z]:(?![^/\\\\])~i', $path) > 0) {
-                $path = (string) preg_replace_callback('~^(?P<drive>[a-z]+:\\\)~i', fn ($match): string => strtolower($match['drive']), $path);
+                $path = (string) preg_replace_callback('~^(?P<drive>[a-z]+:\\\)~i', fn (array $match): string => strtolower($match['drive']), $path);
 
                 $startChar = strtolower((string) preg_replace('~^([a-z]+:\\\).*$~i', '$1', __DIR__));
             }
@@ -84,8 +84,10 @@ final class UsesCall
         }, $targets);
 
         $this->targets = array_reduce($targets, function (array $accumulator, string $target): array {
-            if (is_dir($target) || file_exists($target)) {
-                $accumulator[] = (string) realpath($target);
+            if (($matches = glob($target)) !== false) {
+                foreach ($matches as $file) {
+                    $accumulator[] = (string) realpath($file);
+                }
             }
 
             return $accumulator;

src/Pest.php

@@ -6,7 +6,7 @@ namespace Pest;
 
 function version(): string
 {
-    return '2.5.1';
+    return '2.10.1';
 }
 
 function testDirectory(string $file = ''): string

src/Plugins/Concerns/HandleArguments.php

@@ -44,6 +44,6 @@ trait HandleArguments
 
         unset($arguments[$argument]);
 
-        return array_flip($arguments);
+        return array_values(array_flip($arguments));
     }
 }

src/Plugins/Coverage.php

@@ -50,7 +50,7 @@ final class Coverage implements AddsOutput, HandlesArguments
      */
     public function handleArguments(array $originals): array
     {
-        $arguments = [...[''], ...array_values(array_filter($originals, function ($original): bool {
+        $arguments = [...[''], ...array_values(array_filter($originals, function (string $original): bool {
             foreach ([self::COVERAGE_OPTION, self::MIN_OPTION] as $option) {
                 if ($original === sprintf('--%s', $option)) {
                     return true;

src/Plugins/Help.php

@@ -107,22 +107,22 @@ final class Help implements HandlesArguments
                 'arg' => '--parallel',
                 'desc' => 'Run tests in parallel',
             ],
+            [
+                'arg' => '--update-snapshots',
+                'desc' => 'Update snapshots for tests using the "toMatchSnapshot" expectation',
+            ],
         ], ...$content['Execution']];
 
-        $content['Selection'] = array_merge([
-            [
-                'arg' => '--bail',
-                'desc' => 'Stop execution upon first not-passed test',
-            ],
-            [
-                'arg' => '--todos',
-                'desc' => 'Output to standard output the list of todos',
-            ],
-            [
-                'arg' => '--retry',
-                'desc' => 'Run non-passing tests first and stop execution upon first error or failure',
-            ],
-        ], $content['Selection']);
+        $content['Selection'] = [[
+            'arg' => '--bail',
+            'desc' => 'Stop execution upon first not-passed test',
+        ], [
+            'arg' => '--todos',
+            'desc' => 'Output to standard output the list of todos',
+        ], [
+            'arg' => '--retry',
+            'desc' => 'Run non-passing tests first and stop execution upon first error or failure',
+        ], ...$content['Selection']];
 
         $content['Reporting'] = [...$content['Reporting'], ...[
             [
@@ -131,16 +131,13 @@ final class Help implements HandlesArguments
             ],
         ]];
 
-        $content['Code Coverage'] = array_merge([
-            [
-                'arg' => '--coverage ',
-                'desc' => 'Generate code coverage report and output to standard output',
-            ],
-            [
-                'arg' => '--coverage --min',
-                'desc' => 'Set the minimum required coverage percentage, and fail if not met',
-            ],
-        ], $content['Code Coverage']);
+        $content['Code Coverage'] = [[
+            'arg' => '--coverage ',
+            'desc' => 'Generate code coverage report and output to standard output',
+        ], [
+            'arg' => '--coverage --min',
+            'desc' => 'Set the minimum required coverage percentage, and fail if not met',
+        ], ...$content['Code Coverage']];
 
         $content['Profiling'] = [
             [

src/Plugins/Init.php

@@ -60,13 +60,13 @@ final class Init implements HandlesArguments
 
         $this->init();
 
-        return array_values($arguments);
+        exit(0);
     }
 
     /**
      * Initializes the tests directory.
      */
-    private function init(): void
+    public function init(): void
     {
         $testsBaseDir = "{$this->testSuite->rootPath}/tests";
 
@@ -112,8 +112,6 @@ final class Init implements HandlesArguments
         View::render('components.new-line');
 
         (new Thanks($this->input, $this->output))();
-
-        exit(0);
     }
 
     /**

src/Plugins/Parallel.php

@@ -115,13 +115,13 @@ final class Parallel implements HandlesArguments
     private function runTestSuiteInParallel(array $arguments): int
     {
         $handlers = array_filter(
-            array_map(fn ($handler): object|string => Container::getInstance()->get($handler), self::HANDLERS),
-            fn ($handler): bool => $handler instanceof HandlesArguments,
+            array_map(fn (string $handler): object|string => Container::getInstance()->get($handler), self::HANDLERS),
+            fn (object|string $handler): bool => $handler instanceof HandlesArguments,
         );
 
         $filteredArguments = array_reduce(
             $handlers,
-            fn ($arguments, HandlesArguments $handler): array => $handler->handleArguments($arguments),
+            fn (array $arguments, HandlesArguments $handler): array => $handler->handleArguments($arguments),
             $arguments
         );
 
@@ -139,13 +139,13 @@ final class Parallel implements HandlesArguments
     private function runWorkerHandlers(array $arguments): array
     {
         $handlers = array_filter(
-            array_map(fn ($handler): object|string => Container::getInstance()->get($handler), self::HANDLERS),
-            fn ($handler): bool => $handler instanceof HandlersWorkerArguments,
+            array_map(fn (string $handler): object|string => Container::getInstance()->get($handler), self::HANDLERS),
+            fn (object|string $handler): bool => $handler instanceof HandlersWorkerArguments,
         );
 
         return array_reduce(
             $handlers,
-            fn ($arguments, HandlersWorkerArguments $handler): array => $handler->handleWorkerArguments($arguments),
+            fn (array $arguments, HandlersWorkerArguments $handler): array => $handler->handleWorkerArguments($arguments),
             $arguments
         );
     }

src/Plugins/Parallel/Handlers/Parallel.php

@@ -30,7 +30,7 @@ final class Parallel implements HandlesArguments
      */
     public function handleArguments(array $arguments): array
     {
-        $args = array_reduce(self::ARGS_TO_REMOVE, fn ($args, $arg): array => $this->popArgument($arg, $args), $arguments);
+        $args = array_reduce(self::ARGS_TO_REMOVE, fn (array $args, string $arg): array => $this->popArgument($arg, $args), $arguments);
 
         return $this->pushArgument('--runner='.WrapperRunner::class, $args);
     }

src/Plugins/Parallel/Paratest/ResultPrinter.php

@@ -12,20 +12,20 @@ use function fread;
 use function fseek;
 use function ftell;
 use function fwrite;
-use NunoMaduro\Collision\Adapters\Phpunit\State;
 use ParaTest\Options;
 use Pest\Plugins\Parallel\Support\CompactPrinter;
 use Pest\Support\StateGenerator;
 use PHPUnit\TestRunner\TestResult\TestResult;
 use PHPUnit\TextUI\Output\Printer;
-use function preg_replace;
 use SebastianBergmann\Timer\Duration;
 use SplFileInfo;
 use function strlen;
 use Symfony\Component\Console\Formatter\OutputFormatter;
 use Symfony\Component\Console\Output\OutputInterface;
 
-/** @internal */
+/**
+ * @internal
+ */
 final class ResultPrinter
 {
     /**
@@ -51,7 +51,7 @@ final class ResultPrinter
     /** @var resource|null */
     private $teamcityLogFileHandle;
 
-    /** @var array<string, int> */
+    /** @var array<non-empty-string, int> */
     private array $tailPositions;
 
     public function __construct(
@@ -74,6 +74,7 @@ final class ResultPrinter
                 if (str_starts_with($buffer, 'done [')) {
                     return;
                 }
+
                 $this->output->write(OutputFormatter::escape($buffer));
             }
 
@@ -93,9 +94,12 @@ final class ResultPrinter
         $this->teamcityLogFileHandle = $teamcityLogFileHandle;
     }
 
-    /** @param  array<int, SplFileInfo>  $teamcityFiles */
-    public function printFeedback(SplFileInfo $progressFile, array $teamcityFiles): void
-    {
+    /** @param  list<SplFileInfo>  $teamcityFiles */
+    public function printFeedback(
+        SplFileInfo $progressFile,
+        SplFileInfo $outputFile,
+        array $teamcityFiles
+    ): void {
         if ($this->options->needsTeamcity) {
             $teamcityProgress = $this->tailMultiple($teamcityFiles);
 
@@ -115,6 +119,15 @@ final class ResultPrinter
             return;
         }
 
+        $unexpectedOutput = $this->tail($outputFile);
+        if ($unexpectedOutput !== '') {
+            if (preg_match('/^T+$/', $unexpectedOutput) > 0) {
+                return;
+            }
+
+            $this->output->write($unexpectedOutput);
+        }
+
         $feedbackItems = $this->tail($progressFile);
         if ($feedbackItems === '') {
             return;
@@ -129,8 +142,8 @@ final class ResultPrinter
     }
 
     /**
-     * @param  array<int, SplFileInfo>  $teamcityFiles
-     * @param  array<int, SplFileInfo>  $testdoxFiles
+     * @param  list<SplFileInfo>  $teamcityFiles
+     * @param  list<SplFileInfo>  $testdoxFiles
      */
     public function printResults(TestResult $testResult, array $teamcityFiles, array $testdoxFiles, Duration $duration): void
     {
@@ -183,7 +196,7 @@ final class ResultPrinter
         $this->compactPrinter->descriptionItem($item);
     }
 
-    /** @param  array<int, SplFileInfo>  $files */
+    /** @param  list<SplFileInfo>  $files */
     private function tailMultiple(array $files): string
     {
         $content = '';
@@ -201,6 +214,7 @@ final class ResultPrinter
     private function tail(SplFileInfo $file): string
     {
         $path = $file->getPathname();
+        assert($path !== '');
         $handle = fopen($path, 'r');
         assert($handle !== false);
         $fseek = fseek($handle, $this->tailPositions[$path] ?? 0);

src/Plugins/Parallel/Paratest/WrapperRunner.php

@@ -23,6 +23,7 @@ use ParaTest\WrapperRunner\WrapperWorker;
 use Pest\Result;
 use Pest\TestSuite;
 use PHPUnit\Event\Facade as EventFacade;
+use PHPUnit\Event\TestRunner\WarningTriggered;
 use PHPUnit\Runner\CodeCoverage;
 use PHPUnit\TestRunner\TestResult\Facade as TestResultFacade;
 use PHPUnit\TestRunner\TestResult\TestResult;
@@ -48,36 +49,39 @@ final class WrapperRunner implements RunnerInterface
 
     private readonly Timer $timer;
 
-    /** @var array<int, string> */
+    /** @var list<non-empty-string> */
     private array $pending = [];
 
-    private int $exitCode = -1;
+    private int $exitcode = -1;
 
-    /** @var array<int,WrapperWorker> */
+    /** @var array<positive-int,WrapperWorker> */
     private array $workers = [];
 
     /** @var array<int,int> */
     private array $batches = [];
 
-    /** @var array<int, SplFileInfo> */
+    /** @var list<SplFileInfo> */
+    private array $unexpectedOutputFiles = [];
+
+    /** @var list<SplFileInfo> */
     private array $testresultFiles = [];
 
-    /** @var array<int, SplFileInfo> */
+    /** @var list<SplFileInfo> */
     private array $coverageFiles = [];
 
-    /** @var array<int, SplFileInfo> */
+    /** @var list<SplFileInfo> */
     private array $junitFiles = [];
 
-    /** @var array<int, SplFileInfo> */
+    /** @var list<SplFileInfo> */
     private array $teamcityFiles = [];
 
-    /** @var array<int, SplFileInfo> */
+    /** @var list<SplFileInfo> */
     private array $testdoxFiles = [];
 
-    /** @var array<int, string> */
+    /** @var non-empty-string[] */
     private readonly array $parameters;
 
-    private readonly CodeCoverageFilterRegistry $codeCoverageFilterRegistry;
+    private CodeCoverageFilterRegistry $codeCoverageFilterRegistry;
 
     public function __construct(
         private readonly Options $options,
@@ -86,11 +90,10 @@ final class WrapperRunner implements RunnerInterface
         $this->printer = new ResultPrinter($output, $options);
         $this->timer = new Timer();
 
-        $worker = realpath(
+        $wrapper = realpath(
             dirname(__DIR__, 4).DIRECTORY_SEPARATOR.'bin'.DIRECTORY_SEPARATOR.'worker.php',
         );
-
-        assert($worker !== false);
+        assert($wrapper !== false);
         $phpFinder = new PhpExecutableFinder();
         $phpBin = $phpFinder->find(false);
         assert($phpBin !== false);
@@ -101,7 +104,7 @@ final class WrapperRunner implements RunnerInterface
             $parameters = array_merge($parameters, $options->passthruPhp);
         }
 
-        $parameters[] = $worker;
+        $parameters[] = $wrapper;
 
         $this->parameters = $parameters;
         $this->codeCoverageFilterRegistry = new CodeCoverageFilterRegistry();
@@ -110,14 +113,15 @@ final class WrapperRunner implements RunnerInterface
     public function run(): int
     {
         $directory = dirname(__DIR__);
-        assert(strlen($directory) > 0);
+        assert($directory !== '');
         ExcludeList::addDirectory($directory);
-
         TestResultFacade::init();
-
         EventFacade::instance()->seal();
-
-        $suiteLoader = new SuiteLoader($this->options, $this->output, $this->codeCoverageFilterRegistry);
+        $suiteLoader = new SuiteLoader(
+            $this->options,
+            $this->output,
+            $this->codeCoverageFilterRegistry,
+        );
         $this->pending = $this->getTestFiles($suiteLoader);
 
         $result = TestResultFacade::result();
@@ -142,7 +146,7 @@ final class WrapperRunner implements RunnerInterface
     {
         $batchSize = $this->options->maxBatchSize;
 
-        while ($this->pending !== [] && $this->workers !== []) {
+        while (count($this->pending) > 0 && count($this->workers) > 0) {
             foreach ($this->workers as $token => $worker) {
                 if (! $worker->isRunning()) {
                     throw $worker->getWorkerCrashedException();
@@ -160,13 +164,11 @@ final class WrapperRunner implements RunnerInterface
                 }
 
                 if (
-                    $this->exitCode > 0
+                    $this->exitcode > 0
                     && $this->options->configuration->stopOnFailure()
                 ) {
                     $this->pending = [];
                 } elseif (($pending = array_shift($this->pending)) !== null) {
-                    $this->debug(sprintf('Assigning %s to worker %d', $pending, $token));
-
                     $worker->assign($pending);
                     $this->batches[$token]++;
                 }
@@ -178,9 +180,10 @@ final class WrapperRunner implements RunnerInterface
 
     private function flushWorker(WrapperWorker $worker): void
     {
-        $this->exitCode = max($this->exitCode, $worker->getExitCode());
+        $this->exitcode = max($this->exitcode, $worker->getExitCode());
         $this->printer->printFeedback(
             $worker->progressFile,
+            $worker->unexpectedOutputFile,
             $this->teamcityFiles,
         );
         $worker->reset();
@@ -189,10 +192,10 @@ final class WrapperRunner implements RunnerInterface
     private function waitForAllToFinish(): void
     {
         $stopped = [];
-        while ($this->workers !== []) {
+        while (count($this->workers) > 0) {
             foreach ($this->workers as $index => $worker) {
                 if ($worker->isRunning()) {
-                    if (! array_key_exists($index, $stopped) && $worker->isFree()) {
+                    if (! isset($stopped[$index]) && $worker->isFree()) {
                         $worker->stop();
                         $stopped[$index] = true;
                     }
@@ -212,22 +215,19 @@ final class WrapperRunner implements RunnerInterface
         }
     }
 
+    /** @param  positive-int  $token */
     private function startWorker(int $token): WrapperWorker
     {
-        /** @var array<non-empty-string> $parameters */
-        $parameters = $this->parameters;
-
         $worker = new WrapperWorker(
             $this->output,
             $this->options,
-            $parameters,
+            $this->parameters,
             $token,
         );
-
         $worker->start();
-
         $this->batches[$token] = 0;
 
+        $this->unexpectedOutputFiles[] = $worker->unexpectedOutputFile;
         $this->testresultFiles[] = $worker->testresultFile;
 
         if (isset($worker->junitFile)) {
@@ -318,7 +318,10 @@ final class WrapperRunner implements RunnerInterface
             $testResultSum->testTriggeredPhpunitErrorEvents(),
             $testResultSum->testTriggeredPhpunitWarningEvents(),
             $testResultSum->testRunnerTriggeredDeprecationEvents(),
-            array_values(array_filter($testResultSum->testRunnerTriggeredWarningEvents(), fn ($event): bool => ! str_contains($event->message(), 'No tests found'))),
+            array_values(array_filter(
+                $testResultSum->testRunnerTriggeredWarningEvents(),
+                fn (WarningTriggered $event): bool => ! str_contains($event->message(), 'No tests found')
+            )),
         );
 
         $this->printer->printResults(
@@ -330,15 +333,16 @@ final class WrapperRunner implements RunnerInterface
         $this->generateCodeCoverageReports();
         $this->generateLogs();
 
-        $exitCode = Result::exitCode($this->options->configuration, $testResultSum);
+        $exitcode = Result::exitCode($this->options->configuration, $testResultSum);
 
+        $this->clearFiles($this->unexpectedOutputFiles);
         $this->clearFiles($this->testresultFiles);
         $this->clearFiles($this->coverageFiles);
         $this->clearFiles($this->junitFiles);
         $this->clearFiles($this->teamcityFiles);
         $this->clearFiles($this->testdoxFiles);
 
-        return $exitCode;
+        return $exitcode;
     }
 
     private function generateCodeCoverageReports(): void
@@ -348,10 +352,11 @@ final class WrapperRunner implements RunnerInterface
         }
 
         $coverageManager = new CodeCoverage();
-
-        // @phpstan-ignore-next-line
-        is_bool(true) && $coverageManager->init($this->options->configuration, $this->codeCoverageFilterRegistry, true);
-
+        $coverageManager->init(
+            $this->options->configuration,
+            $this->codeCoverageFilterRegistry,
+            false,
+        );
         $coverageMerger = new CoverageMerger($coverageManager->codeCoverage());
         foreach ($this->coverageFiles as $coverageFile) {
             $coverageMerger->addCoverageFromFile($coverageFile);
@@ -376,7 +381,7 @@ final class WrapperRunner implements RunnerInterface
         );
     }
 
-    /** @param  array<int, SplFileInfo>  $files */
+    /** @param  list<SplFileInfo>  $files */
     private function clearFiles(array $files): void
     {
         foreach ($files as $file) {
@@ -391,31 +396,19 @@ final class WrapperRunner implements RunnerInterface
     /**
      * Returns the test files to be executed.
      *
-     * @return array<int, string>
+     * @return array<int, non-empty-string>
      */
     private function getTestFiles(SuiteLoader $suiteLoader): array
     {
-        $this->debug(sprintf('Found %d test file%s', count($suiteLoader->files), count($suiteLoader->files) === 1 ? '' : 's'));
-
-        /** @var array<string, string> $files */
-        $files = $suiteLoader->files;
-
-        return [
+        /** @var array<string, non-empty-string> $files */
+        $files = [
             ...array_values(array_filter(
-                $files,
+                $suiteLoader->tests,
                 fn (string $filename): bool => ! str_ends_with($filename, "eval()'d code")
             )),
             ...TestSuite::getInstance()->tests->getFilenames(),
         ];
-    }
 
-    /**
-     * Prints a debug message.
-     */
-    private function debug(string $message): void
-    {
-        if ($this->options->verbose) {
-            $this->output->writeln("  <fg=blue>{$message}</>  ");
-        }
+        return $files; // @phpstan-ignore-line
     }
 }

src/Plugins/Snapshot.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins;
+
+use Pest\Contracts\Plugins\HandlesArguments;
+use Pest\Exceptions\InvalidOption;
+use Pest\TestSuite;
+
+/**
+ * @internal
+ */
+final class Snapshot implements HandlesArguments
+{
+    use Concerns\HandleArguments;
+
+    /**
+     * {@inheritDoc}
+     */
+    public function handleArguments(array $arguments): array
+    {
+        if (! $this->hasArgument('--update-snapshots', $arguments)) {
+            return $arguments;
+        }
+
+        if ($this->hasArgument('--parallel', $arguments)) {
+            throw new InvalidOption('The [--update-snapshots] option is not supported when running in parallel.');
+        }
+
+        TestSuite::getInstance()->snapshots->flush();
+
+        return $this->popArgument('--update-snapshots', $arguments);
+    }
+}

src/Plugins/Verbose.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins;
+
+use Pest\Contracts\Plugins\HandlesArguments;
+
+/**
+ * @internal
+ */
+final class Verbose implements HandlesArguments
+{
+    use Concerns\HandleArguments;
+
+    /**
+     * The list of verbosity levels.
+     */
+    private const VERBOSITY_LEVELS = ['v', 'vv', 'vvv', 'q'];
+
+    /**
+     * {@inheritDoc}
+     */
+    public function handleArguments(array $arguments): array
+    {
+        foreach (self::VERBOSITY_LEVELS as $level) {
+            if ($this->hasArgument('-'.$level, $arguments)) {
+                $arguments = $this->popArgument('-'.$level, $arguments);
+            }
+        }
+
+        if ($this->hasArgument('--quiet', $arguments)) {
+            return $this->popArgument('--quiet', $arguments);
+        }
+
+        return $arguments;
+    }
+}

src/Repositories/AfterEachRepository.php

@@ -6,7 +6,7 @@ namespace Pest\Repositories;
 
 use Closure;
 use Mockery;
-use Pest\Exceptions\AfterEachAlreadyExist;
+use Pest\PendingCalls\AfterEachCall;
 use Pest\Support\ChainableClosure;
 use Pest\Support\NullClosure;
 
@@ -23,13 +23,18 @@ final class AfterEachRepository
     /**
      * Sets a after each closure.
      */
-    public function set(string $filename, Closure $closure): void
+    public function set(string $filename, AfterEachCall $afterEachCall, Closure $afterEachTestCase): void
     {
         if (array_key_exists($filename, $this->state)) {
-            throw new AfterEachAlreadyExist($filename);
+            $fromAfterEachTestCase = $this->state[$filename];
+
+            $afterEachTestCase = ChainableClosure::bound($fromAfterEachTestCase, $afterEachTestCase)
+                ->bindTo($afterEachCall, $afterEachCall::class);
         }
 
-        $this->state[$filename] = $closure;
+        assert($afterEachTestCase instanceof Closure);
+
+        $this->state[$filename] = $afterEachTestCase;
     }
 
     /**
@@ -39,7 +44,7 @@ final class AfterEachRepository
     {
         $afterEach = $this->state[$filename] ?? NullClosure::create();
 
-        return ChainableClosure::from(function (): void {
+        return ChainableClosure::bound(function (): void {
             if (class_exists(Mockery::class)) {
                 if ($container = Mockery::getContainer()) {
                     /* @phpstan-ignore-next-line */

src/Repositories/BeforeAllRepository.php

@@ -5,7 +5,7 @@ declare(strict_types=1);
 namespace Pest\Repositories;
 
 use Closure;
-use Pest\Exceptions\BeforeEachAlreadyExist;
+use Pest\Exceptions\BeforeAllAlreadyExist;
 use Pest\Support\NullClosure;
 use Pest\Support\Reflection;
 
@@ -39,7 +39,7 @@ final class BeforeAllRepository
         $filename = Reflection::getFileNameFromClosure($closure);
 
         if (array_key_exists($filename, $this->state)) {
-            throw new BeforeEachAlreadyExist($filename);
+            throw new BeforeAllAlreadyExist($filename);
         }
 
         $this->state[$filename] = $closure;

src/Repositories/BeforeEachRepository.php

@@ -5,7 +5,8 @@ declare(strict_types=1);
 namespace Pest\Repositories;
 
 use Closure;
-use Pest\Exceptions\BeforeEachAlreadyExist;
+use Pest\PendingCalls\BeforeEachCall;
+use Pest\Support\ChainableClosure;
 use Pest\Support\NullClosure;
 
 /**
@@ -14,27 +15,38 @@ use Pest\Support\NullClosure;
 final class BeforeEachRepository
 {
     /**
-     * @var array<string, Closure>
+     * @var array<string, array{0: Closure, 1: Closure}>
      */
     private array $state = [];
 
     /**
      * Sets a before each closure.
      */
-    public function set(string $filename, Closure $closure): void
+    public function set(string $filename, BeforeEachCall $beforeEachCall, Closure $beforeEachTestCall, Closure $beforeEachTestCase): void
     {
         if (array_key_exists($filename, $this->state)) {
-            throw new BeforeEachAlreadyExist($filename);
+            [$fromBeforeEachTestCall, $fromBeforeEachTestCase] = $this->state[$filename];
+
+            $beforeEachTestCall = ChainableClosure::unbound($fromBeforeEachTestCall, $beforeEachTestCall);
+            $beforeEachTestCase = ChainableClosure::bound($fromBeforeEachTestCase, $beforeEachTestCase)->bindTo($beforeEachCall, $beforeEachCall::class);
+            assert($beforeEachTestCase instanceof Closure);
         }
 
-        $this->state[$filename] = $closure;
+        $this->state[$filename] = [$beforeEachTestCall, $beforeEachTestCase];
     }
 
     /**
      * Gets a before each closure by the given filename.
+     *
+     * @return array{0: Closure, 1: Closure}
      */
-    public function get(string $filename): Closure
+    public function get(string $filename): array
     {
-        return $this->state[$filename] ?? NullClosure::create();
+        $closures = $this->state[$filename] ?? [];
+
+        return [
+            $closures[0] ?? NullClosure::create(),
+            $closures[1] ?? NullClosure::create(),
+        ];
     }
 }

src/Repositories/DatasetsRepository.php

@@ -66,11 +66,11 @@ final class DatasetsRepository
     }
 
     /**
-     * @return Closure|array<int|string, mixed>|never
+     * @return Closure|array<int|string, mixed>
      *
      * @throws ShouldNotHappen
      */
-    public static function get(string $filename, string $description)
+    public static function get(string $filename, string $description): Closure|array
     {
         $dataset = self::$withs[$filename.self::SEPARATOR.$description];
 
@@ -89,7 +89,7 @@ final class DatasetsRepository
      * @param  array<Closure|iterable<int|string, mixed>|string>  $dataset
      * @return array<string, mixed>|null
      */
-    public static function resolve(array $dataset, string $currentTestFile): array|null
+    public static function resolve(array $dataset, string $currentTestFile): ?array
     {
         if ($dataset === []) {
             return null;
@@ -138,7 +138,7 @@ final class DatasetsRepository
 
     /**
      * @param  array<Closure|iterable<int|string, mixed>|string>  $datasets
-     * @return array<array<mixed>>
+     * @return array<int, array<int, mixed>>
      */
     private static function processDatasets(array $datasets, string $currentTestFile): array
     {
@@ -193,7 +193,7 @@ final class DatasetsRepository
 
         $closestScopeDatasetKey = array_reduce(
             array_keys($matchingDatasets),
-            fn ($keyA, $keyB) => $keyA !== null && strlen((string) $keyA) > strlen($keyB) ? $keyA : $keyB
+            fn (string|int|null $keyA, string|int|null $keyB): string|int|null => $keyA !== null && strlen((string) $keyA) > strlen((string) $keyB) ? $keyA : $keyB
         );
 
         if ($closestScopeDatasetKey === null) {

src/Repositories/SnapshotRepository.php

@@ -0,0 +1,135 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Repositories;
+
+use Pest\Exceptions\ShouldNotHappen;
+use Pest\Support\Str;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @internal
+ */
+final class SnapshotRepository
+{
+    /**
+     * Creates a snapshot repository instance.
+     */
+    public function __construct(
+        readonly private string $testsPath,
+        readonly private string $snapshotsPath,
+    ) {
+    }
+
+    /**
+     * Checks if the snapshot exists.
+     */
+    public function has(TestCase $testCase, string $description): bool
+    {
+        [$filename, $description] = $this->getFilenameAndDescription($testCase);
+
+        return file_exists($this->getSnapshotFilename($filename, $description));
+    }
+
+    /**
+     * Gets the snapshot.
+     *
+     * @return array{0: string, 1: string}
+     *
+     * @throws ShouldNotHappen
+     */
+    public function get(TestCase $testCase, string $description): array
+    {
+        [$filename, $description] = $this->getFilenameAndDescription($testCase);
+
+        $contents = file_get_contents($snapshotFilename = $this->getSnapshotFilename($filename, $description));
+
+        if ($contents === false) {
+            throw ShouldNotHappen::fromMessage('Snapshot file could not be read.');
+        }
+
+        $snapshot = str_replace(dirname($this->testsPath).'/', '', $snapshotFilename);
+
+        return [$snapshot, $contents];
+    }
+
+    /**
+     * Saves the given snapshot for the given test case.
+     */
+    public function save(TestCase $testCase, string $snapshot): string
+    {
+        [$filename, $description] = $this->getFilenameAndDescription($testCase);
+
+        $snapshotFilename = $this->getSnapshotFilename($filename, $description);
+
+        if (! file_exists(dirname($snapshotFilename))) {
+            mkdir(dirname($snapshotFilename), 0755, true);
+        }
+
+        file_put_contents($snapshotFilename, $snapshot);
+
+        return str_replace(dirname($this->testsPath).'/', '', $snapshotFilename);
+    }
+
+    /**
+     * Flushes the snapshots.
+     */
+    public function flush(): void
+    {
+        $absoluteSnapshotsPath = $this->testsPath.'/'.$this->snapshotsPath;
+
+        $deleteDirectory = function (string $path) use (&$deleteDirectory): void {
+            if (file_exists($path)) {
+                $scannedDir = scandir($path);
+                assert(is_array($scannedDir));
+
+                $files = array_diff($scannedDir, ['.', '..']);
+
+                foreach ($files as $file) {
+                    if (is_dir($path.'/'.$file)) {
+                        $deleteDirectory($path.'/'.$file);
+                    } else {
+                        unlink($path.'/'.$file);
+                    }
+                }
+
+                rmdir($path);
+            }
+        };
+
+        if (file_exists($absoluteSnapshotsPath)) {
+            $deleteDirectory($absoluteSnapshotsPath);
+        }
+    }
+
+    /**
+     * Gets the snapshot's "filename" and "description".
+     *
+     * @return array{0: string, 1: string}
+     */
+    private function getFilenameAndDescription(TestCase $testCase): array
+    {
+        $filename = (fn () => self::$__filename)->call($testCase, $testCase::class); // @phpstan-ignore-line
+
+        $description = str_replace('__pest_evaluable_', '', $testCase->name());
+        $datasetAsString = str_replace('__pest_evaluable_', '', Str::evaluable($testCase->dataSetAsStringWithData()));
+
+        $description = str_replace(' ', '_', $description.$datasetAsString);
+
+        return [$filename, $description];
+    }
+
+    /**
+     * Gets the snapshot's "filename".
+     */
+    private function getSnapshotFilename(string $filename, string $description): string
+    {
+        $relativePath = str_replace($this->testsPath, '', $filename);
+
+        // remove extension from filename
+        $relativePath = substr($relativePath, 0, (int) strrpos($relativePath, '.'));
+
+        return sprintf('%s/%s.snap', $this->testsPath.'/'.$this->snapshotsPath.$relativePath, $description);
+    }
+}

src/Result.php

@@ -39,15 +39,13 @@ final class Result
      */
     public static function exitCode(Configuration $configuration, TestResult $result): int
     {
-        $returnCode = self::FAILURE_EXIT;
-
         if ($result->wasSuccessfulIgnoringPhpunitWarnings()
             && ! $result->hasTestTriggeredPhpunitWarningEvents()) {
-            $returnCode = self::SUCCESS_EXIT;
+            return self::SUCCESS_EXIT;
         }
 
         if ($configuration->failOnEmptyTestSuite() && $result->numberOfTests() === 0) {
-            $returnCode = self::FAILURE_EXIT;
+            return self::FAILURE_EXIT;
         }
 
         if ($result->wasSuccessfulIgnoringPhpunitWarnings()) {
@@ -76,6 +74,6 @@ final class Result
             return self::EXCEPTION_EXIT;
         }
 
-        return $returnCode;
+        return self::FAILURE_EXIT;
     }
 }

src/Support/Backtrace.php

@@ -78,9 +78,7 @@ final class Backtrace
      */
     public static function file(): string
     {
-        $trace = debug_backtrace(self::BACKTRACE_OPTIONS)[1];
-
-        assert(array_key_exists(self::FILE, $trace));
+        $trace = self::backtrace();
 
         return $trace[self::FILE];
     }
@@ -90,9 +88,7 @@ final class Backtrace
      */
     public static function dirname(): string
     {
-        $trace = debug_backtrace(self::BACKTRACE_OPTIONS)[1];
-
-        assert(array_key_exists(self::FILE, $trace));
+        $trace = self::backtrace();
 
         return dirname($trace[self::FILE]);
     }
@@ -102,10 +98,30 @@ final class Backtrace
      */
     public static function line(): int
     {
-        $trace = debug_backtrace(self::BACKTRACE_OPTIONS)[1];
+        $trace = self::backtrace();
 
-        assert(array_key_exists('line', $trace));
+        return $trace['line'] ?? 0;
+    }
 
-        return $trace['line'];
+    /**
+     * @return array{function: string, line?: int, file: string, class?: class-string, type?: string, args?: mixed[], object?: object}
+     */
+    private static function backtrace(): array
+    {
+        $backtrace = debug_backtrace(self::BACKTRACE_OPTIONS);
+
+        foreach ($backtrace as $trace) {
+            if (! isset($trace['file'])) {
+                continue;
+            }
+
+            if (str_contains($trace['file'], 'pest'.DIRECTORY_SEPARATOR.'src')) {
+                continue;
+            }
+
+            return $trace;
+        }
+
+        throw ShouldNotHappen::fromMessage('Backtrace not found.');
     }
 }

src/Support/ChainableClosure.php

@@ -13,9 +13,25 @@ use Pest\Exceptions\ShouldNotHappen;
 final class ChainableClosure
 {
     /**
-     * Calls the given `$closure` and chains the `$next` closure.
+     * Calls the given `$closure` when the given condition is true, "bound" to the same object.
      */
-    public static function from(Closure $closure, Closure $next): Closure
+    public static function boundWhen(Closure $condition, Closure $next): Closure
+    {
+        return function () use ($condition, $next): void {
+            if (! is_object($this)) { // @phpstan-ignore-line
+                throw ShouldNotHappen::fromMessage('$this not bound to chainable closure.');
+            }
+
+            if (\Pest\Support\Closure::bind($condition, $this, self::class)(...func_get_args())) {
+                \Pest\Support\Closure::bind($next, $this, self::class)(...func_get_args());
+            }
+        };
+    }
+
+    /**
+     * Calls the given `$closure` and chains the `$next` closure, "bound" to the same object.
+     */
+    public static function bound(Closure $closure, Closure $next): Closure
     {
         return function () use ($closure, $next): void {
             if (! is_object($this)) { // @phpstan-ignore-line
@@ -28,9 +44,20 @@ final class ChainableClosure
     }
 
     /**
-     * Call the given static `$closure` and chains the `$next` closure.
+     * Calls the given `$closure` and chains the `$next` closure, "unbound" of any object.
      */
-    public static function fromStatic(Closure $closure, Closure $next): Closure
+    public static function unbound(Closure $closure, Closure $next): Closure
+    {
+        return function () use ($closure, $next): void {
+            $closure(...func_get_args());
+            $next(...func_get_args());
+        };
+    }
+
+    /**
+     * Call the given static `$closure` and chains the `$next` closure, "bound" to the same object statically.
+     */
+    public static function boundStatically(Closure $closure, Closure $next): Closure
     {
         return static function () use ($closure, $next): void {
             \Pest\Support\Closure::bind($closure, null, self::class)(...func_get_args());

src/Support/Closure.php

@@ -18,7 +18,7 @@ final class Closure
      *
      * @throws ShouldNotHappen
      */
-    public static function bind(BaseClosure|null $closure, ?object $newThis, object|string|null $newScope = 'static'): BaseClosure
+    public static function bind(?BaseClosure $closure, ?object $newThis, object|string|null $newScope = 'static'): BaseClosure
     {
         if ($closure == null) {
             throw ShouldNotHappen::fromMessage('Could not bind null closure.');

src/Support/Coverage.php

@@ -159,10 +159,11 @@ final class Coverage
      * ['11', '20..25', '50', '60..80'];
      * ```
      *
+     *
      * @param  File  $file
      * @return array<int, string>
      */
-    public static function getMissingCoverage($file): array
+    public static function getMissingCoverage(mixed $file): array
     {
         $shouldBeNewLine = true;
 

src/Support/ExceptionTrace.php

@@ -18,11 +18,9 @@ final class ExceptionTrace
     /**
      * Ensures the given closure reports the good execution context.
      *
-     * @return mixed
-     *
      * @throws Throwable
      */
-    public static function ensure(Closure $closure)
+    public static function ensure(Closure $closure): mixed
     {
         try {
             return $closure();
@@ -32,7 +30,7 @@ final class ExceptionTrace
 
                 $message = str_replace(self::UNDEFINED_METHOD, 'Call to undefined method ', $message);
 
-                if (class_exists($class) && count(class_parents($class)) > 0 && array_values(class_parents($class))[0] === TestCase::class) {
+                if (class_exists((string) $class) && (is_countable(class_parents($class)) ? count(class_parents($class)) : 0) > 0 && array_values(class_parents($class))[0] === TestCase::class) { // @phpstan-ignore-line
                     $message .= '. Did you forget to use the [uses()] function? Read more at: https://pestphp.com/docs/configuring-tests';
                 }
 

src/Support/ExpectationPipeline.php

@@ -84,6 +84,6 @@ final class ExpectationPipeline
      */
     public function carry(): Closure
     {
-        return fn ($stack, $pipe): Closure => fn () => $pipe($stack, ...$this->passables);
+        return fn (mixed $stack, callable $pipe): Closure => fn () => $pipe($stack, ...$this->passables);
     }
 }

src/Support/Exporter.php

@@ -77,6 +77,12 @@ final class Exporter
      */
     public function shortenedExport(mixed $value): string
     {
-        return (string) preg_replace(['#\.{3}#', '#\\\n\s*#'], ['…'], $this->exporter->shortenedExport($value));
+        $map = [
+            '#\.{3}#' => '…',
+            '#\\\n\s*#' => '',
+            '# Object \(…\)#' => '',
+        ];
+
+        return (string) preg_replace(array_keys($map), array_values($map), $this->exporter->shortenedExport($value));
     }
 }

src/Support/HigherOrderCallables.php

@@ -25,7 +25,7 @@ final class HigherOrderCallables
      *
      * Create a new expectation. Callable values will be executed prior to returning the new expectation.
      *
-     * @param (Closure():TValue)|TValue $value
+     * @param  (Closure():TValue)|TValue  $value
      * @return Expectation<TValue>
      */
     public function expect(mixed $value): Expectation

src/Support/HigherOrderMessage.php

@@ -62,7 +62,7 @@ final class HigherOrderMessage
             Reflection::setPropertyValue($throwable, 'file', $this->filename);
             Reflection::setPropertyValue($throwable, 'line', $this->line);
 
-            if ($throwable->getMessage() === self::getUndefinedMethodMessage($target, $this->name)) {
+            if ($throwable->getMessage() === $this->getUndefinedMethodMessage($target, $this->name)) {
                 /** @var ReflectionClass<TValue> $reflection */
                 $reflection = new ReflectionClass($target);
                 /* @phpstan-ignore-next-line */
@@ -94,7 +94,7 @@ final class HigherOrderMessage
         return in_array($this->name, get_class_methods(HigherOrderCallables::class), true);
     }
 
-    private static function getUndefinedMethodMessage(object $target, string $methodName): string
+    private function getUndefinedMethodMessage(object $target, string $methodName): string
     {
         if (\PHP_MAJOR_VERSION >= 8) {
             return sprintf(self::UNDEFINED_METHOD, sprintf('%s::%s()', $target::class, $methodName));

src/Support/Reflection.php

@@ -24,9 +24,8 @@ final class Reflection
      * Calls the given method with args on the given object.
      *
      * @param  array<int, mixed>  $args
-     * @return mixed
      */
-    public static function call(object $object, string $method, array $args = [])
+    public static function call(object $object, string $method, array $args = []): mixed
     {
         $reflectionClass = new ReflectionClass($object);
 
@@ -53,9 +52,8 @@ final class Reflection
      * Bind a callable to the TestCase and return the result.
      *
      * @param  array<int, mixed>  $args
-     * @return mixed
      */
-    public static function bindCallable(callable $callable, array $args = [])
+    public static function bindCallable(callable $callable, array $args = []): mixed
     {
         return Closure::fromCallable($callable)->bindTo(TestSuite::getInstance()->test)(...$args);
     }
@@ -63,10 +61,8 @@ final class Reflection
     /**
      * Bind a callable to the TestCase and return the result,
      * passing in the current dataset values as arguments.
-     *
-     * @return mixed
      */
-    public static function bindCallableWithData(callable $callable)
+    public static function bindCallableWithData(callable $callable): mixed
     {
         $test = TestSuite::getInstance()->test;
 
@@ -87,10 +83,8 @@ final class Reflection
 
     /**
      * Gets the property value from of the given object.
-     *
-     * @return mixed
      */
-    public static function getPropertyValue(object $object, string $property)
+    public static function getPropertyValue(object $object, string $property): mixed
     {
         $reflectionClass = new ReflectionClass($object);
 
@@ -206,10 +200,7 @@ final class Reflection
         return $arguments;
     }
 
-    /**
-     * @return mixed
-     */
-    public static function getFunctionVariable(Closure $function, string $key)
+    public static function getFunctionVariable(Closure $function, string $key): mixed
     {
         return (new ReflectionFunction($function))->getStaticVariables()[$key] ?? null;
     }

src/TestCaseFilters/GitDirtyTestCaseFilter.php

@@ -16,7 +16,7 @@ final class GitDirtyTestCaseFilter implements TestCaseFilter
     /**
      * @var string[]|null
      */
-    private array|null $changedFiles = null;
+    private ?array $changedFiles = null;
 
     public function __construct(private readonly string $projectRoot)
     {
@@ -59,13 +59,18 @@ final class GitDirtyTestCaseFilter implements TestCaseFilter
             $dirtyFiles[substr($dirtyFile, 3)] = trim(substr($dirtyFile, 0, 3));
         }
 
-        $dirtyFiles = array_filter($dirtyFiles, fn ($status): bool => $status !== 'D');
+        $dirtyFiles = array_filter($dirtyFiles, fn (string $status): bool => $status !== 'D');
 
-        $dirtyFiles = array_map(fn ($file, $status): string => in_array($status, ['R', 'RM'], true) ? explode(' -> ', $file)[1] : $file, array_keys($dirtyFiles), $dirtyFiles);
+        $dirtyFiles = array_map(
+            fn (string $file, string $status): string => in_array($status, ['R', 'RM'], true)
+                ? explode(' -> ', $file)[1]
+                : $file, array_keys($dirtyFiles), $dirtyFiles,
+        );
 
         $dirtyFiles = array_filter(
             $dirtyFiles,
-            fn ($file): bool => str_starts_with('.'.DIRECTORY_SEPARATOR.$file, TestSuite::getInstance()->testPath) || str_starts_with($file, TestSuite::getInstance()->testPath)
+            fn (string $file): bool => str_starts_with('.'.DIRECTORY_SEPARATOR.$file, TestSuite::getInstance()->testPath)
+                || str_starts_with($file, TestSuite::getInstance()->testPath)
         );
 
         $dirtyFiles = array_values($dirtyFiles);

src/TestSuite.php

@@ -9,6 +9,7 @@ use Pest\Repositories\AfterAllRepository;
 use Pest\Repositories\AfterEachRepository;
 use Pest\Repositories\BeforeAllRepository;
 use Pest\Repositories\BeforeEachRepository;
+use Pest\Repositories\SnapshotRepository;
 use Pest\Repositories\TestRepository;
 use PHPUnit\Framework\TestCase;
 
@@ -47,6 +48,11 @@ final class TestSuite
      */
     public AfterAllRepository $afterAll;
 
+    /**
+     * Holds the snapshots repository.
+     */
+    public SnapshotRepository $snapshots;
+
     /**
      * Holds the root path.
      */
@@ -69,8 +75,11 @@ final class TestSuite
         $this->tests = new TestRepository();
         $this->afterEach = new AfterEachRepository();
         $this->afterAll = new AfterAllRepository();
-
         $this->rootPath = (string) realpath($rootPath);
+        $this->snapshots = new SnapshotRepository(
+            implode(DIRECTORY_SEPARATOR, [$this->rootPath, $this->testPath]),
+            implode(DIRECTORY_SEPARATOR, ['.pest', 'snapshots']),
+        );
     }
 
     /**

tests/.pest/snapshots/Features/Expect/toMatchSnapshot/_within_describe__→_pass_with_dataset_with_data_set____my_datas_set_value______my_datas_set_value__.snap

@@ -0,0 +1,7 @@
+    <div class="container">
+        <div class="row">
+            <div class="col-md-12">
+                <h1>Snapshot</h1>
+            </div>
+        </div>
+    </div>

tests/.pest/snapshots/Features/Expect/toMatchSnapshot/failures.snap

@@ -0,0 +1,7 @@
+    <div class="container">
+        <div class="row">
+            <div class="col-md-12">
+                <h1>Snapshot</h1>
+            </div>
+        </div>
+    </div>

tests/.pest/snapshots/Features/Expect/toMatchSnapshot/failures_with_custom_message.snap

@@ -0,0 +1,7 @@
+    <div class="container">
+        <div class="row">
+            <div class="col-md-12">
+                <h1>Snapshot</h1>
+            </div>
+        </div>
+    </div>

tests/.pest/snapshots/Features/Expect/toMatchSnapshot/not_failures.snap

@@ -0,0 +1,7 @@
+    <div class="container">
+        <div class="row">
+            <div class="col-md-12">
+                <h1>Snapshot</h1>
+            </div>
+        </div>
+    </div>

tests/.pest/snapshots/Features/Expect/toMatchSnapshot/pass.snap

@@ -0,0 +1,7 @@
+    <div class="container">
+        <div class="row">
+            <div class="col-md-12">
+                <h1>Snapshot</h1>
+            </div>
+        </div>
+    </div>

tests/.pest/snapshots/Features/Expect/toMatchSnapshot/pass_with______toString_.snap

@@ -0,0 +1,7 @@
+    <div class="container">
+        <div class="row">
+            <div class="col-md-12">
+                <h1>Snapshot</h1>
+            </div>
+        </div>
+    </div>

tests/.pest/snapshots/Features/Expect/toMatchSnapshot/pass_with__toArray_.snap

@@ -0,0 +1,3 @@
+{
+    "key": "    <div class=\"container\">\n        <div class=\"row\">\n            <div class=\"col-md-12\">\n                <h1>Snapshot<\/h1>\n            <\/div>\n        <\/div>\n    <\/div>"
+}

tests/.pest/snapshots/Features/Expect/toMatchSnapshot/pass_with__toString_.snap

@@ -0,0 +1,7 @@
+    <div class="container">
+        <div class="row">
+            <div class="col-md-12">
+                <h1>Snapshot</h1>
+            </div>
+        </div>
+    </div>

tests/.pest/snapshots/Features/Expect/toMatchSnapshot/pass_with_array.snap

@@ -0,0 +1,3 @@
+{
+    "key": "    <div class=\"container\">\n        <div class=\"row\">\n            <div class=\"col-md-12\">\n                <h1>Snapshot<\/h1>\n            <\/div>\n        <\/div>\n    <\/div>"
+}

tests/.pest/snapshots/Features/Expect/toMatchSnapshot/pass_with_dataset_with_data_set____my_datas_set_value______my_datas_set_value__.snap

@@ -0,0 +1,7 @@
+    <div class="container">
+        <div class="row">
+            <div class="col-md-12">
+                <h1>Snapshot</h1>
+            </div>
+        </div>
+    </div>

tests/.pest/snapshots/Visual/Collision/collision_with_data_set___________array_____.snap

@@ -18,7 +18,6 @@
       9▕ })->skip(! isset($_SERVER['COLLISION_TEST']));
 
   1   tests/Fixtures/CollisionTest.php:4
-  2   src/Factories/TestCaseMethodFactory.php:100
 
 
   Tests:    1 failed, 1 passed (1 assertions)

tests/.pest/snapshots/Visual/Collision/collision_with_data_set_______parallel______array____parallel___.snap

@@ -16,7 +16,6 @@
       9▕ })->skip(! isset($_SERVER['COLLISION_TEST']));
 
   1   tests/Fixtures/CollisionTest.php:4
-  2   src/Factories/TestCaseMethodFactory.php:100
 
 
   Tests:    1 failed, 2 passed (2 assertions)

tests/.pest/snapshots/Visual/Help/visual_snapshot_of_help_command_output.snap

@@ -1,5 +1,5 @@
 
-  Pest Testing Framework 2.5.1.  
+  Pest Testing Framework 2.10.1.  
 
   USAGE: pest <file> [options]  
 
@@ -34,6 +34,7 @@
 
   EXECUTION OPTIONS:
   --parallel ........................................... Run tests in parallel  
+  --update-snapshots  Update snapshots for tests using the "toMatchSnapshot" expectation  
   --process-isolation ................ Run each test in a separate PHP process  
   --globals-backup ................. Backup and restore $GLOBALS for each test  
   --static-backup ......... Backup and restore static properties for each test  

tests/.pest/snapshots/Visual/Version/visual_snapshot_of_help_command_output.snap

@@ -0,0 +1,3 @@
+
+  Pest Testing Framework 2.10.1.  
+

tests/.snapshots/Failure.php.inc

@@ -1,7 +1,7 @@
 ##teamcity[testSuiteStarted name='Tests/tests/Failure' locationHint='file://tests/.tests/Failure.php' flowId='1234']
-##teamcity[testCount count='6' flowId='1234']
+##teamcity[testCount count='8' flowId='1234']
 ##teamcity[testStarted name='it can fail with comparison' locationHint='pest_qn://tests/.tests/Failure.php::it can fail with comparison' flowId='1234']
-##teamcity[testFailed name='it can fail with comparison' message='Failed asserting that true matches expected false.' details='at src/Mixins/Expectation.php:343|nat src/Support/ExpectationPipeline.php:75|nat src/Support/ExpectationPipeline.php:79|nat src/Expectation.php:300|nat tests/.tests/Failure.php:6|nat src/Factories/TestCaseMethodFactory.php:100|nat src/Concerns/Testable.php:302|nat src/Support/ExceptionTrace.php:28|nat src/Concerns/Testable.php:302|nat src/Concerns/Testable.php:221|nat src/Kernel.php:86' type='comparisonFailure' actual='true' expected='false' flowId='1234']
+##teamcity[testFailed name='it can fail with comparison' message='Failed asserting that true matches expected false.' details='at tests/.tests/Failure.php:6' type='comparisonFailure' actual='true' expected='false' flowId='1234']
 ##teamcity[testFinished name='it can fail with comparison' duration='100000' flowId='1234']
 ##teamcity[testStarted name='it can be ignored because of no assertions' locationHint='pest_qn://tests/.tests/Failure.php::it can be ignored because of no assertions' flowId='1234']
 ##teamcity[testIgnored name='it can be ignored because of no assertions' message='This test did not perform any assertions' details='' flowId='1234']
@@ -10,16 +10,21 @@
 ##teamcity[testIgnored name='it can be ignored because it is skipped' message='This test was ignored.' details='' flowId='1234']
 ##teamcity[testFinished name='it can be ignored because it is skipped' duration='100000' flowId='1234']
 ##teamcity[testStarted name='it can fail' locationHint='pest_qn://tests/.tests/Failure.php::it can fail' flowId='1234']
-##teamcity[testFailed name='it can fail' message='oh noo' details='at tests/.tests/Failure.php:18|nat src/Factories/TestCaseMethodFactory.php:100|nat src/Concerns/Testable.php:302|nat src/Support/ExceptionTrace.php:28|nat src/Concerns/Testable.php:302|nat src/Concerns/Testable.php:221|nat src/Kernel.php:86' flowId='1234']
+##teamcity[testFailed name='it can fail' message='oh noo' details='at tests/.tests/Failure.php:18' flowId='1234']
 ##teamcity[testFinished name='it can fail' duration='100000' flowId='1234']
+##teamcity[testStarted name='it throws exception' locationHint='pest_qn://tests/.tests/Failure.php::it throws exception' flowId='1234']
+##teamcity[testFailed name='it throws exception' message='Exception: test error' details='at tests/.tests/Failure.php:22' flowId='1234']
+##teamcity[testFinished name='it throws exception' duration='100000' flowId='1234']
 ##teamcity[testStarted name='it is not done yet' locationHint='pest_qn://tests/.tests/Failure.php::it is not done yet' flowId='1234']
 ##teamcity[testIgnored name='it is not done yet' message='This test was ignored.' details='' flowId='1234']
 ##teamcity[testFinished name='it is not done yet' duration='100000' flowId='1234']
 ##teamcity[testStarted name='build this one.' locationHint='pest_qn://tests/.tests/Failure.php::build this one.' flowId='1234']
 ##teamcity[testIgnored name='build this one.' message='This test was ignored.' details='' flowId='1234']
 ##teamcity[testFinished name='build this one.' duration='100000' flowId='1234']
+##teamcity[testStarted name='it is passing' locationHint='pest_qn://tests/.tests/Failure.php::it is passing' flowId='1234']
+##teamcity[testFinished name='it is passing' duration='100000' flowId='1234']
 ##teamcity[testSuiteFinished name='Tests/tests/Failure' flowId='1234']
 
-  Tests:    2 failed, 1 risky, 2 todos, 1 skipped (2 assertions)
+  Tests:    3 failed, 1 risky, 2 todos, 1 skipped, 1 passed (3 assertions)
   Duration: 1.00s
 

tests/.snapshots/coverage.txt

@@ -1,60 +0,0 @@
-
-   PASS  Tests\Playground
-  ✓ basic
-
-  Tests:  1 passed
-  Time:   0.20s
-  Cov:    6.49%
-
-  Actions/AddsDefaults ........................................... 0.0 %
-  Actions/AddsTests .............................................. 0.0 %
-  Actions/LoadStructure .......................................... 0.0 %
-  Actions/ValidatesConfiguration ................................. 0.0 %
-  Actions/ValidatesEnvironment ................................... 0.0 %
-  Concerns/TestCase 40..54, 71..88, 123..126, 147 ............... 44.4 %
-  Console/Command ................................................ 0.0 %
-  Contracts/HasPrintableTestCaseName ............................. 0.0 %
-  Contracts/Plugins/AddsOutput  ................................ 100.0 %
-  Contracts/Plugins/HandlesArguments  .......................... 100.0 %
-  Datasets ....................................................... 0.0 %
-  Exceptions/AfterAllAlreadyExist ................................ 0.0 %
-  Exceptions/AfterEachAlreadyExist ............................... 0.0 %
-  Exceptions/AttributeNotSupportedYet ............................ 0.0 %
-  Exceptions/BeforeEachAlreadyExist .............................. 0.0 %
-  Exceptions/DatasetAlreadyExist ................................. 0.0 %
-  Exceptions/DatasetDoesNotExist ................................. 0.0 %
-  Exceptions/FileOrFolderNotFound ................................ 0.0 %
-  Exceptions/InvalidConsoleArgument .............................. 0.0 %
-  Exceptions/InvalidPestCommand .................................. 0.0 %
-  Exceptions/InvalidUsesPath ..................................... 0.0 %
-  Exceptions/ShouldNotHappen ..................................... 0.0 %
-  Exceptions/TestAlreadyExist .................................... 0.0 %
-  Exceptions/TestCaseAlreadyInUse ................................ 0.0 %
-  Exceptions/TestCaseClassOrTraitNotFound ........................ 0.0 %
-  Factories/TestCaseFactory 111..133, 141..204 ................... 8.2 %
-  Laravel/Commands/PestDatasetCommand ............................ 0.0 %
-  Laravel/Commands/PestInstallCommand ............................ 0.0 %
-  Laravel/Commands/PestTestCommand ............................... 0.0 %
-  Laravel/PestServiceProvider .................................... 0.0 %
-  PendingObjects/AfterEachCall ................................... 0.0 %
-  PendingObjects/BeforeEachCall .................................. 0.0 %
-  PendingObjects/TestCall ........................................ 0.0 %
-  PendingObjects/UsesCall ........................................ 0.0 %
-  Plugin ......................................................... 0.0 %
-  Repositories/AfterAllRepository ................................ 0.0 %
-  Repositories/AfterEachRepository 28..33 ....................... 60.0 %
-  Repositories/BeforeAllRepository ............................... 0.0 %
-  Repositories/BeforeEachRepository 26..31 ...................... 20.0 %
-  Repositories/TestRepository .................................... 0.0 %
-  Support/Backtrace .............................................. 0.0 %
-  Support/ChainableClosure  .................................... 100.0 %
-  Support/Container .............................................. 0.0 %
-  Support/ExceptionTrace 25..32 ................................. 28.6 %
-  Support/HigherOrderMessage ..................................... 0.0 %
-  Support/HigherOrderMessageCollection 24..25, 33, 43 ........... 50.0 %
-  Support/HigherOrderTapProxy .................................... 0.0 %
-  Support/NullClosure  ......................................... 100.0 %
-  Support/Reflection ............................................. 0.0 %
-  Support/Str .................................................... 0.0 %
-  TestSuite 80..87, 95..101, 105 ................................ 20.0 %
-  globals ........................................................ 0.0 %

tests/.snapshots/success.txt

@@ -22,6 +22,22 @@
   ✓ it gets executed before each test
   ✓ it gets executed before each test once again
 
+   PASS  Tests\Features\BeforeEachProxiesToTestCallWithExpectations
+  ✓ runs 1
+  ✓ runs 2
+  ✓ runs 3
+
+   WARN  Tests\Features\BeforeEachProxiesToTestCallWithSkip
+  - does not run 1
+  - does not run 2
+  - does not run 3
+
+   TODO  Tests\Features\BeforeEachProxiesToTestCallWithTodo - 4 todos
+  ↓ is marked as todo 1
+  ↓ is marked as todo 2
+  ↓ is marked as todo 3
+  ↓ shouldBeMarkedAsTodo
+
    WARN  Tests\Features\Coverage
   ✓ it has plugin
   - it adds coverage if --coverage exist → Coverage is not available
@@ -33,9 +49,11 @@
   ✓ it uses the correct PHPUnit attribute for function
   ✓ it removes duplicated attributes
   ✓ it guesses if the given argument is a class or function
+  ✓ it uses the correct PHPUnit attribute for trait
   ✓ it appends CoversNothing to method attributes
   ✓ it does not append CoversNothing to other methods
   ✓ it throws exception if no class nor method has been found
+  ✓ a "describe" group of tests → it does not append CoversNothing to method attributes
 
    PASS  Tests\Features\DatasetsTests - 1 todo
   ✓ it throws exception if dataset does not exist
@@ -63,7 +81,7 @@
   ✓ named datasets with dataset "one"
   ✓ named datasets with dataset "two"
   ✓ named datasets did the job right
-  ✓ lazy named datasets with (Bar Object (…))
+  ✓ lazy named datasets with (Bar)
   ✓ it creates unique test case names with ('Name 1', Pest\Plugin Object (), true) #1
   ✓ it creates unique test case names with ('Name 1', Pest\Plugin Object (), true) #2
   ✓ it creates unique test case names with ('Name 1', Pest\Plugin Object (), false)
@@ -117,24 +135,24 @@
   ✓ eager registered wrapped datasets with Generator functions did the job right
   ✓ eager registered wrapped datasets with Generator functions display description with dataset "taylor"
   ✓ eager registered wrapped datasets with Generator functions display description with dataset "james"
-  ✓ it can resolve a dataset after the test case is available with (Closure Object (…)) #1
-  ✓ it can resolve a dataset after the test case is available with (Closure Object (…)) #2
-  ✓ it can resolve a dataset after the test case is available with multiple datasets with (Closure Object (…)) / (Closure Object (…)) #1
-  ✓ it can resolve a dataset after the test case is available with multiple datasets with (Closure Object (…)) / (Closure Object (…)) #2
-  ✓ it can resolve a dataset after the test case is available with multiple datasets with (Closure Object (…)) / (Closure Object (…)) #3
-  ✓ it can resolve a dataset after the test case is available with multiple datasets with (Closure Object (…)) / (Closure Object (…)) #4
-  ✓ it can resolve a dataset after the test case is available with shared yield sets with (Closure Object (…)) #1
-  ✓ it can resolve a dataset after the test case is available with shared yield sets with (Closure Object (…)) #2
-  ✓ it can resolve a dataset after the test case is available with shared array sets with (Closure Object (…)) #1
-  ✓ it can resolve a dataset after the test case is available with shared array sets with (Closure Object (…)) #2
-  ✓ it resolves a potential bound dataset logically with ('foo', Closure Object (…))
-  ✓ it resolves a potential bound dataset logically even when the closure comes first with (Closure Object (…), 'bar')
-  ✓ it will not resolve a closure if it is type hinted as a closure with (Closure Object (…)) #1
-  ✓ it will not resolve a closure if it is type hinted as a closure with (Closure Object (…)) #2
-  ✓ it will not resolve a closure if it is type hinted as a callable with (Closure Object (…)) #1
-  ✓ it will not resolve a closure if it is type hinted as a callable with (Closure Object (…)) #2
-  ✓ it can correctly resolve a bound dataset that returns an array with (Closure Object (…))
-  ✓ it can correctly resolve a bound dataset that returns an array but wants to be spread with (Closure Object (…))
+  ✓ it can resolve a dataset after the test case is available with (Closure) #1
+  ✓ it can resolve a dataset after the test case is available with (Closure) #2
+  ✓ it can resolve a dataset after the test case is available with multiple datasets with (Closure) / (Closure) #1
+  ✓ it can resolve a dataset after the test case is available with multiple datasets with (Closure) / (Closure) #2
+  ✓ it can resolve a dataset after the test case is available with multiple datasets with (Closure) / (Closure) #3
+  ✓ it can resolve a dataset after the test case is available with multiple datasets with (Closure) / (Closure) #4
+  ✓ it can resolve a dataset after the test case is available with shared yield sets with (Closure) #1
+  ✓ it can resolve a dataset after the test case is available with shared yield sets with (Closure) #2
+  ✓ it can resolve a dataset after the test case is available with shared array sets with (Closure) #1
+  ✓ it can resolve a dataset after the test case is available with shared array sets with (Closure) #2
+  ✓ it resolves a potential bound dataset logically with ('foo', Closure)
+  ✓ it resolves a potential bound dataset logically even when the closure comes first with (Closure, 'bar')
+  ✓ it will not resolve a closure if it is type hinted as a closure with (Closure) #1
+  ✓ it will not resolve a closure if it is type hinted as a closure with (Closure) #2
+  ✓ it will not resolve a closure if it is type hinted as a callable with (Closure) #1
+  ✓ it will not resolve a closure if it is type hinted as a callable with (Closure) #2
+  ✓ it can correctly resolve a bound dataset that returns an array with (Closure)
+  ✓ it can correctly resolve a bound dataset that returns an array but wants to be spread with (Closure)
   ↓ forbids to define tests in Datasets dirs and Datasets.php files
 
    PASS  Tests\Features\Depends
@@ -152,8 +170,31 @@
   ✓ it uses correct parent class
 
    DEPR  Tests\Features\Deprecated
-  ! deprecated → str_contains(): Passing null to parameter #2 ($needle) of type string is deprecated // tests/Features/Deprecated.php:6
-  ✓ user deprecated
+  ! deprecated → str_contains(): Passing null to parameter #1 ($haystack) of type string is deprecated // tests/Features/Deprecated.php:6
+  ! user deprecated → Since foo 1.0: This is a deprecation description // vendor/symfony/deprecation-contracts/function.php:25
+
+   PASS  Tests\Features\Describe - 5 todos
+  ✓ before each
+  ✓ hooks → value
+  ✓ hooks in different orders → value
+  ↓ todo
+  ✓ previous describable before each does not get applied here
+  ↓ todo on hook → should not fail
+  ↓ todo on hook → should run
+  ↓ todo on describe → should not fail
+  ↓ todo on describe → should run
+  ✓ should run
+  ✓ with with (1)
+  ✓ with on hook → value with (2)
+  ✓ with on describe → value with (3)
+
+   PASS  Tests\Features\DescriptionLess
+  ✓ get 'foo'
+  ✓ get 'foo' → get 'bar' → expect true → toBeTrue
+  ✓ get 'foo' → expect true → toBeTrue
+  ✓ a "describe" group of tests → get 'foo'
+  ✓ a "describe" group of tests → get 'foo' → get 'bar' → expect true → toBeTrue
+  ✓ a "describe" group of tests → get 'foo' → expect true → toBeTrue
 
    PASS  Tests\Features\Exceptions
   ✓ it gives access the the underlying expectException
@@ -569,7 +610,7 @@
   ✓ it passes with ('Fortaleza')
   ✓ it passes with ('Sollefteå')
   ✓ it passes with ('Ιεράπετρα')
-  ✓ it passes with (stdClass Object (…))
+  ✓ it passes with (stdClass)
   ✓ it passes with array
   ✓ it passes with *not*
   ✓ it properly fails with *not*
@@ -588,6 +629,12 @@
   ✓ failures with custom message
   ✓ not failures
 
+   PASS  Tests\Features\Expect\toHavePrefix
+  ✓ missing prefix
+  ✓ has prefix
+  ✓ opposite missing prefix
+  ✓ opposite has prefix
+
    PASS  Tests\Features\Expect\toHaveProperties
   ✓ pass
   ✓ failures
@@ -601,6 +648,12 @@
   ✓ failures with message and Any matcher
   ✓ not failures
 
+   PASS  Tests\Features\Expect\toHaveSuffix
+  ✓ missing suffix
+  ✓ has suffix
+  ✓ opposite missing suffix
+  ✓ opposite has suffix
+
    PASS  Tests\Features\Expect\toMatch
   ✓ pass
   ✓ failures
@@ -624,6 +677,18 @@
   ✓ pass with class
   ✓ failures
   ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toMatchSnapshot
+  ✓ pass
+  ✓ pass with __toString
+  ✓ pass with toString
+  ✓ pass with dataset with ('my-datas-set-value')
+  ✓ within describe → pass with dataset with ('my-datas-set-value')
+  ✓ pass with toArray
+  ✓ pass with array
+  ✓ failures
+  ✓ failures with custom message
   ✓ not failures
 
    PASS  Tests\Features\Expect\toStartWith
@@ -641,6 +706,7 @@
   ✓ failures 5
   ✓ failures 6
   ✓ failures 7
+  ✓ failures 8
   ✓ failures with custom message
   ✓ not failures
   ✓ closure missing parameter
@@ -696,18 +762,106 @@
   ✓ it is not incompleted because of expect
   ✓ it is not incompleted because of assert
   ✓ it is not incompleted because of test with assertions
+  … a "describe" group of tests → it is incompleted
 
    PASS  Tests\Features\It
   ✓ it is a test
   ✓ it is a higher order message test
+  ✓ a "describe" group of tests → it is a test
+  ✓ a "describe" group of tests → it is a higher order message test
 
    NOTI  Tests\Features\Notices
   ! notice → This is a notice description // tests/Features/Notices.php:4
+  ! a "describe" group of tests → notice → This is a notice description // tests/Features/Notices.php:11
 
-   PASS  Tests\Features\PendingHigherOrderTests
-  ✓ get 'foo'
-  ✓ get 'foo' → get 'bar' → expect true → toBeTrue
-  ✓ get 'foo' → expect true → toBeTrue
+   PASS  Tests\Features\Repeat
+  ✓ once
+  ✓ multiple times @ repetition 1 of 5
+  ✓ multiple times @ repetition 2 of 5
+  ✓ multiple times @ repetition 3 of 5
+  ✓ multiple times @ repetition 4 of 5
+  ✓ multiple times @ repetition 5 of 5
+  ✓ multiple times with single dataset dataset "a" @ repetition 1 of 6
+  ✓ multiple times with single dataset dataset "b" @ repetition 1 of 6
+  ✓ multiple times with single dataset dataset "c" @ repetition 1 of 6
+  ✓ multiple times with single dataset dataset "a" @ repetition 2 of 6
+  ✓ multiple times with single dataset dataset "b" @ repetition 2 of 6
+  ✓ multiple times with single dataset dataset "c" @ repetition 2 of 6
+  ✓ multiple times with single dataset dataset "a" @ repetition 3 of 6
+  ✓ multiple times with single dataset dataset "b" @ repetition 3 of 6
+  ✓ multiple times with single dataset dataset "c" @ repetition 3 of 6
+  ✓ multiple times with single dataset dataset "a" @ repetition 4 of 6
+  ✓ multiple times with single dataset dataset "b" @ repetition 4 of 6
+  ✓ multiple times with single dataset dataset "c" @ repetition 4 of 6
+  ✓ multiple times with single dataset dataset "a" @ repetition 5 of 6
+  ✓ multiple times with single dataset dataset "b" @ repetition 5 of 6
+  ✓ multiple times with single dataset dataset "c" @ repetition 5 of 6
+  ✓ multiple times with single dataset dataset "a" @ repetition 6 of 6
+  ✓ multiple times with single dataset dataset "b" @ repetition 6 of 6
+  ✓ multiple times with single dataset dataset "c" @ repetition 6 of 6
+  ✓ multiple times with multiple dataset dataset "a" / (4) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (5) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (6) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (4) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (5) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (6) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (4) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (5) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (6) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (4) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (5) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (6) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (4) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (5) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (6) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (4) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (5) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (6) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (4) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (5) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (6) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (4) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (5) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (6) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (4) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (5) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (6) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (4) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (5) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (6) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (4) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (5) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (6) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (4) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (5) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (6) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (4) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (5) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (6) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (4) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (5) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (6) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (4) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (5) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (6) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (4) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (5) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (6) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (4) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (5) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (6) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (4) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (5) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (6) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (4) @ repetition 7 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (5) @ repetition 7 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (6) @ repetition 7 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (4) @ repetition 7 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (5) @ repetition 7 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (6) @ repetition 7 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (4) @ repetition 7 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (5) @ repetition 7 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (6) @ repetition 7 of 7
 
    PASS  Tests\Features\ScopedDatasets\Directory\NestedDirectory1\TestFileInNestedDirectoryWithDatasetsFile
   ✓ uses dataset with (1)
@@ -769,6 +923,7 @@
    PASS  Tests\Features\ThrowsNoExceptions
   ✓ it allows access to the underlying expectNotToPerformAssertions method
   ✓ it allows performing no expectations without being risky
+  ✓ a "describe" group of tests → it allows performing no expectations without being risky
 
    PASS  Tests\Features\Todo - 3 todos
   ↓ something todo later
@@ -779,6 +934,7 @@
    WARN  Tests\Features\Warnings
   ! warning → Undefined property: P\Tests\Features\Warnings::$fooqwdfwqdfqw
   ! user warning → This is a warning description
+  ! a "describe" group of tests → user warning → This is a warning description
 
    WARN  Tests\Fixtures\CollisionTest
   - error
@@ -790,6 +946,9 @@
    PASS  Tests\Fixtures\ExampleTest
   ✓ it example 2
 
+   WARN  Tests\Fixtures\UnexpectedOutput
+  - output
+
    PASS  Tests\Helpers\TestInHelpers
   ✓ it executes tests in the Helpers directory
 
@@ -845,6 +1004,12 @@
   ✓ custom traits can be used
   ✓ trait applied in this file
 
+   PASS  Tests\PHPUnit\GlobPatternTests\SubFolder\InnerFolder\UsesPerDirectoryAsPattern
+  ✓ closure was bound to CustomTestCase
+
+   PASS  Tests\PHPUnit\GlobPatternTests\SubFolder2\UsesPerFileAsPattern
+  ✓ closure was bound to CustomTestCase
+
    PASS  Tests\Playground
   ✓ basic
 
@@ -914,6 +1079,9 @@
   ✓ it ensures the given closures reports the correct class name
   ✓ it ensures the given closures reports the correct class name and suggests the [uses()] function
 
+   PASS  Tests\Unit\Support\HigherOrderMessage
+  ✓ undefined method exceptions
+
    PASS  Tests\Unit\Support\Reflection
   ✓ it gets file name from closure
   ✓ it gets property values
@@ -985,6 +1153,7 @@
   ✓ it can return an array of all test suite filenames
 
    PASS  Tests\Visual\BeforeEachTestName
+  ✓ description
   ✓ latest description
 
    PASS  Tests\Visual\Collision
@@ -1014,7 +1183,7 @@
   ✓ todo
   ✓ todo in parallel
 
-   PASS  Tests\Visual\Version
-  ✓ visual snapshot of help command output
+   WARN  Tests\Visual\Version
+  - visual snapshot of help command output
 
-  Tests:    1 deprecated, 3 warnings, 4 incomplete, 1 notice, 4 todos, 14 skipped, 711 passed (1719 assertions)
+  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 13 todos, 19 skipped, 838 passed (1939 assertions)

tests/.snapshots/todo.txt

@@ -1,6 +1,19 @@
+   TODO  Tests\Features\BeforeEachProxiesToTestCallWithTodo - 4 todos
+  ↓ is marked as todo 1
+  ↓ is marked as todo 2
+  ↓ is marked as todo 3
+  ↓ shouldBeMarkedAsTodo
+
    TODO  Tests\Features\DatasetsTests - 1 todo
   ↓ forbids to define tests in Datasets dirs and Datasets.php files
 
+   TODO  Tests\Features\Describe - 5 todos
+  ↓ todo
+  ↓ todo on hook → should not fail
+  ↓ todo on hook → should run
+  ↓ todo on describe → should not fail
+  ↓ todo on describe → should run
+
    TODO  Tests\Features\Todo - 3 todos
   ↓ something todo later
   ↓ something todo later chained
@@ -9,4 +22,4 @@
    PASS  Tests\CustomTestCase\ExecutedTest
   ✓ that gets executed
 
-  Tests:    4 todos, 1 passed (1 assertions)
+  Tests:    13 todos, 1 passed (1 assertions)

tests/.snapshots/version-command.txt

@@ -1,3 +0,0 @@
-
-  Pest Testing Framework 2.5.1.  
-

tests/.tests/Failure.php

@@ -18,9 +18,17 @@ it('can fail', function () {
     $this->fail("oh noo");
 });
 
+it('throws exception', function () {
+    throw new Exception('test error');
+});
+
 it('is not done yet', function () {
 
 })->todo();
 
 todo("build this one.");
 
+it('is passing', function () {
+    expect(true)->toEqual(true);
+});
+

tests/Arch.php

@@ -30,4 +30,4 @@ test('contracts')
         'NunoMaduro\Collision\Contracts',
         'Pest\Factories\TestCaseMethodFactory',
         'Symfony\Component\Console',
-    ]);
+    ])->toBeInterfaces();

tests/Features/AfterEach.php

@@ -7,7 +7,11 @@ beforeEach(function () use ($state) {
 });
 
 afterEach(function () {
-    $this->state->bar = 2;
+    $this->state->bar = 1;
+});
+
+afterEach(function () {
+    unset($this->state->bar);
 });
 
 it('does not get executed before the test', function () {
@@ -18,3 +22,7 @@ it('gets executed after the test', function () {
     expect($this->state)->toHaveProperty('bar');
     expect($this->state->bar)->toBe(2);
 });
+
+afterEach(function () {
+    $this->state->bar = 2;
+});

tests/Features/BeforeEach.php

@@ -4,12 +4,24 @@ beforeEach(function () {
     $this->bar = 2;
 });
 
+beforeEach(function () {
+    $this->bar++;
+});
+
+beforeEach(function () {
+    $this->bar = 0;
+});
+
 it('gets executed before each test', function () {
-    expect($this->bar)->toBe(2);
+    expect($this->bar)->toBe(1);
 
     $this->bar = 'changed';
 });
 
 it('gets executed before each test once again', function () {
-    expect($this->bar)->toBe(2);
+    expect($this->bar)->toBe(1);
+});
+
+beforeEach(function () {
+    $this->bar++;
 });

tests/Features/BeforeEachProxiesToTestCallWithExpectations.php

@@ -0,0 +1,15 @@
+<?php
+
+beforeEach()->expect(true)->toBeTrue();
+
+test('runs 1', function () {
+    // This test did performs assertions...
+});
+
+test('runs 2', function () {
+    // This test did performs assertions...
+});
+
+test('runs 3', function () {
+    // This test did performs assertions...
+});

tests/Features/BeforeEachProxiesToTestCallWithSkip.php

@@ -0,0 +1,15 @@
+<?php
+
+beforeEach()->skip();
+
+test('does not run 1', function () {
+    $this->fail('This test should not run');
+});
+
+test('does not run 2', function () {
+    $this->fail('This test should not run');
+});
+
+test('does not run 3', function () {
+    $this->fail('This test should not run');
+});

tests/Features/BeforeEachProxiesToTestCallWithTodo.php

@@ -0,0 +1,15 @@
+<?php
+
+beforeEach()->todo();
+
+test('is marked as todo 1', function () {
+    $this->fail('This test should not run');
+});
+
+test('is marked as todo 2', function () {
+    $this->fail('This test should not run');
+});
+
+test('is marked as todo 3');
+
+test()->shouldBeMarkedAsTodo();

tests/Features/Covers.php

@@ -6,6 +6,7 @@ use PHPUnit\Framework\Attributes\CoversClass;
 use Tests\Fixtures\Covers\CoversClass1;
 use Tests\Fixtures\Covers\CoversClass2;
 use Tests\Fixtures\Covers\CoversClass3;
+use Tests\Fixtures\Covers\CoversTrait;
 
 $runCounter = 0;
 
@@ -43,6 +44,13 @@ it('guesses if the given argument is a class or function', function () {
     expect($attributes[3]->getArguments()[0])->toBe(CoversClass3::class);
 })->covers(CoversClass3::class, 'testCoversFunction');
 
+it('uses the correct PHPUnit attribute for trait', function () {
+    $attributes = (new ReflectionClass($this))->getAttributes();
+
+    expect($attributes[4]->getName())->toBe('PHPUnit\Framework\Attributes\CoversClass');
+    expect($attributes[4]->getArguments()[0])->toBe('Tests\Fixtures\Covers\CoversTrait');
+})->coversClass(CoversTrait::class);
+
 it('appends CoversNothing to method attributes', function () {
     $phpDoc = (new ReflectionClass($this))->getMethod($this->name());
 
@@ -60,3 +68,11 @@ it('throws exception if no class nor method has been found', function () {
 
     $testCall->covers('fakeName');
 })->throws(InvalidArgumentException::class, 'No class or method named "fakeName" has been found.');
+
+describe('a "describe" group of tests', function () {
+    it('does not append CoversNothing to method attributes', function () {
+        $phpDoc = (new ReflectionClass($this))->getMethod($this->name());
+
+        expect(str_contains($phpDoc->getDocComment(), '* @coversNothing'))->toBeTrue();
+    });
+})->coversNothing();

tests/Features/Describe.php

@@ -0,0 +1,78 @@
+<?php
+
+beforeEach(fn () => $this->count = 1);
+
+test('before each', function () {
+    expect($this->count)->toBe(1);
+});
+
+describe('hooks', function () {
+    beforeEach(function () {
+        $this->count++;
+    });
+
+    test('value', function () {
+        expect($this->count)->toBe(2);
+        $this->count++;
+    });
+
+    afterEach(function () {
+        expect($this->count)->toBe(3);
+    });
+});
+
+describe('hooks in different orders', function () {
+    beforeEach(function () {
+        $this->count++;
+    });
+
+    test('value', function () {
+        expect($this->count)->toBe(3);
+        $this->count++;
+    });
+
+    afterEach(function () {
+        expect($this->count)->toBe(4);
+    });
+
+    beforeEach(function () {
+        $this->count++;
+    });
+});
+
+test('todo')->todo()->shouldNotRun();
+
+test('previous describable before each does not get applied here', function () {
+    expect($this->count)->toBe(1);
+});
+
+describe('todo on hook', function () {
+    beforeEach()->todo();
+
+    test('should not fail')->shouldNotRun();
+    test('should run')->expect(true)->toBeTrue();
+});
+
+describe('todo on describe', function () {
+    test('should not fail')->shouldNotRun();
+
+    test('should run')->expect(true)->toBeTrue();
+})->todo();
+
+test('should run')->expect(true)->toBeTrue();
+
+test('with', fn ($foo) => expect($foo)->toBe(1))->with([1]);
+
+describe('with on hook', function () {
+    beforeEach()->with([2]);
+
+    test('value', function ($foo) {
+        expect($foo)->toBe(2);
+    });
+});
+
+describe('with on describe', function () {
+    test('value', function ($foo) {
+        expect($foo)->toBe(3);
+    });
+})->with([3]);

tests/Features/DescriptionLess.php

@@ -29,3 +29,9 @@ trait Gettable
 get('foo'); // not incomplete because closure is created...
 get('foo')->get('bar')->expect(true)->toBeTrue();
 get('foo')->expect(true)->toBeTrue();
+
+describe('a "describe" group of tests', function () {
+    get('foo'); // not incomplete because closure is created...
+    get('foo')->get('bar')->expect(true)->toBeTrue();
+    get('foo')->expect(true)->toBeTrue();
+});

tests/Features/Expect/HigherOrder/methods.php

@@ -85,17 +85,17 @@ it('works with higher order tests')
 it('can use the scoped method to lock into the given level for expectations', function () {
     expect(new HasMethods())
         ->attributes()->scoped(fn ($attributes) => $attributes
-            ->name->toBe('Has Methods')
-            ->quantity->toBe(20)
+        ->name->toBe('Has Methods')
+        ->quantity->toBe(20)
         )
         ->name()->toBeString()->toBe('Has Methods')
         ->newInstance()->newInstance()->scoped(fn ($instance) => $instance
-            ->name()->toBe('Has Methods')
-            ->quantity()->toBe(20)
-            ->attributes()->scoped(fn ($attributes) => $attributes
-                ->name->toBe('Has Methods')
-                ->quantity->toBe(20)
-            )
+        ->name()->toBe('Has Methods')
+        ->quantity()->toBe(20)
+        ->attributes()->scoped(fn ($attributes) => $attributes
+        ->name->toBe('Has Methods')
+        ->quantity->toBe(20)
+        )
         );
 });
 

tests/Features/Expect/pipes.php

@@ -171,19 +171,19 @@ test('pipe works with negated expectation', function () use ($state) {
     $state->reset();
 
     expect($char)->not->toBe(new Char('B'))
-       ->and($state)
-       ->runCount->toMatchArray([
-           'char' => 1,
-           'number' => 0,
-           'wildcard' => 0,
-           'symbol' => 0,
-       ])
-       ->appliedCount->toMatchArray([
-           'char' => 1,
-           'number' => 0,
-           'wildcard' => 0,
-           'symbol' => 0,
-       ]);
+        ->and($state)
+        ->runCount->toMatchArray([
+            'char' => 1,
+            'number' => 0,
+            'wildcard' => 0,
+            'symbol' => 0,
+        ])
+        ->appliedCount->toMatchArray([
+            'char' => 1,
+            'number' => 0,
+            'wildcard' => 0,
+            'symbol' => 0,
+        ]);
 });
 
 test('interceptor is applied', function () use ($state) {

tests/Features/Expect/toHavePrefix.php

@@ -0,0 +1,21 @@
+<?php
+
+use Pest\Arch\Exceptions\ArchExpectationFailedException;
+
+test('missing prefix')
+    ->throws(ArchExpectationFailedException::class)
+    ->expect('Tests\\Fixtures\\Arch\\ToHavePrefix\\HasNoPrefix')
+    ->toHavePrefix('Prefix');
+
+test('has prefix')
+    ->expect('Tests\\Fixtures\\Arch\\ToHavePrefix\\HasPrefix')
+    ->toHavePrefix('Prefix');
+
+test('opposite missing prefix')
+    ->throws(ArchExpectationFailedException::class)
+    ->expect('Tests\\Fixtures\\Arch\\ToHavePrefix\\HasPrefix')
+    ->not->toHavePrefix('Prefix');
+
+test('opposite has prefix')
+    ->expect('Tests\\Fixtures\\Arch\\ToHavePrefix\\HasNoPrefix')
+    ->not->toHavePrefix('Prefix');

tests/Features/Expect/toHaveSuffix.php

@@ -0,0 +1,21 @@
+<?php
+
+use Pest\Arch\Exceptions\ArchExpectationFailedException;
+
+test('missing suffix')
+    ->throws(ArchExpectationFailedException::class)
+    ->expect('Tests\\Fixtures\\Arch\\ToHaveSuffix\\HasNoSuffix')
+    ->toHaveSuffix('Suffix');
+
+test('has suffix')
+    ->expect('Tests\\Fixtures\\Arch\\ToHaveSuffix\\HasSuffix')
+    ->toHaveSuffix('Suffix');
+
+test('opposite missing suffix')
+    ->throws(ArchExpectationFailedException::class)
+    ->expect('Tests\\Fixtures\\Arch\\ToHaveSuffix\\HasSuffix')
+    ->not->toHaveSuffix('Suffix');
+
+test('opposite has suffix')
+    ->expect('Tests\\Fixtures\\Arch\\ToHaveSuffix\\HasNoSuffix')
+    ->not->toHaveSuffix('Suffix');

tests/Features/Expect/toMatchSnapshot.php

@@ -0,0 +1,122 @@
+<?php
+
+use Pest\TestSuite;
+use PHPUnit\Framework\ExpectationFailedException;
+
+beforeEach(function () {
+    $this->snapshotable = <<<'HTML'
+        <div class="container">
+            <div class="row">
+                <div class="col-md-12">
+                    <h1>Snapshot</h1>
+                </div>
+            </div>
+        </div>
+    HTML;
+});
+
+test('pass', function () {
+    TestSuite::getInstance()->snapshots->save($this, $this->snapshotable);
+
+    expect($this->snapshotable)->toMatchSnapshot();
+});
+
+test('pass with `__toString`', function () {
+    TestSuite::getInstance()->snapshots->save($this, $this->snapshotable);
+
+    $object = new class($this->snapshotable)
+    {
+        public function __construct(protected string $snapshotable)
+        {
+        }
+
+        public function __toString()
+        {
+            return $this->snapshotable;
+        }
+    };
+
+    expect($object)->toMatchSnapshot()->toMatchSnapshot();
+});
+
+test('pass with `toString`', function () {
+    TestSuite::getInstance()->snapshots->save($this, $this->snapshotable);
+
+    $object = new class($this->snapshotable)
+    {
+        public function __construct(protected string $snapshotable)
+        {
+        }
+
+        public function toString()
+        {
+            return $this->snapshotable;
+        }
+    };
+
+    expect($object)->toMatchSnapshot()->toMatchSnapshot();
+});
+
+test('pass with dataset', function ($data) {
+    TestSuite::getInstance()->snapshots->save($this, $this->snapshotable);
+    [$filename] = TestSuite::getInstance()->snapshots->get($this, $this->snapshotable);
+
+    expect($filename)->toEndWith('pass_with_dataset_with_data_set____my_datas_set_value______my_datas_set_value__.snap')
+        ->and($this->snapshotable)->toMatchSnapshot();
+})->with(['my-datas-set-value']);
+
+describe('within describe', function () {
+    test('pass with dataset', function ($data) {
+        TestSuite::getInstance()->snapshots->save($this, $this->snapshotable);
+        [$filename] = TestSuite::getInstance()->snapshots->get($this, $this->snapshotable);
+
+        expect($filename)->toEndWith('pass_with_dataset_with_data_set____my_datas_set_value______my_datas_set_value__.snap')
+            ->and($this->snapshotable)->toMatchSnapshot();
+    });
+})->with(['my-datas-set-value']);
+
+test('pass with `toArray`', function () {
+    TestSuite::getInstance()->snapshots->save($this, json_encode(['key' => $this->snapshotable], JSON_PRETTY_PRINT));
+
+    $object = new class($this->snapshotable)
+    {
+        public function __construct(protected string $snapshotable)
+        {
+        }
+
+        public function toArray()
+        {
+            return [
+                'key' => $this->snapshotable,
+            ];
+        }
+    };
+
+    expect($object)->toMatchSnapshot()->toMatchSnapshot();
+});
+
+test('pass with array', function () {
+    TestSuite::getInstance()->snapshots->save($this, json_encode(['key' => $this->snapshotable], JSON_PRETTY_PRINT));
+
+    expect([
+        'key' => $this->snapshotable,
+    ])->toMatchSnapshot()->toMatchSnapshot();
+});
+
+test('failures', function () {
+    TestSuite::getInstance()->snapshots->save($this, $this->snapshotable);
+
+    expect('contain that does not match snapshot')->toMatchSnapshot();
+})->throws(ExpectationFailedException::class, 'Failed asserting that two strings are identical.');
+
+test('failures with custom message', function () {
+    TestSuite::getInstance()->snapshots->save($this, $this->snapshotable);
+
+    expect('contain that does not match snapshot')->toMatchSnapshot('oh no');
+})->throws(ExpectationFailedException::class, 'oh no');
+
+test('not failures', function () {
+    TestSuite::getInstance()->snapshots->save($this, $this->snapshotable);
+
+    expect($this->snapshotable)->not->toMatchSnapshot();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toThrow.php

@@ -2,6 +2,10 @@
 
 use PHPUnit\Framework\ExpectationFailedException;
 
+class CustomException extends Exception
+{
+}
+
 test('passes', function () {
     expect(function () {
         throw new RuntimeException();
@@ -33,6 +37,9 @@ test('passes', function () {
         throw new RuntimeException('actual message');
     })->toThrow(function (RuntimeException $e) {
     }, 'actual message');
+    expect(function () {
+        throw new CustomException('foo');
+    })->toThrow(new CustomException('foo'));
 });
 
 test('failures 1', function () {
@@ -79,6 +86,12 @@ test('failures 7', function () {
     })->toThrow(RuntimeException::class, 'expected message');
 })->throws(ExpectationFailedException::class);
 
+test('failures 8', function () {
+    expect(function () {
+        throw new CustomException('actual message');
+    })->toThrow(new CustomException('expected message'));
+})->throws(ExpectationFailedException::class);
+
 test('failures with custom message', function () {
     expect(function () {
         throw new RuntimeException('actual message');

tests/Features/Incompleted.php

@@ -15,3 +15,7 @@ it('is not incompleted because of assert')->assertTrue(true);
 it('is not incompleted because of test with assertions', function () {
     expect(true)->toBeTrue();
 });
+
+describe('a "describe" group of tests', function () {
+    it('is incompleted');
+});

tests/Features/It.php

@@ -5,3 +5,11 @@ it('is a test', function () {
 });
 
 it('is a higher order message test')->expect(true)->toBeTrue();
+
+describe('a "describe" group of tests', function () {
+    it('is a test', function () {
+        expect(['key' => 'foo'])->toHaveKey('key')->key->toBeString();
+    });
+
+    it('is a higher order message test')->expect(true)->toBeTrue();
+});

tests/Features/Notices.php

@@ -5,3 +5,11 @@ test('notice', function () {
 
     expect(true)->toBeTrue();
 });
+
+describe('a "describe" group of tests', function () {
+    test('notice', function () {
+        trigger_error('This is a notice description', E_USER_NOTICE);
+
+        expect(true)->toBeTrue();
+    });
+});

tests/Features/Repeat.php

@@ -0,0 +1,18 @@
+<?php
+
+test('once', function () {
+    expect(true)->toBeTrue();
+})->repeat(times: 1);
+
+test('multiple times', function () {
+    expect(true)->toBeTrue();
+})->repeat(times: 5);
+
+test('multiple times with single dataset', function (int $number) {
+    expect([1, 2, 3])->toContain($number);
+})->repeat(times: 6)->with(['a' => 1, 'b' => 2, 'c' => 3]);
+
+test('multiple times with multiple dataset', function (int $numberA, int $numberB) {
+    expect([1, 2, 3])->toContain($numberA)
+        ->and([4, 5, 6])->toContain($numberB);
+})->repeat(times: 7)->with(['a' => 1, 'b' => 2, 'c' => 3], [4, 5, 6]);

tests/Features/ThrowsNoExceptions.php

@@ -9,3 +9,9 @@ it('allows access to the underlying expectNotToPerformAssertions method', functi
 it('allows performing no expectations without being risky', function () {
     $result = 1 + 1;
 })->throwsNoExceptions();
+
+describe('a "describe" group of tests', function () {
+    it('allows performing no expectations without being risky', function () {
+        $result = 1 + 1;
+    });
+})->throwsNoExceptions();

tests/Features/Warnings.php

@@ -11,3 +11,11 @@ test('user warning', function () {
 
     expect(true)->toBeTrue();
 });
+
+describe('a "describe" group of tests', function () {
+    test('user warning', function () {
+        trigger_error('This is a warning description', E_USER_WARNING);
+
+        expect(true)->toBeTrue();
+    });
+});