release: v2.14.1

add expectations for uppercase, lowercase, alpha and alphanumeric

.github/workflows/integration-tests.yml

@@ -0,0 +1,42 @@
+name: Integration Tests
+
+on:
+  push:
+  schedule:
+    - cron: '0 0 * * *'
+
+
+jobs:
+  ci:
+    if: github.event_name != 'schedule' || github.repository == 'pestphp/pest'
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        php: ['8.1', '8.2']
+        dependency-version: [prefer-lowest, prefer-stable]
+
+    name: PHP ${{ matrix.php }} - ${{ matrix.os }} - ${{ matrix.dependency-version }}
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Setup PHP
+      uses: shivammathur/setup-php@v2
+      with:
+        php-version: ${{ matrix.php }}
+        tools: composer:v2
+        coverage: none
+
+    - name: Setup Problem Matches
+      run: |
+        echo "::add-matcher::${{ runner.tool_cache }}/php.json"
+        echo "::add-matcher::${{ runner.tool_cache }}/phpunit.json"
+
+    - name: Install PHP dependencies
+      run: composer update --${{ matrix.dependency-version }} --no-interaction --no-progress --ansi
+
+    - name: Integration Tests
+      run: composer test:integration
+

.github/workflows/static.yml

@@ -8,6 +8,7 @@ on:
 
 jobs:
   static:
+    if: github.event_name != 'schedule' || github.repository == 'pestphp/pest'
     name: Static Tests
 
     runs-on: ubuntu-latest
@@ -29,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

.github/workflows/tests.yml

@@ -9,6 +9,7 @@ on:
 
 jobs:
   ci:
+    if: github.event_name != 'schedule' || github.repository == 'pestphp/pest'
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
@@ -42,7 +43,4 @@ jobs:
 
     - name: Unit Tests in Parallel
       run: composer test:parallel
-      if: startsWith(matrix.os, 'windows') != true
 
-    - name: Integration Tests
-      run: composer test:integration

CHANGELOG.md

@@ -2,6 +2,209 @@
 
 ## Unreleased
 
+## [v2.14.0 (2023-08-14)](https://github.com/pestphp/pest/compare/v2.13.0...v2.14.0)
+
+### Added
+
+- `toBeUppercase()`, `toBeLowercase()`, `toBeAlphaNumeric()`, `toBeAlpha()` ([#906](https://github.com/pestphp/pest/pull/906))
+
+## [v2.13.0 (2023-08-09)](https://github.com/pestphp/pest/compare/v2.12.2...v2.13.0)
+
+### Added
+
+- `expect()->ddWhen` and `expect()->ddUnless` ([306b7eb](https://github.com/pestphp/pest/commit/306b7eb2a6a57e570d58228b46501ad9ba4062b4))
+
+## [v2.12.2 (2023-08-07)](https://github.com/pestphp/pest/compare/v2.12.0...v2.12.2)
+
+### Fixed
+
+- Running tests from `uses` parent class ([#898](https://github.com/pestphp/pest/pull/898))
+
+## [v2.12.0 (2023-08-02)](https://github.com/pestphp/pest/compare/v2.11.0...v2.12.0)
+
+### Added
+
+- Allows multiple `toMatchSnapshot` per test ([#881](https://github.com/pestphp/pest/pull/881))
+
+### Changed
+
+- Bumps PHPUnit to `^10.2.7` ([43107c1](https://github.com/pestphp/pest/commit/43107c17436e41e23018ae31705c688168c14784))
+
+## [v2.11.0 (2023-08-01)](https://github.com/pestphp/pest/compare/v2.10.1...v2.11.0)
+
+### Added
+
+- `toBeInvokable`expectation ([#891](https://github.com/pestphp/pest/pull/891))
+
+## [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
+- Bumps PHPUnit to `^10.1.1` ([ec6a817](https://github.com/pestphp/pest/commit/ec6a81735af19f5463d24545df97535d77697ec6))
+
+## [v2.5.0 (2023-04-14)](https://github.com/pestphp/pest/compare/v2.4.0...v2.5.0)
+
+### Chore
+- Bumps PHPUnit to `^10.1.0` ([#780](https://github.com/pestphp/pest/pull/780))
+
+## [v2.4.0 (2023-04-03)](https://github.com/pestphp/pest/compare/v2.3.0...v2.4.0)
+
+### Added
+- `skipOnWindows()`, `skipOnMac()`, and `skipOnLinux()` ([#757](https://github.com/pestphp/pest/pull/757))
+- source architecture testing violation ([#1](https://github.com/pestphp/pest-plugin-arch/pull/1))([8e66263](https://github.com/pestphp/pest-plugin-arch/commit/8e66263104304e99e3d6ceda25c7ed679b27fb03))
+- `toHaveProperties` may now also check values ([#760](https://github.com/pestphp/pest/pull/760))
+
+### Fixed
+- Tests on `tests/Helpers` directory not being executed ([#753](https://github.com/pestphp/pest/pull/753))
+- Teamcity count ([#747](https://github.com/pestphp/pest/pull/747))
+- Parallel execution when class extends class with same name ([#748](https://github.com/pestphp/pest/pull/748))
+- Wording on `uses()` hint ([#745](https://github.com/pestphp/pest/pull/745/files))
+
+## [v2.3.0 (2023-03-28)](https://github.com/pestphp/pest/compare/v2.2.3...v2.3.0)
+
+### Added
+- Better error handler about missing uses ([#743](https://github.com/pestphp/pest/pull/743))
+
+### Fixed
+- Inconsistent spelling of `dataset` ([#739](https://github.com/pestphp/pest/pull/739))
+
+### Chore
+- Bumps PHPUnit to `^10.0.19` ([3d7e621](https://github.com/pestphp/pest/commit/3d7e621b7dfc03f0b2d9dcf6eb06c26bc383f502))
+
+## [v2.2.3 (2023-03-24)](https://github.com/pestphp/pest/compare/v2.2.2...v2.2.3)
+
+### Fixed
+- Unnecessary dataset on dataset arguments mismatch ([#736](https://github.com/pestphp/pest/pull/736))
+- Parallel arguments on plugins order ([#703](https://github.com/pestphp/pest/pull/703))
+- Arch plugin runtime exceptions on bad phpdocs ([2f2b51c](https://github.com/pestphp/pest/commit/2f2b51ce3d1b000be9d6add0e785fd0044931b3b))
+
+## [v2.2.2 (2023-03-23)](https://github.com/pestphp/pest/compare/v2.2.1...v2.2.2)
+
+### Fixed
+- Edge case in parallel execution test description ([3ce6408](https://github.com/pestphp/pest/commit/3ce640819541ca6022b250e000f336d87c3e7889))
+
+## [v2.2.1 (2023-03-22)](https://github.com/pestphp/pest/compare/v2.2.0...v2.2.1)
+
+### Fixed
+- Collision between tests names with underscores ([#724](https://github.com/pestphp/pest/pull/724))
+
+### Chore
+- Bumps PHPUnit to `^10.0.18` ([1408cff](https://github.com/pestphp/pest/commit/1408cffc028690057e44f00038f9390f776e6bfb))
+
+## [v2.2.0 (2023-03-22)](https://github.com/pestphp/pest/compare/v2.1.0...v2.2.0)
+
+### Added
+- Improved error messages on dataset arguments mismatch ([#698](https://github.com/pestphp/pest/pull/698))
+- Allows the usage of `DateTimeInterface` on multiple expectations ([#716](https://github.com/pestphp/pest/pull/716))
+
+### Fixed
+- `--dirty` option on Windows environments ([#721](https://github.com/pestphp/pest/pull/721))
+- Parallel exit code when `phpunit.xml` is outdated ([14dd5cb](https://github.com/pestphp/pest/commit/14dd5cb57b9432300ac4e8095f069941cb43bdb5))
+
 ## [v2.1.0 (2023-03-21)](https://github.com/pestphp/pest/compare/v2.0.2...v2.1.0)
 
 ### Added

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:',
@@ -45,6 +46,7 @@ $bootPest = (static function (): void {
     ];
 
     foreach ($composerAutoloadFiles as $file) {
+
         if (file_exists($file)) {
             require_once $file;
             define('PHPUNIT_COMPOSER_INSTALL', $file);
@@ -58,6 +60,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 +76,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,11 +92,11 @@ $bootPest = (static function (): void {
         $testPath = fgets(STDIN);
         if ($testPath === false || $testPath === WrapperWorker::COMMAND_EXIT) {
             $application->end();
-
             exit;
         }
 
-        $exitCode = $application->runTest(trim($testPath));
+        // 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);
         fflush($statusFile);

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.2",
-        "nunomaduro/collision": "^7.3.1",
+        "brianium/paratest": "^7.2.5",
+        "nunomaduro/collision": "^7.8.1",
         "nunomaduro/termwind": "^1.15.1",
-        "pestphp/pest-plugin": "^2.0.0",
-        "pestphp/pest-plugin-arch": "^2.0.1",
-        "phpunit/phpunit": "^10.0.17"
+        "pestphp/pest-plugin": "^2.0.1",
+        "pestphp/pest-plugin-arch": "^2.2.3",
+        "phpunit/phpunit": "^10.3.2"
     },
     "conflict": {
         "webmozart/assert": "<1.11.0",
-        "phpunit/phpunit": ">10.0.17"
+        "phpunit/phpunit": ">10.3.2"
     },
     "autoload": {
         "psr-4": {
@@ -41,6 +41,8 @@
     "autoload-dev": {
         "psr-4": {
             "Tests\\Fixtures\\Covers\\": "tests/Fixtures/Covers",
+            "Tests\\Fixtures\\Inheritance\\": "tests/Fixtures/Inheritance",
+            "Tests\\Fixtures\\Arch\\": "tests/Fixtures/Arch",
             "Tests\\": "tests/PHPUnit/"
         },
         "files": [
@@ -48,10 +50,12 @@
         ]
     },
     "require-dev": {
-        "pestphp/pest-dev-tools": "^2.5.0",
-        "symfony/process": "^6.2.7"
+        "pestphp/pest-dev-tools": "^2.14.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",
@@ -67,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 -v",
-        "update:snapshots": "REBUILD_SNAPSHOTS=true php bin/pest --colors=always",
+        "test:integration": "php bin/pest --colors=always --group=integration",
+        "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"
@@ -97,6 +103,8 @@
                 "Pest\\Plugins\\ProcessIsolation",
                 "Pest\\Plugins\\Profile",
                 "Pest\\Plugins\\Retry",
+                "Pest\\Plugins\\Snapshot",
+                "Pest\\Plugins\\Verbose",
                 "Pest\\Plugins\\Version",
                 "Pest\\Plugins\\Parallel"
             ]

docker/Dockerfile

@@ -2,7 +2,7 @@ ARG PHP=8.1
 FROM php:${PHP}-cli-alpine
 
 RUN apk update \
-    && apk add zip libzip-dev icu-dev
+    && apk add zip libzip-dev icu-dev git
 
 RUN docker-php-ext-configure zip
 RUN docker-php-ext-install zip

overrides/Event/Value/ThrowableBuilder.php

@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PHPUnit\Event\Code;
+
+use NunoMaduro\Collision\Contracts\RenderableOnCollisionEditor;
+use PHPUnit\Event\NoPreviousThrowableException;
+use PHPUnit\Framework\Exception;
+use PHPUnit\Util\Filter;
+use PHPUnit\Util\ThrowableToStringMapper;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class ThrowableBuilder
+{
+    /**
+     * @throws Exception
+     * @throws NoPreviousThrowableException
+     */
+    public static function from(\Throwable $t): Throwable
+    {
+        $previous = $t->getPrevious();
+
+        if ($previous !== null) {
+            $previous = self::from($previous);
+        }
+
+        $trace = Filter::getFilteredStacktrace($t);
+
+        if ($t instanceof RenderableOnCollisionEditor && $frame = $t->toCollisionEditor()) {
+            $file = $frame->getFile();
+            $line = $frame->getLine();
+
+            $trace = "$file:$line\n$trace";
+        }
+
+        return new Throwable(
+            $t::class,
+            $t->getMessage(),
+            ThrowableToStringMapper::map($t),
+            $trace,
+            $previous
+        );
+    }
+}

overrides/Runner/Filter/NameFilterIterator.php

@@ -34,17 +34,18 @@
 
 namespace PHPUnit\Runner\Filter;
 
-use function end;
 use Exception;
-use function implode;
 use Pest\Contracts\HasPrintableTestCaseName;
 use PHPUnit\Framework\SelfDescribing;
 use PHPUnit\Framework\Test;
 use PHPUnit\Framework\TestCase;
 use PHPUnit\Framework\TestSuite;
-use function preg_match;
 use RecursiveFilterIterator;
 use RecursiveIterator;
+
+use function end;
+use function implode;
+use function preg_match;
 use function sprintf;
 use function str_replace;
 
@@ -107,7 +108,7 @@ final class NameFilterIterator extends RecursiveFilterIterator
             if (preg_match('/^(.*?)#(\d+)(?:-(\d+))?$/', $filter, $matches)) {
                 if (isset($matches[3]) && $matches[2] < $matches[3]) {
                     $filter = sprintf(
-                        '%s.*with data set #(\d+)$',
+                        '%s.*with dataset #(\d+)$',
                         $matches[1]
                     );
 
@@ -115,7 +116,7 @@ final class NameFilterIterator extends RecursiveFilterIterator
                     $this->filterMax = (int) $matches[3];
                 } else {
                     $filter = sprintf(
-                        '%s.*with data set #%s$',
+                        '%s.*with dataset #%s$',
                         $matches[1],
                         $matches[2]
                     );
@@ -125,7 +126,7 @@ final class NameFilterIterator extends RecursiveFilterIterator
             //  * testDetermineJsonError@JSON.*
             elseif (preg_match('/^(.*?)@(.+)$/', $filter, $matches)) {
                 $filter = sprintf(
-                    '%s.*with data set "%s"$',
+                    '%s.*with dataset "%s"$',
                     $matches[1],
                     $matches[2]
                 );

overrides/Runner/ResultCache/DefaultResultCache.php

@@ -45,9 +45,15 @@ declare(strict_types=1);
 
 namespace PHPUnit\Runner\ResultCache;
 
+use const DIRECTORY_SEPARATOR;
+
+use PHPUnit\Framework\TestStatus\TestStatus;
+use PHPUnit\Runner\DirectoryCannotBeCreatedException;
+use PHPUnit\Runner\Exception;
+use PHPUnit\Util\Filesystem;
+
 use function array_keys;
 use function assert;
-use const DIRECTORY_SEPARATOR;
 use function dirname;
 use function file_get_contents;
 use function file_put_contents;
@@ -57,10 +63,6 @@ use function is_file;
 use function json_decode;
 use function json_encode;
 use function Pest\version;
-use PHPUnit\Framework\TestStatus\TestStatus;
-use PHPUnit\Runner\DirectoryCannotBeCreatedException;
-use PHPUnit\Runner\Exception;
-use PHPUnit\Util\Filesystem;
 
 /**
  * @internal This class is not covered by the backward compatibility promise for PHPUnit
@@ -89,7 +91,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;

overrides/Runner/TestSuiteLoader.php

@@ -36,18 +36,19 @@ declare(strict_types=1);
 
 namespace PHPUnit\Runner;
 
-use function array_diff;
-use function array_values;
-use function basename;
-use function class_exists;
 use Exception;
-use function get_declared_classes;
 use Pest\Contracts\HasPrintableTestCaseName;
 use Pest\TestCases\IgnorableTestCase;
 use Pest\TestSuite;
 use PHPUnit\Framework\TestCase;
 use ReflectionClass;
 use ReflectionException;
+
+use function array_diff;
+use function array_values;
+use function basename;
+use function class_exists;
+use function get_declared_classes;
 use function substr;
 
 /**
@@ -60,6 +61,11 @@ final class TestSuiteLoader
      */
     private static array $loadedClasses = [];
 
+    /**
+     * @psalm-var array<string, array<class-string>>
+     */
+    private static array $loadedClassesByFilename = [];
+
     /**
      * @psalm-var list<class-string>
      */
@@ -97,6 +103,17 @@ final class TestSuiteLoader
 
         self::$loadedClasses = array_merge($loadedClasses, self::$loadedClasses);
 
+        foreach ($loadedClasses as $loadedClass) {
+            $reflection = new ReflectionClass($loadedClass);
+            $filename = $reflection->getFileName();
+            self::$loadedClassesByFilename[$filename] = [
+                $loadedClass,
+                ...self::$loadedClassesByFilename[$filename] ?? [],
+            ];
+        }
+
+        $loadedClasses = array_merge(self::$loadedClassesByFilename[$suiteClassFile] ?? [], $loadedClasses);
+
         if (empty($loadedClasses)) {
             return $this->exceptionFor($suiteClassName, $suiteClassFile);
         }

overrides/TextUI/TestSuiteFilterProcessor.php

@@ -45,7 +45,6 @@ declare(strict_types=1);
 
 namespace PHPUnit\TextUI;
 
-use function array_map;
 use Pest\Plugins\Only;
 use PHPUnit\Event;
 use PHPUnit\Framework\TestSuite;
@@ -53,6 +52,8 @@ use PHPUnit\Runner\Filter\Factory;
 use PHPUnit\TextUI\Configuration\Configuration;
 use PHPUnit\TextUI\Configuration\FilterNotConfiguredException;
 
+use function array_map;
+
 /**
  * @internal This class is not covered by the backward compatibility promise for PHPUnit
  */

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.#"

phpunit.xml

@@ -18,11 +18,12 @@
       <directory suffix=".php">./tests</directory>
       <exclude>./tests/.snapshots</exclude>
       <exclude>./tests/.tests</exclude>
+      <exclude>./tests/Fixtures/Inheritance</exclude>
     </testsuite>
   </testsuites>
-  <coverage>
+  <source>
     <include>
       <directory suffix=".php">./src</directory>
     </include>
-  </coverage>
+  </source>
 </phpunit>

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/Bootstrappers/BootFiles.php

@@ -7,12 +7,13 @@ namespace Pest\Bootstrappers;
 use Pest\Contracts\Bootstrapper;
 use Pest\Support\DatasetInfo;
 use Pest\Support\Str;
-use function Pest\testDirectory;
 use Pest\TestSuite;
 use RecursiveDirectoryIterator;
 use RecursiveIteratorIterator;
 use SebastianBergmann\FileIterator\Facade as PhpUnitFileIterator;
 
+use function Pest\testDirectory;
+
 /**
  * @internal
  */

src/Bootstrappers/BootOverrides.php

@@ -24,6 +24,7 @@ final class BootOverrides implements Bootstrapper
         'TextUI/Command/WarmCodeCoverageCacheCommand.php',
         'TextUI/Output/Default/ProgressPrinter/TestSkippedSubscriber.php',
         'TextUI/TestSuiteFilterProcessor.php',
+        'Event/Value/ThrowableBuilder.php',
     ];
 
     /**

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

@@ -5,11 +5,14 @@ declare(strict_types=1);
 namespace Pest\Concerns;
 
 use Closure;
+use Pest\Exceptions\DatasetArgsCountMismatch;
 use Pest\Support\ChainableClosure;
 use Pest\Support\ExceptionTrace;
 use Pest\Support\Reflection;
 use Pest\TestSuite;
 use PHPUnit\Framework\TestCase;
+use ReflectionException;
+use ReflectionFunction;
 use Throwable;
 
 /**
@@ -20,40 +23,50 @@ 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;
 
+    /**
+     * The list of snapshot changes, if any.
+     */
+    private array $__snapshotChanges = [];
+
     /**
      * Resets the test case static properties.
      */
@@ -75,6 +88,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);
         }
     }
@@ -84,12 +98,12 @@ trait Testable
      */
     public function __addBeforeAll(?Closure $hook): void
     {
-        if ($hook === null) {
+        if (! $hook instanceof \Closure) {
             return;
         }
 
         self::$__beforeAll = (self::$__beforeAll instanceof Closure)
-            ? ChainableClosure::fromStatic(self::$__beforeAll, $hook)
+            ? ChainableClosure::boundStatically(self::$__beforeAll, $hook)
             : $hook;
     }
 
@@ -98,12 +112,12 @@ trait Testable
      */
     public function __addAfterAll(?Closure $hook): void
     {
-        if ($hook === null) {
+        if (! $hook instanceof \Closure) {
             return;
         }
 
         self::$__afterAll = (self::$__afterAll instanceof Closure)
-            ? ChainableClosure::fromStatic(self::$__afterAll, $hook)
+            ? ChainableClosure::boundStatically(self::$__afterAll, $hook)
             : $hook;
     }
 
@@ -128,12 +142,12 @@ trait Testable
      */
     private function __addHook(string $property, ?Closure $hook): void
     {
-        if ($hook === null) {
+        if (! $hook instanceof \Closure) {
             return;
         }
 
         $this->{$property} = ($this->{$property} instanceof Closure)
-            ? ChainableClosure::from($this->{$property}, $hook)
+            ? ChainableClosure::bound($this->{$property}, $hook)
             : $hook;
     }
 
@@ -147,7 +161,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));
@@ -161,7 +175,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));
@@ -176,12 +190,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());
@@ -195,7 +230,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());
@@ -212,7 +247,10 @@ trait Testable
      */
     private function __runTest(Closure $closure, ...$args): mixed
     {
-        return $this->__callClosure($closure, $this->__resolveTestArguments($args));
+        $arguments = $this->__resolveTestArguments($args);
+        $this->__ensureDatasetArgumentNumberMatches($arguments);
+
+        return $this->__callClosure($closure, $arguments);
     }
 
     /**
@@ -224,7 +262,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));
@@ -235,7 +275,7 @@ trait Testable
                     continue;
                 }
 
-                if (in_array($testParameterTypes[$argumentIndex], [\Closure::class, 'callable', 'mixed'])) {
+                if (in_array($testParameterTypes[$argumentIndex], [Closure::class, 'callable', 'mixed'])) {
                     continue;
                 }
 
@@ -249,7 +289,7 @@ trait Testable
             return $arguments;
         }
 
-        if (in_array($testParameterTypes[0], [\Closure::class, 'callable'])) {
+        if (in_array($testParameterTypes[0], [Closure::class, 'callable'])) {
             return $arguments;
         }
 
@@ -264,6 +304,30 @@ trait Testable
         return array_values($boundDatasetResult);
     }
 
+    /**
+     * Ensures dataset items count matches underlying test case required parameters
+     *
+     * @throws ReflectionException
+     * @throws DatasetArgsCountMismatch
+     */
+    private function __ensureDatasetArgumentNumberMatches(array $arguments): void
+    {
+        if ($arguments === []) {
+            return;
+        }
+
+        $underlyingTest = Reflection::getFunctionVariable($this->__test, 'closure');
+        $testReflection = new ReflectionFunction($underlyingTest);
+        $requiredParametersCount = $testReflection->getNumberOfRequiredParameters();
+        $suppliedParametersCount = count($arguments);
+
+        if ($suppliedParametersCount >= $requiredParametersCount) {
+            return;
+        }
+
+        throw new DatasetArgsCountMismatch($requiredParametersCount, $suppliedParametersCount);
+    }
+
     /**
      * @throws Throwable
      */
@@ -272,6 +336,24 @@ trait Testable
         return ExceptionTrace::ensure(fn (): mixed => call_user_func_array(Closure::bind($closure, $this, $this::class), $arguments));
     }
 
+    /** @postCondition */
+    protected function __MarkTestIncompleteIfSnapshotHaveChanged(): void
+    {
+        if (count($this->__snapshotChanges) === 0) {
+            return;
+        }
+
+        if (count($this->__snapshotChanges) === 1) {
+            $this->markTestIncomplete($this->__snapshotChanges[0]);
+
+            return;
+        }
+
+        $messages = implode(PHP_EOL, array_map(static fn (string $message): string => '- $message', $this->__snapshotChanges));
+
+        $this->markTestIncomplete($messages);
+    }
+
     /**
      * The printable test case name.
      */

src/Contracts/AddsAnnotations.php

@@ -7,7 +7,7 @@ namespace Pest\Contracts;
 use Pest\Factories\TestCaseMethodFactory;
 
 /**
- * @interal
+ * @internal
  */
 interface AddsAnnotations
 {

src/Contracts/Plugins/HandlesArguments.php

@@ -10,7 +10,7 @@ namespace Pest\Contracts\Plugins;
 interface HandlesArguments
 {
     /**
-     * Adds arguments before of the Test Suite execution.
+     * Adds arguments before the Test Suite execution.
      *
      * @param  array<int, string>  $arguments
      * @return array<int, string>

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/DatasetArgsCountMismatch.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use Exception;
+
+final class DatasetArgsCountMismatch extends Exception
+{
+    public function __construct(int $requiredCount, int $suppliedCount)
+    {
+        parent::__construct(sprintf('Test expects %d arguments but dataset only provides %d', $requiredCount, $suppliedCount));
+    }
+}

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
 {
@@ -118,6 +127,40 @@ final class Expectation
         exit(1);
     }
 
+    /**
+     * Dump the expectation value when the result of the condition is truthy.
+     *
+     * @param  (\Closure(TValue): bool)|bool  $condition
+     * @return self<TValue>
+     */
+    public function ddWhen(Closure|bool $condition, mixed ...$arguments): Expectation
+    {
+        $condition = $condition instanceof Closure ? $condition($this->value) : $condition;
+
+        if (! $condition) {
+            return $this;
+        }
+
+        $this->dd(...$arguments);
+    }
+
+    /**
+     * Dump the expectation value when the result of the condition is falsy.
+     *
+     * @param  (\Closure(TValue): bool)|bool  $condition
+     * @return self<TValue>
+     */
+    public function ddUnless(Closure|bool $condition, mixed ...$arguments): Expectation
+    {
+        $condition = $condition instanceof Closure ? $condition($this->value) : $condition;
+
+        if ($condition) {
+            return $this;
+        }
+
+        $this->dd(...$arguments);
+    }
+
     /**
      * Send the expectation value to Ray along with all given arguments.
      *
@@ -167,7 +210,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 +253,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 +291,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 +307,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 +330,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 +390,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 +431,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 prefix.
+     */
+    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.
      *
@@ -419,4 +727,17 @@ final class Expectation
     {
         return ToBeUsedInNothing::make($this);
     }
+
+    /**
+     * Asserts that the given expectation dependency is an invokable class.
+     */
+    public function toBeInvokable(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->hasMethod('__invoke'),
+            'to be invokable',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
+        );
+    }
 }

src/Expectations/EachExpectation.php

@@ -4,9 +4,10 @@ declare(strict_types=1);
 
 namespace Pest\Expectations;
 
-use function expect;
 use Pest\Expectation;
 
+use function expect;
+
 /**
  * @internal
  *

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']);
+    }
+
+    /**
+     * Asserts that the given expectation target to not have the given prefix.
+     */
+    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')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to not have the given suffix.
+     */
+    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']);
@@ -117,6 +365,19 @@ final class OppositeExpectation
         throw InvalidExpectation::fromMethods(['not', 'toBeUsedInNothing']);
     }
 
+    /**
+     * Asserts that the given expectation dependency is not an invokable class.
+     */
+    public function toBeInvokable(): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! $object->reflectionClass->hasMethod('__invoke'),
+            'to not be invokable',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
+        );
+    }
+
     /**
      * Handle dynamic method calls into the original expectation.
      *
@@ -126,9 +387,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 +408,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 +431,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/Annotations/TestDox.php

@@ -14,7 +14,17 @@ final class TestDox implements AddsAnnotations
      */
     public function __invoke(TestCaseMethodFactory $method, array $annotations): array
     {
-        $annotations[] = "@testdox $method->description";
+        /*
+       * escapes docblock according to
+       * https://manual.phpdoc.org/HTMLframesConverter/default/phpDocumentor/tutorial_phpDocumentor.howto.pkg.html#basics.desc
+       *
+       * note: '@' escaping is not needed as it cannot be the first character of the line (it always starts with @testdox
+       */
+
+        assert($method->description !== null);
+        $methodDescription = str_replace('*/', '{@*}', $method->description);
+
+        $annotations[] = "@testdox $methodDescription";
 
         return $annotations;
     }

src/Factories/Attributes/Covers.php

@@ -14,7 +14,7 @@ use Pest\Factories\TestCaseMethodFactory;
 final class Covers extends Attribute
 {
     /**
-     * Determine if the attribute should be placed above the classe instead of above the method.
+     * Determine if the attribute should be placed above the class instead of above the method.
      */
     public static bool $above = true;
 

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);
@@ -217,7 +217,7 @@ final class TestCaseFactory
         }
 
         if (! $method->receivesArguments()) {
-            if ($method->closure === null) {
+            if (! $method->closure instanceof \Closure) {
                 throw ShouldNotHappen::fromMessage('The test closure may not be empty.');
             }
 

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,11 +114,11 @@ 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
     {
-        if ($description === null && TestSuite::getInstance()->test !== null) {
+        if ($description === null && TestSuite::getInstance()->test instanceof \PHPUnit\Framework\TestCase) {
             return new HigherOrderTapProxy(TestSuite::getInstance()->test);
         }
 
@@ -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

@@ -11,7 +11,9 @@ use Pest\Plugins\Actions\CallsBoot;
 use Pest\Plugins\Actions\CallsHandleArguments;
 use Pest\Plugins\Actions\CallsShutdown;
 use Pest\Support\Container;
+use PHPUnit\TestRunner\TestResult\Facade;
 use PHPUnit\TextUI\Application;
+use PHPUnit\TextUI\Configuration\Registry;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
 
@@ -31,6 +33,7 @@ final class Kernel
         Bootstrappers\BootFiles::class,
         Bootstrappers\BootView::class,
         Bootstrappers\BootKernelDump::class,
+        Bootstrappers\BootExcludeList::class,
     ];
 
     /**
@@ -65,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;
     }
 
     /**
@@ -90,8 +97,11 @@ final class Kernel
             ]);
         }
 
+        $configuration = Registry::get();
+        $result = Facade::result();
+
         return CallsAddsOutput::execute(
-            Result::exitCode(),
+            Result::exitCode($configuration, $result),
         );
     }
 

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;
@@ -64,7 +70,7 @@ final class Converter
     }
 
     /**
-     * Gets the exception messsage.
+     * Gets the exception message.
      */
     public function getExceptionMessage(Throwable $throwable): string
     {
@@ -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();
 
@@ -166,6 +172,14 @@ final class Converter
         return $this->toRelativePath($path);
     }
 
+    /**
+     * Gets the test suite size.
+     */
+    public function getTestSuiteSize(TestSuite $testSuite): int
+    {
+        return $testSuite->count();
+    }
+
     /**
      * Transforms the given path in relative path.
      */
@@ -180,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,
@@ -40,6 +40,13 @@ final class ServiceMessage
         ]);
     }
 
+    public static function testSuiteCount(int $count): self
+    {
+        return new self('testCount', [
+            'count' => $count,
+        ]);
+    }
+
     public static function testSuiteFinished(string $name): self
     {
         return new self('testSuiteFinished', [
@@ -120,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;
@@ -34,6 +35,7 @@ use PHPUnit\Event\TestSuite\Finished as TestSuiteFinished;
 use PHPUnit\Event\TestSuite\Started as TestSuiteStarted;
 use PHPUnit\Event\UnknownSubscriberTypeException;
 use PHPUnit\TestRunner\TestResult\Facade as TestResultFacade;
+use ReflectionClass;
 use Symfony\Component\Console\Output\ConsoleOutput;
 use Symfony\Component\Console\Output\OutputInterface;
 
@@ -44,6 +46,13 @@ final class TeamCityLogger
 {
     private ?HRTime $time = null;
 
+    private bool $isSummaryTestCountPrinted = false;
+
+    /**
+     * @var array<string, bool>
+     */
+    private array $testEvents = [];
+
     /**
      * @throws EventFacadeIsSealedException
      * @throws UnknownSubscriberTypeException
@@ -51,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();
@@ -66,6 +75,15 @@ final class TeamCityLogger
         );
 
         $this->output($message);
+
+        if (! $this->isSummaryTestCountPrinted) {
+            $this->isSummaryTestCountPrinted = true;
+            $message = ServiceMessage::testSuiteCount(
+                $this->converter->getTestSuiteSize($event->testSuite())
+            );
+
+            $this->output($message);
+        }
     }
 
     public function testSuiteFinished(TestSuiteFinished $event): void
@@ -96,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);
+        });
     }
 
     /**
@@ -110,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);
+        });
     }
 
     /**
@@ -129,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);
+        });
     }
 
     /**
@@ -159,17 +183,19 @@ 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
     {
-        if ($this->time === null) {
+        if (! $this->time instanceof \PHPUnit\Event\Telemetry\HRTime) {
             throw ShouldNotHappen::fromMessage('Start time has not been set.');
         }
 
@@ -196,13 +222,17 @@ final class TeamCityLogger
         $style = new Style($this->output);
 
         $telemetry = $event->telemetryInfo();
+
         if ($this->withoutDuration) {
+            $reflector = new ReflectionClass($telemetry);
+
+            $property = $reflector->getProperty('current');
+            $property->setAccessible(true);
+            $snapshot = $property->getValue($telemetry);
+            assert($snapshot instanceof Snapshot);
+
             $telemetry = new Info(
-                new Snapshot(
-                    $telemetry->time(),
-                    $telemetry->memoryUsage(),
-                    $telemetry->peakMemoryUsage(),
-                ),
+                $snapshot,
                 Duration::fromSecondsAndNanoseconds(1, 0),
                 $telemetry->memoryUsageSinceStart(),
                 $telemetry->durationSincePrevious(),
@@ -248,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

@@ -6,19 +6,24 @@ namespace Pest\Mixins;
 
 use BadMethodCallException;
 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
@@ -32,7 +37,7 @@ final class Expectation
     /**
      * The exporter instance, if any.
      */
-    private Exporter|null $exporter = null;
+    private ?Exporter $exporter = null;
 
     /**
      * Creates a new expectation.
@@ -124,7 +129,7 @@ final class Expectation
      *
      * @return self<TValue>
      */
-    public function toBeGreaterThan(int|float $expected, string $message = ''): self
+    public function toBeGreaterThan(int|float|DateTimeInterface $expected, string $message = ''): self
     {
         Assert::assertGreaterThan($expected, $this->value, $message);
 
@@ -136,7 +141,7 @@ final class Expectation
      *
      * @return self<TValue>
      */
-    public function toBeGreaterThanOrEqual(int|float $expected, string $message = ''): self
+    public function toBeGreaterThanOrEqual(int|float|DateTimeInterface $expected, string $message = ''): self
     {
         Assert::assertGreaterThanOrEqual($expected, $this->value, $message);
 
@@ -148,7 +153,7 @@ final class Expectation
      *
      * @return self<TValue>
      */
-    public function toBeLessThan(int|float $expected, string $message = ''): self
+    public function toBeLessThan(int|float|DateTimeInterface $expected, string $message = ''): self
     {
         Assert::assertLessThan($expected, $this->value, $message);
 
@@ -160,7 +165,7 @@ final class Expectation
      *
      * @return self<TValue>
      */
-    public function toBeLessThanOrEqual(int|float $expected, string $message = ''): self
+    public function toBeLessThanOrEqual(int|float|DateTimeInterface $expected, string $message = ''): self
     {
         Assert::assertLessThanOrEqual($expected, $this->value, $message);
 
@@ -295,8 +300,8 @@ final class Expectation
      */
     public function toHaveProperties(iterable $names, string $message = ''): self
     {
-        foreach ($names as $name) {
-            $this->toHaveProperty($name, message: $message);
+        foreach ($names as $name => $value) {
+            is_int($name) ? $this->toHaveProperty($value, message: $message) : $this->toHaveProperty($name, $value, $message);
         }
 
         return $this;
@@ -793,6 +798,48 @@ final class Expectation
         return $this;
     }
 
+    /**
+     * Asserts that the value "stringable" matches the given snapshot..
+     *
+     * @return self<TValue>
+     */
+    public function toMatchSnapshot(string $message = ''): self
+    {
+        $snapshots = TestSuite::getInstance()->snapshots;
+        $snapshots->startNewExpectation();
+
+        $testCase = TestSuite::getInstance()->test;
+        assert($testCase instanceof TestCase);
+
+        $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'),
+        };
+
+        if ($snapshots->has()) {
+            [$filename, $content] = $snapshots->get();
+
+            Assert::assertSame(
+                strtr($content, ["\r\n" => "\n", "\r" => "\n"]),
+                strtr($string, ["\r\n" => "\n", "\r" => "\n"]),
+                $message === '' ? "Failed asserting that the string value matches its snapshot ($filename)." : $message
+            );
+        } else {
+            $filename = $snapshots->save($string);
+
+            TestSuite::getInstance()->registerSnapshotChange("Snapshot created at [$filename]");
+        }
+
+        return $this;
+    }
+
     /**
      * Asserts that the value matches a regular expression.
      *
@@ -838,10 +885,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();
 
@@ -863,6 +910,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);
@@ -887,7 +943,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.");
         }
 
@@ -899,10 +955,58 @@ final class Expectation
      */
     private function export(mixed $value): string
     {
-        if ($this->exporter === null) {
+        if (! $this->exporter instanceof \Pest\Support\Exporter) {
             $this->exporter = Exporter::default();
         }
 
         return $this->exporter->shortenedExport($value);
     }
+
+    /**
+     * Asserts that the value is uppercase.
+     *
+     * @return self<TValue>
+     */
+    public function toBeUppercase(string $message = ''): self
+    {
+        Assert::assertTrue(ctype_upper((string) $this->value), $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is lowercase.
+     *
+     * @return self<TValue>
+     */
+    public function toBeLowercase(string $message = ''): self
+    {
+        Assert::assertTrue(ctype_lower((string) $this->value), $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is alphanumeric.
+     *
+     * @return self<TValue>
+     */
+    public function toBeAlphaNumeric(string $message = ''): self
+    {
+        Assert::assertTrue(ctype_alnum((string) $this->value), $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is alpha.
+     *
+     * @return self<TValue>
+     */
+    public function toBeAlpha(string $message = ''): self
+    {
+        Assert::assertTrue(ctype_alpha((string) $this->value), $message);
+
+        return $this;
+    }
 }

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,55 @@ final class TestCall
 
         $this->testCaseMethod
             ->chains
-            ->addWhen($condition, Backtrace::file(), Backtrace::line(), 'markTestSkipped', [$message]);
+            ->addWhen($condition, $this->filename, Backtrace::line(), 'markTestSkipped', [$message]);
+
+        return $this;
+    }
+
+    /**
+     * Skips the current test if the given test is running on Windows.
+     */
+    public function skipOnWindows(): self
+    {
+        return $this->skipOn('Windows', 'This test is skipped on [Windows].');
+    }
+
+    /**
+     * Skips the current test if the given test is running on Mac OS.
+     */
+    public function skipOnMac(): self
+    {
+        return $this->skipOn('Darwin', 'This test is skipped on [Mac].');
+    }
+
+    /**
+     * Skips the current test if the given test is running on Linux.
+     */
+    public function skipOnLinux(): self
+    {
+        return $this->skipOn('Linux', 'This test is skipped on [Linux].');
+    }
+
+    /**
+     * Skips the current test if the given test is running on the given operating systems.
+     */
+    private function skipOn(string $osFamily, string $message): self
+    {
+        return PHP_OS_FAMILY === $osFamily
+            ? $this->skip($message)
+            : $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;
     }
@@ -190,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) {
@@ -279,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 .= ' → ';
             }
@@ -301,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.1.0';
+    return '2.14.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

@@ -6,10 +6,11 @@ namespace Pest\Plugins;
 
 use Pest\Contracts\Plugins\HandlesArguments;
 use Pest\Support\View;
-use function Pest\version;
 use PHPUnit\TextUI\Help as PHPUnitHelp;
 use Symfony\Component\Console\Output\OutputInterface;
 
+use function Pest\version;
+
 /**
  * @internal
  */
@@ -102,20 +103,27 @@ final class Help implements HandlesArguments
             'desc' => 'Initialise a standard Pest configuration',
         ]], ...$content['Configuration']];
 
-        $content['Selection'] = array_merge([
+        $content['Execution'] = [...[
             [
-                'arg' => '--bail',
-                'desc' => 'Stop execution upon first not-passed test',
+                'arg' => '--parallel',
+                'desc' => 'Run tests in parallel',
             ],
             [
-                'arg' => '--todos',
-                'desc' => 'Output to standard output the list of todos',
+                'arg' => '--update-snapshots',
+                'desc' => 'Update snapshots for tests using the "toMatchSnapshot" expectation',
             ],
-            [
-                'arg' => '--retry',
-                'desc' => 'Run non-passing tests first and stop execution upon first error or failure',
-            ],
-        ], $content['Selection']);
+        ], ...$content['Execution']];
+
+        $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'], ...[
             [
@@ -124,16 +132,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

@@ -26,11 +26,11 @@ final class Init implements HandlesArguments
      * The files that will be created.
      */
     private const STUBS = [
-        'phpunit.xml' => 'phpunit.xml',
-        'Pest.php' => 'tests/Pest.php',
-        'TestCase.php' => 'tests/TestCase.php',
-        'Unit/ExampleTest.php' => 'tests/Unit/ExampleTest.php',
-        'Feature/ExampleTest.php' => 'tests/Feature/ExampleTest.php',
+        'phpunit.xml.stub' => 'phpunit.xml',
+        'Pest.php.stub' => 'tests/Pest.php',
+        'TestCase.php.stub' => 'tests/TestCase.php',
+        'Unit/ExampleTest.php.stub' => 'tests/Unit/ExampleTest.php',
+        'Feature/ExampleTest.php.stub' => 'tests/Feature/ExampleTest.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

@@ -13,16 +13,18 @@ use Pest\Plugins\Parallel\Paratest\CleanConsoleOutput;
 use Pest\Support\Arr;
 use Pest\Support\Container;
 use Pest\TestSuite;
-use function Pest\version;
+use Stringable;
 use Symfony\Component\Console\Application;
-use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Input\ArgvInput;
-use Symfony\Component\Console\Output\OutputInterface;
+
+use function Pest\version;
 
 final class Parallel implements HandlesArguments
 {
     use HandleArguments;
 
+    private const GLOBAL_PREFIX = 'PEST_PARALLEL_GLOBAL_';
+
     private const HANDLERS = [
         Parallel\Handlers\Parallel::class,
         Parallel\Handlers\Pest::class,
@@ -59,6 +61,33 @@ final class Parallel implements HandlesArguments
         return ((int) $argvValue) === 1;
     }
 
+    /**
+     * Sets a global value that can be accessed by the parent process and all workers.
+     */
+    public static function setGlobal(string $key, string|int|bool|Stringable $value): void
+    {
+        $data = ['value' => $value instanceof Stringable ? $value->__toString() : $value];
+
+        $_ENV[self::GLOBAL_PREFIX.$key] = json_encode($data, JSON_THROW_ON_ERROR);
+    }
+
+    /**
+     * Returns the given global value if one has been set.
+     */
+    public static function getGlobal(string $key): string|int|bool|null
+    {
+        $placesToCheck = [$_SERVER, $_ENV];
+
+        foreach ($placesToCheck as $location) {
+            if (array_key_exists(self::GLOBAL_PREFIX.$key, $location)) {
+                // @phpstan-ignore-next-line
+                return json_decode((string) $location[self::GLOBAL_PREFIX.$key], true, 512, JSON_THROW_ON_ERROR)['value'] ?? null;
+            }
+        }
+
+        return null;
+    }
+
     /**
      * {@inheritdoc}
      */
@@ -86,20 +115,14 @@ final class Parallel implements HandlesArguments
      */
     private function runTestSuiteInParallel(array $arguments): int
     {
-        if (! class_exists(ParaTestCommand::class)) {
-            $this->askUserToInstallParatest();
-
-            return Command::FAILURE;
-        }
-
         $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
         );
 
@@ -117,31 +140,17 @@ 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
         );
     }
 
-    /**
-     * Outputs a message to the user asking them to install ParaTest as a dev dependency.
-     */
-    private function askUserToInstallParatest(): void
-    {
-        /** @var OutputInterface $output */
-        $output = Container::getInstance()->get(OutputInterface::class);
-
-        $output->writeln([
-            '<fg=red>Pest Parallel requires ParaTest to run.</>',
-            'Please run <fg=yellow>composer require --dev brianium/paratest</>.',
-        ]);
-    }
-
     /**
      * Builds an instance of the Paratest command.
      */

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

@@ -4,6 +4,16 @@ declare(strict_types=1);
 
 namespace Pest\Plugins\Parallel\Paratest;
 
+use ParaTest\Options;
+use Pest\Plugins\Parallel\Support\CompactPrinter;
+use Pest\Support\StateGenerator;
+use PHPUnit\TestRunner\TestResult\TestResult;
+use PHPUnit\TextUI\Output\Printer;
+use SebastianBergmann\Timer\Duration;
+use SplFileInfo;
+use Symfony\Component\Console\Formatter\OutputFormatter;
+use Symfony\Component\Console\Output\OutputInterface;
+
 use function assert;
 use function fclose;
 use function feof;
@@ -12,20 +22,11 @@ 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 +52,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 +75,7 @@ final class ResultPrinter
                 if (str_starts_with($buffer, 'done [')) {
                     return;
                 }
+
                 $this->output->write(OutputFormatter::escape($buffer));
             }
 
@@ -93,9 +95,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 +120,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 +143,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 +197,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 +215,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

@@ -4,15 +4,9 @@ declare(strict_types=1);
 
 namespace Pest\Plugins\Parallel\Paratest;
 
-use function array_merge;
-use function array_merge_recursive;
-use function array_shift;
-use function assert;
-use function count;
 use const DIRECTORY_SEPARATOR;
-use function dirname;
-use function file_get_contents;
-use function max;
+
+use NunoMaduro\Collision\Adapters\Phpunit\Support\ResultReflection;
 use ParaTest\Coverage\CoverageMerger;
 use ParaTest\JUnit\LogMerger;
 use ParaTest\JUnit\Writer;
@@ -20,19 +14,29 @@ use ParaTest\Options;
 use ParaTest\RunnerInterface;
 use ParaTest\WrapperRunner\SuiteLoader;
 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;
 use PHPUnit\TextUI\Configuration\CodeCoverageFilterRegistry;
-use PHPUnit\TextUI\ShellExitCodeCalculator;
 use PHPUnit\Util\ExcludeList;
-use function realpath;
 use SebastianBergmann\Timer\Timer;
 use SplFileInfo;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Process\PhpExecutableFinder;
+
+use function array_merge;
+use function array_merge_recursive;
+use function array_shift;
+use function assert;
+use function count;
+use function dirname;
+use function file_get_contents;
+use function max;
+use function realpath;
 use function unlink;
 use function unserialize;
 use function usleep;
@@ -48,36 +52,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 +93,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 +107,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 +116,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 +149,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 +167,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 +183,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 +195,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 +218,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)) {
@@ -273,7 +276,7 @@ final class WrapperRunner implements RunnerInterface
             assert($testResult instanceof TestResult);
 
             $testResultSum = new TestResult(
-                $testResultSum->numberOfTests() + $testResult->numberOfTests(),
+                (int) $testResultSum->hasTests() + (int) $testResult->hasTests(),
                 $testResultSum->numberOfTestsRun() + $testResult->numberOfTestsRun(),
                 $testResultSum->numberOfAssertions() + $testResult->numberOfAssertions(),
                 array_merge_recursive($testResultSum->testErroredEvents(), $testResult->testErroredEvents()),
@@ -282,23 +285,23 @@ final class WrapperRunner implements RunnerInterface
                 array_merge_recursive($testResultSum->testSuiteSkippedEvents(), $testResult->testSuiteSkippedEvents()),
                 array_merge_recursive($testResultSum->testSkippedEvents(), $testResult->testSkippedEvents()),
                 array_merge_recursive($testResultSum->testMarkedIncompleteEvents(), $testResult->testMarkedIncompleteEvents()),
-                array_merge_recursive($testResultSum->testTriggeredDeprecationEvents(), $testResult->testTriggeredDeprecationEvents()),
-                array_merge_recursive($testResultSum->testTriggeredPhpDeprecationEvents(), $testResult->testTriggeredPhpDeprecationEvents()),
                 array_merge_recursive($testResultSum->testTriggeredPhpunitDeprecationEvents(), $testResult->testTriggeredPhpunitDeprecationEvents()),
-                array_merge_recursive($testResultSum->testTriggeredErrorEvents(), $testResult->testTriggeredErrorEvents()),
-                array_merge_recursive($testResultSum->testTriggeredNoticeEvents(), $testResult->testTriggeredNoticeEvents()),
-                array_merge_recursive($testResultSum->testTriggeredPhpNoticeEvents(), $testResult->testTriggeredPhpNoticeEvents()),
-                array_merge_recursive($testResultSum->testTriggeredWarningEvents(), $testResult->testTriggeredWarningEvents()),
-                array_merge_recursive($testResultSum->testTriggeredPhpWarningEvents(), $testResult->testTriggeredPhpWarningEvents()),
                 array_merge_recursive($testResultSum->testTriggeredPhpunitErrorEvents(), $testResult->testTriggeredPhpunitErrorEvents()),
                 array_merge_recursive($testResultSum->testTriggeredPhpunitWarningEvents(), $testResult->testTriggeredPhpunitWarningEvents()),
                 array_merge_recursive($testResultSum->testRunnerTriggeredDeprecationEvents(), $testResult->testRunnerTriggeredDeprecationEvents()),
                 array_merge_recursive($testResultSum->testRunnerTriggeredWarningEvents(), $testResult->testRunnerTriggeredWarningEvents()),
+                array_merge_recursive($testResultSum->errors(), $testResult->errors()),
+                array_merge_recursive($testResultSum->deprecations(), $testResult->deprecations()),
+                array_merge_recursive($testResultSum->notices(), $testResult->notices()),
+                array_merge_recursive($testResultSum->warnings(), $testResult->warnings()),
+                array_merge_recursive($testResultSum->phpDeprecations(), $testResult->phpDeprecations()),
+                array_merge_recursive($testResultSum->phpNotices(), $testResult->phpNotices()),
+                array_merge_recursive($testResultSum->phpWarnings(), $testResult->phpWarnings()),
             );
         }
 
         $testResultSum = new TestResult(
-            $testResultSum->numberOfTests(),
+            ResultReflection::numberOfTests($testResultSum),
             $testResultSum->numberOfTestsRun(),
             $testResultSum->numberOfAssertions(),
             $testResultSum->testErroredEvents(),
@@ -307,18 +310,21 @@ final class WrapperRunner implements RunnerInterface
             $testResultSum->testSuiteSkippedEvents(),
             $testResultSum->testSkippedEvents(),
             $testResultSum->testMarkedIncompleteEvents(),
-            $testResultSum->testTriggeredDeprecationEvents(),
-            $testResultSum->testTriggeredPhpDeprecationEvents(),
             $testResultSum->testTriggeredPhpunitDeprecationEvents(),
-            $testResultSum->testTriggeredErrorEvents(),
-            $testResultSum->testTriggeredNoticeEvents(),
-            $testResultSum->testTriggeredPhpNoticeEvents(),
-            $testResultSum->testTriggeredWarningEvents(),
-            $testResultSum->testTriggeredPhpWarningEvents(),
             $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')
+            )),
+            $testResultSum->errors(),
+            $testResultSum->deprecations(),
+            $testResultSum->notices(),
+            $testResultSum->warnings(),
+            $testResultSum->phpDeprecations(),
+            $testResultSum->phpNotices(),
+            $testResultSum->phpWarnings(),
         );
 
         $this->printer->printResults(
@@ -330,22 +336,16 @@ final class WrapperRunner implements RunnerInterface
         $this->generateCodeCoverageReports();
         $this->generateLogs();
 
-        $exitCode = (new ShellExitCodeCalculator())->calculate(
-            $this->options->configuration->failOnEmptyTestSuite(),
-            $this->options->configuration->failOnRisky(),
-            $this->options->configuration->failOnWarning(),
-            $this->options->configuration->failOnIncomplete(),
-            $this->options->configuration->failOnSkipped(),
-            $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
@@ -355,10 +355,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);
@@ -383,7 +384,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) {
@@ -398,31 +399,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/Parallel/Support/CompactPrinter.php

@@ -7,6 +7,7 @@ namespace Pest\Plugins\Parallel\Support;
 use NunoMaduro\Collision\Adapters\Phpunit\State;
 use NunoMaduro\Collision\Adapters\Phpunit\Style;
 use ParaTest\Options;
+use PHPUnit\Event\Telemetry\GarbageCollectorStatus;
 use PHPUnit\Event\Telemetry\HRTime;
 use PHPUnit\Event\Telemetry\Info;
 use PHPUnit\Event\Telemetry\MemoryUsage;
@@ -15,8 +16,9 @@ use PHPUnit\TestRunner\TestResult\TestResult as PHPUnitTestResult;
 use SebastianBergmann\Timer\Duration;
 use Symfony\Component\Console\Output\ConsoleOutput;
 use Symfony\Component\Console\Output\OutputInterface;
-use function Termwind\render;
 use Termwind\Terminal;
+
+use function Termwind\render;
 use function Termwind\terminal;
 
 /**
@@ -122,11 +124,29 @@ final class CompactPrinter
         $snapshotDuration = HRTime::fromSecondsAndNanoseconds((int) $duration->asSeconds(), $nanoseconds);
         $telemetryDuration = \PHPUnit\Event\Telemetry\Duration::fromSecondsAndNanoseconds((int) $duration->asSeconds(), $nanoseconds);
 
+        $status = gc_status();
+
+        $garbageCollectorStatus = new GarbageCollectorStatus(
+            $status['runs'],
+            $status['collected'],
+            $status['threshold'],
+            $status['roots'],
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+        );
+
         $telemetry = new Info(
             new Snapshot(
                 $snapshotDuration,
                 MemoryUsage::fromBytes(0),
                 MemoryUsage::fromBytes(0),
+                $garbageCollectorStatus,
             ),
             $telemetryDuration,
             MemoryUsage::fromBytes(0),

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/Plugins/Version.php

@@ -6,6 +6,7 @@ namespace Pest\Plugins;
 
 use Pest\Contracts\Plugins\HandlesArguments;
 use Pest\Support\View;
+
 use function Pest\version;
 
 /**

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

@@ -10,9 +10,10 @@ use Pest\Exceptions\DatasetAlreadyExists;
 use Pest\Exceptions\DatasetDoesNotExist;
 use Pest\Exceptions\ShouldNotHappen;
 use Pest\Support\Exporter;
-use function sprintf;
 use Traversable;
 
+use function sprintf;
+
 /**
  * @internal
  */
@@ -66,11 +67,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 +90,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 +139,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 +194,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) {
@@ -235,6 +236,6 @@ final class DatasetsRepository
             return sprintf('(%s)', $exporter->shortenedRecursiveExport($data));
         }
 
-        return sprintf('data set "%s"', $key);
+        return sprintf('dataset "%s"', $key);
     }
 }

src/Repositories/SnapshotRepository.php

@@ -0,0 +1,141 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Repositories;
+
+use Pest\Exceptions\ShouldNotHappen;
+use Pest\TestSuite;
+
+/**
+ * @internal
+ */
+final class SnapshotRepository
+{
+    /** @var array<string, int> */
+    private static array $expectationsCounter = [];
+
+    /**
+     * Creates a snapshot repository instance.
+     */
+    public function __construct(
+        readonly private string $testsPath,
+        readonly private string $snapshotsPath,
+    ) {
+    }
+
+    /**
+     * Checks if the snapshot exists.
+     */
+    public function has(): bool
+    {
+        return file_exists($this->getSnapshotFilename());
+    }
+
+    /**
+     * Gets the snapshot.
+     *
+     * @return array{0: string, 1: string}
+     *
+     * @throws ShouldNotHappen
+     */
+    public function get(): array
+    {
+        $contents = file_get_contents($snapshotFilename = $this->getSnapshotFilename());
+
+        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(string $snapshot): string
+    {
+        $snapshotFilename = $this->getSnapshotFilename();
+
+        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".
+     */
+    private function getSnapshotFilename(): string
+    {
+        $relativePath = str_replace($this->testsPath, '', TestSuite::getInstance()->getFilename());
+
+        // remove extension from filename
+        $relativePath = substr($relativePath, 0, (int) strrpos($relativePath, '.'));
+
+        $description = TestSuite::getInstance()->getDescription();
+
+        if ($this->getCurrentSnapshotCounter() > 1) {
+            $description .= '__'.$this->getCurrentSnapshotCounter();
+        }
+
+        return sprintf('%s/%s.snap', $this->testsPath.'/'.$this->snapshotsPath.$relativePath, $description);
+    }
+
+    private function getCurrentSnapshotKey(): string
+    {
+        return TestSuite::getInstance()->getFilename().'###'.TestSuite::getInstance()->getDescription();
+    }
+
+    private function getCurrentSnapshotCounter(): int
+    {
+        return self::$expectationsCounter[$this->getCurrentSnapshotKey()] ?? 0;
+    }
+
+    public function startNewExpectation(): void
+    {
+        $key = $this->getCurrentSnapshotKey();
+
+        if (! isset(self::$expectationsCounter[$key])) {
+            self::$expectationsCounter[$key] = 0;
+        }
+
+        self::$expectationsCounter[$key]++;
+    }
+}

src/Result.php

@@ -4,8 +4,9 @@ declare(strict_types=1);
 
 namespace Pest;
 
-use PHPUnit\TestRunner\TestResult\Facade;
-use PHPUnit\TextUI\Configuration\Registry;
+use NunoMaduro\Collision\Adapters\Phpunit\Support\ResultReflection;
+use PHPUnit\TestRunner\TestResult\TestResult;
+use PHPUnit\TextUI\Configuration\Configuration;
 
 /**
  * @internal
@@ -21,37 +22,31 @@ final class Result
     /**
      * If the exit code is different from 0.
      */
-    public static function failed(): bool
+    public static function failed(Configuration $configuration, TestResult $result): bool
     {
-        return ! self::ok();
+        return ! self::ok($configuration, $result);
     }
 
     /**
      * If the exit code is exactly 0.
      */
-    public static function ok(): bool
+    public static function ok(Configuration $configuration, TestResult $result): bool
     {
-        return self::exitCode() === self::SUCCESS_EXIT;
+        return self::exitCode($configuration, $result) === self::SUCCESS_EXIT;
     }
 
     /**
      * Get the test execution's exit code.
      */
-    public static function exitCode(): int
+    public static function exitCode(Configuration $configuration, TestResult $result): int
     {
-        $result = Facade::result();
-
-        $returnCode = self::FAILURE_EXIT;
-
         if ($result->wasSuccessfulIgnoringPhpunitWarnings()
             && ! $result->hasTestTriggeredPhpunitWarningEvents()) {
-            $returnCode = self::SUCCESS_EXIT;
+            return self::SUCCESS_EXIT;
         }
 
-        $configuration = Registry::get();
-
-        if ($configuration->failOnEmptyTestSuite() && $result->numberOfTests() === 0) {
-            $returnCode = self::FAILURE_EXIT;
+        if ($configuration->failOnEmptyTestSuite() && ResultReflection::numberOfTests($result) === 0) {
+            return self::FAILURE_EXIT;
         }
 
         if ($result->wasSuccessfulIgnoringPhpunitWarnings()) {
@@ -59,9 +54,9 @@ final class Result
                 $returnCode = self::FAILURE_EXIT;
             }
 
-            $warnings = $result->numberOfTestsWithTestTriggeredPhpunitWarningEvents()
-                + $result->numberOfTestsWithTestTriggeredWarningEvents()
-                + $result->numberOfTestsWithTestTriggeredPhpWarningEvents();
+            $warnings = $result->numberOfTestsWithTestTriggeredPhpunitWarningEvents() +
+                +count($result->warnings())
+                + count($result->phpWarnings());
 
             if ($configuration->failOnWarning() && $warnings > 0) {
                 $returnCode = self::FAILURE_EXIT;
@@ -80,6 +75,6 @@ final class Result
             return self::EXCEPTION_EXIT;
         }
 
-        return $returnCode;
+        return self::FAILURE_EXIT;
     }
 }

src/Support/Backtrace.php

@@ -30,7 +30,10 @@ final class Backtrace
 
             $traceFile = str_replace(DIRECTORY_SEPARATOR, '/', $trace[self::FILE]);
 
-            if (Str::endsWith($traceFile, 'overrides/Runner/TestSuiteLoader.php')) {
+            if (
+                Str::endsWith($traceFile, 'overrides/Runner/TestSuiteLoader.php') ||
+                Str::endsWith($traceFile, 'src/Bootstrappers/BootFiles.php')
+            ) {
                 break;
             }
 
@@ -75,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];
     }
@@ -87,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]);
     }
@@ -99,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/Container.php

@@ -25,7 +25,7 @@ final class Container
      */
     public static function getInstance(): self
     {
-        if (self::$instance === null) {
+        if (! self::$instance instanceof \Pest\Support\Container) {
             self::$instance = new self();
         }
 
@@ -72,7 +72,7 @@ final class Container
         if ($reflectionClass->isInstantiable()) {
             $constructor = $reflectionClass->getConstructor();
 
-            if ($constructor !== null) {
+            if ($constructor instanceof \ReflectionMethod) {
                 $params = array_map(
                     function (ReflectionParameter $param) use ($id): object|string {
                         $candidate = Reflection::getParameterClassName($param);
@@ -80,7 +80,7 @@ final class Container
                         if ($candidate === null) {
                             $type = $param->getType();
                             /* @phpstan-ignore-next-line */
-                            if ($type !== null && $type->isBuiltin()) {
+                            if ($type instanceof \ReflectionType && $type->isBuiltin()) {
                                 $candidate = $param->getName();
                             } else {
                                 throw ShouldNotHappen::fromMessage(sprintf('The type of `$%s` in `%s` cannot be determined.', $id, $param->getName()));

src/Support/Coverage.php

@@ -10,6 +10,7 @@ use SebastianBergmann\CodeCoverage\Node\Directory;
 use SebastianBergmann\CodeCoverage\Node\File;
 use SebastianBergmann\Environment\Runtime;
 use Symfony\Component\Console\Output\OutputInterface;
+
 use function Termwind\render;
 use function Termwind\renderUsing;
 use function Termwind\terminal;
@@ -42,6 +43,14 @@ final class Coverage
             return false;
         }
 
+        if ($runtime->hasPCOV()) {
+            return true;
+        }
+
+        if ($runtime->hasPHPDBGCodeCoverage()) {
+            return true;
+        }
+
         if (! $runtime->hasXdebug()) {
             return true;
         }
@@ -151,10 +160,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

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Pest\Support;
 
 use Closure;
+use PHPUnit\Framework\TestCase;
 use Throwable;
 
 /**
@@ -15,21 +16,24 @@ final class ExceptionTrace
     private const UNDEFINED_METHOD = 'Call to undefined method P\\';
 
     /**
-     * Ensures the given closure reports
-     * the good execution context.
-     *
-     * @return mixed
+     * Ensures the given closure reports the good execution context.
      *
      * @throws Throwable
      */
-    public static function ensure(Closure $closure)
+    public static function ensure(Closure $closure): mixed
     {
         try {
             return $closure();
         } catch (Throwable $throwable) {
             if (Str::startsWith($message = $throwable->getMessage(), self::UNDEFINED_METHOD)) {
+                $class = preg_match('/^Call to undefined method ([^:]+)::/', $message, $matches) === false ? null : $matches[1];
+
                 $message = str_replace(self::UNDEFINED_METHOD, 'Call to undefined method ', $message);
 
+                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';
+                }
+
                 Reflection::setPropertyValue($throwable, 'message', $message);
             }
 

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/Support/StateGenerator.php

@@ -24,7 +24,7 @@ final class StateGenerator
 
         foreach ($testResult->testErroredEvents() as $testResultEvent) {
             if ($testResultEvent instanceof Errored) {
-                $state->add(TestResult::fromTestCase(
+                $state->add(TestResult::fromPestParallelTestCase(
                     $testResultEvent->test(),
                     TestResult::FAIL,
                     $testResultEvent->throwable()
@@ -35,7 +35,7 @@ final class StateGenerator
         }
 
         foreach ($testResult->testFailedEvents() as $testResultEvent) {
-            $state->add(TestResult::fromTestCase(
+            $state->add(TestResult::fromPestParallelTestCase(
                 $testResultEvent->test(),
                 TestResult::FAIL,
                 $testResultEvent->throwable()
@@ -43,7 +43,7 @@ final class StateGenerator
         }
 
         foreach ($testResult->testMarkedIncompleteEvents() as $testResultEvent) {
-            $state->add(TestResult::fromTestCase(
+            $state->add(TestResult::fromPestParallelTestCase(
                 $testResultEvent->test(),
                 TestResult::INCOMPLETE,
                 $testResultEvent->throwable()
@@ -52,7 +52,7 @@ final class StateGenerator
 
         foreach ($testResult->testConsideredRiskyEvents() as $riskyEvents) {
             foreach ($riskyEvents as $riskyEvent) {
-                $state->add(TestResult::fromTestCase(
+                $state->add(TestResult::fromPestParallelTestCase(
                     $riskyEvent->test(),
                     TestResult::RISKY,
                     ThrowableBuilder::from(new TestOutcome($riskyEvent->message()))
@@ -62,85 +62,97 @@ final class StateGenerator
 
         foreach ($testResult->testSkippedEvents() as $testResultEvent) {
             if ($testResultEvent->message() === '__TODO__') {
-                $state->add(TestResult::fromTestCase($testResultEvent->test(), TestResult::TODO));
+                $state->add(TestResult::fromPestParallelTestCase($testResultEvent->test(), TestResult::TODO));
 
                 continue;
             }
 
-            $state->add(TestResult::fromTestCase(
+            $state->add(TestResult::fromPestParallelTestCase(
                 $testResultEvent->test(),
                 TestResult::SKIPPED,
                 ThrowableBuilder::from(new SkippedWithMessageException($testResultEvent->message()))
             ));
         }
 
-        foreach ($testResult->testTriggeredDeprecationEvents() as $testResultEvent) {
-            $testResultEvent = $testResultEvent[0];
+        foreach ($testResult->deprecations() as $testResultEvent) {
+            foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
+                ['test' => $test] = $triggeringTest;
 
-            $state->add(TestResult::fromTestCase(
-                $testResultEvent->test(),
-                TestResult::DEPRECATED,
-                ThrowableBuilder::from(new TestOutcome($testResultEvent->message()))
-            ));
+                $state->add(TestResult::fromPestParallelTestCase(
+                    $test,
+                    TestResult::DEPRECATED,
+                    ThrowableBuilder::from(new TestOutcome($testResultEvent->description()))
+                ));
+            }
         }
 
-        foreach ($testResult->testTriggeredPhpDeprecationEvents() as $testResultEvent) {
-            $testResultEvent = $testResultEvent[0];
+        foreach ($testResult->phpDeprecations() as $testResultEvent) {
+            foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
+                ['test' => $test] = $triggeringTest;
 
-            $state->add(TestResult::fromTestCase(
-                $testResultEvent->test(),
-                TestResult::DEPRECATED,
-                ThrowableBuilder::from(new TestOutcome($testResultEvent->message()))
-            ));
+                $state->add(TestResult::fromPestParallelTestCase(
+                    $test,
+                    TestResult::DEPRECATED,
+                    ThrowableBuilder::from(new TestOutcome($testResultEvent->description()))
+                ));
+            }
         }
 
-        foreach ($testResult->testTriggeredNoticeEvents() as $testResultEvent) {
-            $testResultEvent = $testResultEvent[0];
+        foreach ($testResult->notices() as $testResultEvent) {
+            foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
+                ['test' => $test] = $triggeringTest;
 
-            $state->add(TestResult::fromTestCase(
-                $testResultEvent->test(),
-                TestResult::NOTICE,
-                ThrowableBuilder::from(new TestOutcome($testResultEvent->message()))
-            ));
+                $state->add(TestResult::fromPestParallelTestCase(
+                    $test,
+                    TestResult::NOTICE,
+                    ThrowableBuilder::from(new TestOutcome($testResultEvent->description()))
+                ));
+            }
         }
 
-        foreach ($testResult->testTriggeredPhpNoticeEvents() as $testResultEvent) {
-            $testResultEvent = $testResultEvent[0];
+        foreach ($testResult->phpNotices() as $testResultEvent) {
+            foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
+                ['test' => $test] = $triggeringTest;
 
-            $state->add(TestResult::fromTestCase(
-                $testResultEvent->test(),
-                TestResult::NOTICE,
-                ThrowableBuilder::from(new TestOutcome($testResultEvent->message()))
-            ));
+                $state->add(TestResult::fromPestParallelTestCase(
+                    $test,
+                    TestResult::NOTICE,
+                    ThrowableBuilder::from(new TestOutcome($testResultEvent->description()))
+                ));
+            }
         }
 
-        foreach ($testResult->testTriggeredWarningEvents() as $testResultEvent) {
-            $testResultEvent = $testResultEvent[0];
+        foreach ($testResult->warnings() as $testResultEvent) {
+            foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
+                ['test' => $test] = $triggeringTest;
 
-            $state->add(TestResult::fromTestCase(
-                $testResultEvent->test(),
-                TestResult::WARN,
-                ThrowableBuilder::from(new TestOutcome($testResultEvent->message()))
-            ));
+                $state->add(TestResult::fromPestParallelTestCase(
+                    $test,
+                    TestResult::WARN,
+                    ThrowableBuilder::from(new TestOutcome($testResultEvent->description()))
+                ));
+            }
         }
 
-        foreach ($testResult->testTriggeredPhpWarningEvents() as $testResultEvent) {
-            $testResultEvent = $testResultEvent[0];
+        foreach ($testResult->phpWarnings() as $testResultEvent) {
+            foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
+                ['test' => $test] = $triggeringTest;
 
-            $state->add(TestResult::fromTestCase(
-                $testResultEvent->test(),
-                TestResult::WARN,
-                ThrowableBuilder::from(new TestOutcome($testResultEvent->message()))
-            ));
+                $state->add(TestResult::fromPestParallelTestCase(
+                    $test,
+                    TestResult::WARN,
+                    ThrowableBuilder::from(new TestOutcome($testResultEvent->description()))
+                ));
+            }
         }
 
         // for each test that passed, we need to add it to the state
         for ($i = 0; $i < $passedTests; $i++) {
-            $state->add(TestResult::fromTestCase(
+            $state->add(TestResult::fromPestParallelTestCase(
                 new TestMethod(
                     "$i", // @phpstan-ignore-line
                     '', // @phpstan-ignore-line
-                    '',
+                    '', // @phpstan-ignore-line
                     1,
                     TestDoxBuilder::fromClassNameAndMethodName('', ''), // @phpstan-ignore-line
                     MetadataCollection::fromArray([]),

src/Support/Str.php

@@ -59,6 +59,8 @@ final class Str
      */
     public static function evaluable(string $code): string
     {
+        $code = str_replace('_', '__', $code);
+
         $code = self::PREFIX.str_replace(' ', '_', $code);
 
         // sticks to PHP8.2 function naming rules https://www.php.net/manual/en/functions.user-defined.php

src/Support/View.php

@@ -5,9 +5,10 @@ declare(strict_types=1);
 namespace Pest\Support;
 
 use Symfony\Component\Console\Output\OutputInterface;
+use Termwind\Termwind;
+
 use function Termwind\render;
 use function Termwind\renderUsing;
-use Termwind\Termwind;
 
 /**
  * @internal

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)
     {
@@ -32,6 +32,7 @@ final class GitDirtyTestCaseFilter implements TestCaseFilter
         assert(is_array($this->changedFiles));
 
         $relativePath = str_replace($this->projectRoot, '', $testCaseFilename);
+        $relativePath = str_replace(DIRECTORY_SEPARATOR, '/', $relativePath);
 
         if (str_starts_with($relativePath, '/')) {
             $relativePath = substr($relativePath, 1);
@@ -58,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,7 +9,9 @@ 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 Pest\Support\Str;
 use PHPUnit\Framework\TestCase;
 
 /**
@@ -47,6 +49,11 @@ final class TestSuite
      */
     public AfterAllRepository $afterAll;
 
+    /**
+     * Holds the snapshots repository.
+     */
+    public SnapshotRepository $snapshots;
+
     /**
      * Holds the root path.
      */
@@ -69,8 +76,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']),
+        );
     }
 
     /**
@@ -96,4 +106,28 @@ final class TestSuite
 
         return self::$instance;
     }
+
+    public function getFilename(): string
+    {
+        assert($this->test instanceof TestCase);
+
+        return (fn () => self::$__filename)->call($this->test, $this->test::class); // @phpstan-ignore-line
+    }
+
+    public function getDescription(): string
+    {
+        assert($this->test instanceof TestCase);
+
+        $description = str_replace('__pest_evaluable_', '', $this->test->name());
+        $datasetAsString = str_replace('__pest_evaluable_', '', Str::evaluable($this->test->dataSetAsStringWithData()));
+
+        return str_replace(' ', '_', $description.$datasetAsString);
+    }
+
+    public function registerSnapshotChange(string $message): void
+    {
+        assert($this->test instanceof TestCase);
+
+        (fn (): string => $this->__snapshotChanges[] = $message)->call($this->test, $this->test::class); // @phpstan-ignore-line
+    }
 }

tests/.pest/snapshots/Features/Expect/toMatchSnapshot/_describable__→_multiple_snapshot_expectations_with_describe.snap

@@ -0,0 +1 @@
+foo bar 1

tests/.pest/snapshots/Features/Expect/toMatchSnapshot/_describable__→_multiple_snapshot_expectations_with_describe__2.snap

@@ -0,0 +1 @@
+foo bar 2

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/multiple_snapshot_expectations.snap

@@ -0,0 +1 @@
+foo bar 1

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

@@ -0,0 +1 @@
+foo bar 2

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

@@ -0,0 +1 @@
+foo bar 1

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

@@ -0,0 +1 @@
+foo bar 2