release: v2.24.0

[2.x] Add `throwsUnless`

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,66 @@
+name: Bug Report
+description: Report an Issue or Bug with the Pest
+title: "[Bug]: "
+labels: ["bug"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        We're sorry to hear you have a problem. Can you help us solve it by providing the following details.
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: What Happened
+      description: What did you expect to happen?
+      placeholder: When I use expect()->toBeTrue() in my tests, I get an error
+    validations:
+      required: true
+  - type: textarea
+    id: how-to-reproduce
+    attributes:
+      label: How to Reproduce
+      description: How did this occur, please add any config values used and provide a set of reliable steps if possible.
+      placeholder: Install a fresh Laravel app, add Pest, add a test that uses expect()->toBeTrue()
+    validations:
+      required: true
+  - type: input
+    id: repository-sample
+    attributes:
+      label: Sample Repository
+      description: If possible, please provide a sample repository that reproduces the issue.
+      placeholder: https://github.com.br/your-username/your-repository
+  - type: input
+    id: pest-version
+    attributes:
+      label: Pest Version
+      description: What version of our Package are you running? Please be as specific as possible
+      placeholder: 2.14.1
+    validations:
+      required: true
+  - type: input
+    id: php-version
+    attributes:
+      label: PHP Version
+      description: What version of PHP are you running? Please be as specific as possible
+      placeholder: 8.1.20
+    validations:
+      required: true
+  - type: dropdown
+    id: operating-systems
+    attributes:
+      label: Operation System
+      description: On which operating systems does the problem occur? You can select more than one.
+      multiple: true
+      options:
+        - macOS
+        - Windows
+        - Linux
+    validations:
+      required: true
+  - type: textarea
+    id: notes
+    attributes:
+      label: Notes
+      description: Use this field to provide any other notes that you feel might be relevant to the issue.
+    validations:
+      required: false

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,10 +1,16 @@
-| Q             | A
-| ------------- | ---
-| Bug fix?      | yes/no
-| New feature?  | yes/no
-| Fixed tickets | #... <!-- #-prefixed issue number(s), if any -->
-
 <!--
-- Replace this comment by a description of what your PR is solving.
+- Fill in the form below correctly. This will help the Pest team to understand the PR and also work on it.
 -->
 
+### What:
+
+- [ ] Bug Fix
+- [ ] New Feature
+
+### Description:
+
+<!-- describe what your PR is solving -->
+
+### Related:
+
+<!-- link to the issue(s) your PR is solving. If it doesn't exist, remove the "Related" section. -->

.github/workflows/integration-tests.yml

@@ -20,7 +20,7 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
 
     - name: Setup PHP
       uses: shivammathur/setup-php@v2

.github/workflows/static.yml

@@ -18,7 +18,7 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
 
     - name: Setup PHP
       uses: shivammathur/setup-php@v2

.github/workflows/tests.yml

@@ -14,14 +14,14 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        php: ['8.1', '8.2']
+        php: ['8.1', '8.2', '8.3']
         dependency-version: [prefer-lowest, prefer-stable]
 
     name: PHP ${{ matrix.php }} - ${{ matrix.os }} - ${{ matrix.dependency-version }}
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
 
     - name: Setup PHP
       uses: shivammathur/setup-php@v2

CHANGELOG.md

@@ -1,172 +0,0 @@
-# Release Notes for 2.x
-
-## Unreleased
-
-## [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
-- `only` test case method ([bcd1503](https://github.com/pestphp/pest/commit/bcd1503cade938853a55c1283b02b6b820ea0b69))
-
-### Fixed
-- Issues with different characters on test names ([715](https://github.com/pestphp/pest/pull/715))
-
-## [v2.0.2 (2023-03-20)](https://github.com/pestphp/pest/compare/v2.0.1...v2.0.2)
-
-### Fixed
-- `Pest.php` not being loaded in certain scenarios ([b887116](https://github.com/pestphp/pest/commit/b887116e5ce9a69403ad620cad20f0a029474eb5))
-
-## [v2.0.1 (2023-03-20)](https://github.com/pestphp/pest/compare/v2.0.0...v2.0.1)
-
-### Fixed
-- Wrong `version` configuration key on `composer.json` ([8f91f40](https://github.com/pestphp/pest/commit/8f91f40e8ea8b35e04b7989bed6a8f9439e2a2d6))
-
-## [v2.0.0 (2023-03-20)](https://github.com/pestphp/pest/compare/v1.22.6...v2.0.0)
-
-Please consult the [upgrade guide](https://pestphp.com/docs/upgrade-guide) and [release notes](https://pestphp.com/docs/announcing-pest2) in the official Pest documentation.

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)
-- [Fathom Analytics](https://usefathom.com/)
 - [Meema](https://meema.io)
 - [Zapiet](https://www.zapiet.com)
 

RELEASE.md

@@ -5,10 +5,10 @@ When releasing a new version of Pest there are some checks and updates that need
 > **For Pest v1 you should use the `1.x` branch instead.**
 
 - Clear your local repository with: `git add . && git reset --hard && git checkout 2.x`
-- On the GitHub repository, check the contents of [github.com/pestphp/pest/compare/{latest_version}...2.x](https://github.com/pestphp/pest/compare/{latest_version}...master) and update the [changelog](CHANGELOG.md) file with the main changes for this release
+- On the GitHub repository, check the contents of [github.com/pestphp/pest/compare/{latest_version}...2.x](https://github.com/pestphp/pest/compare/{latest_version}...2.x)
 - Update the version number in [src/Pest.php](src/Pest.php)
 - Run the tests locally using: `composer test`
-- Commit the CHANGELOG and Pest file with the message: `git commit -m "release: vX.X.X"`
+- Commit the Pest file with the message: `git commit -m "release: vX.X.X"`
 - Push the changes to GitHub
 - Check that the CI is passing as expected: [github.com/pestphp/pest/actions](https://github.com/pestphp/pest/actions)
 - Tag and push the tag with `git tag vX.X.X && git push --tags`

bin/worker.php

@@ -46,6 +46,7 @@ $bootPest = (static function (): void {
     ];
 
     foreach ($composerAutoloadFiles as $file) {
+
         if (file_exists($file)) {
             require_once $file;
             define('PHPUNIT_COMPOSER_INSTALL', $file);

composer.json

@@ -18,16 +18,17 @@
     ],
     "require": {
         "php": "^8.1.0",
-        "brianium/paratest": "^7.2.3",
-        "nunomaduro/collision": "^7.7.0",
-        "nunomaduro/termwind": "^1.15.1",
-        "pestphp/pest-plugin": "^2.0.1",
-        "pestphp/pest-plugin-arch": "^2.2.3",
-        "phpunit/phpunit": "^10.2.6"
+        "brianium/paratest": "^7.3.0",
+        "nunomaduro/collision": "^7.10.0|^8.0.0",
+        "nunomaduro/termwind": "^1.15.1|^2.0.0",
+        "pestphp/pest-plugin": "^2.1.1",
+        "pestphp/pest-plugin-arch": "^2.4.1",
+        "phpunit/phpunit": "^10.4.1"
     },
     "conflict": {
-        "webmozart/assert": "<1.11.0",
-        "phpunit/phpunit": ">10.2.6"
+        "phpunit/phpunit": ">10.4.1",
+        "sebastian/exporter": "<5.1.0",
+        "webmozart/assert": "<1.11.0"
     },
     "autoload": {
         "psr-4": {
@@ -42,6 +43,7 @@
         "psr-4": {
             "Tests\\Fixtures\\Covers\\": "tests/Fixtures/Covers",
             "Tests\\Fixtures\\Inheritance\\": "tests/Fixtures/Inheritance",
+            "Tests\\Fixtures\\Arch\\": "tests/Fixtures/Arch",
             "Tests\\": "tests/PHPUnit/"
         },
         "files": [
@@ -49,9 +51,9 @@
         ]
     },
     "require-dev": {
-        "pestphp/pest-dev-tools": "^2.12.0",
-        "pestphp/pest-plugin-type-coverage": "^2.0.0",
-        "symfony/process": "^6.3.2"
+        "pestphp/pest-dev-tools": "^2.16.0",
+        "pestphp/pest-plugin-type-coverage": "^2.4.0",
+        "symfony/process": "^6.3.4"
     },
     "minimum-stability": "dev",
     "prefer-stable": true,

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;
 

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

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);
         }
@@ -115,7 +132,7 @@ final class TestSuiteLoader
                     continue;
                 }
 
-                if ($class->isAbstract() || ($class->getFileName() !== $suiteClassFile)) {
+                if ($class->isAbstract() || ($suiteClassFile !== $class->getFileName())) {
                     if (! str_contains($class->getFileName(), 'TestCaseFactory.php')) {
                         continue;
                     }

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
  */

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
  */
@@ -77,6 +78,8 @@ final class BootFiles implements Bootstrapper
 
     private function bootDatasets(string $testsPath): void
     {
+        assert(strlen($testsPath) > 0);
+
         $files = (new PhpUnitFileIterator)->getFilesAsArray($testsPath, '.php');
 
         foreach ($files as $file) {

src/Concerns/Testable.php

@@ -62,6 +62,11 @@ trait Testable
      */
     private static ?Closure $__afterAll = null;
 
+    /**
+     * The list of snapshot changes, if any.
+     */
+    private array $__snapshotChanges = [];
+
     /**
      * Resets the test case static properties.
      */
@@ -331,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/Console/Thanks.php

@@ -23,9 +23,10 @@ final class Thanks
      * @var array<string, string>
      */
     private const FUNDING_MESSAGES = [
-        'Star the project on GitHub' => 'https://github.com/pestphp/pest',
-        'Tweet about the project' => 'https://twitter.com/pestphp',
-        'Sponsor the project' => 'https://github.com/sponsors/nunomaduro',
+        'Star' => 'https://github.com/pestphp/pest',
+        'News' => 'https://twitter.com/pestphp',
+        'Videos' => 'https://youtube.com/@nunomaduro',
+        'Sponsor' => 'https://github.com/sponsors/nunomaduro',
     ];
 
     /**

src/Exceptions/NoDirtyTestsFound.php

@@ -14,7 +14,7 @@ use Symfony\Component\Console\Output\OutputInterface;
 /**
  * @internal
  */
-final class NoDirtyTestsFound extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace, Panicable
+final class NoDirtyTestsFound extends InvalidArgumentException implements ExceptionInterface, Panicable, RenderlessEditor, RenderlessTrace
 {
     /**
      * Renders the panic on the given output.

src/Expectation.php

@@ -4,8 +4,11 @@ declare(strict_types=1);
 
 namespace Pest;
 
+use Attribute;
 use BadMethodCallException;
 use Closure;
+use InvalidArgumentException;
+use OutOfRangeException;
 use Pest\Arch\Contracts\ArchExpectation;
 use Pest\Arch\Expectations\Targeted;
 use Pest\Arch\Expectations\ToBeUsedIn;
@@ -28,7 +31,6 @@ 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;
 
 /**
@@ -127,6 +129,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.
      *
@@ -185,30 +221,26 @@ final class Expectation
             throw new BadMethodCallException('Expectation value is not iterable.');
         }
 
-        $value = is_array($this->value) ? $this->value : iterator_to_array($this->value);
-        $keys = array_keys($value);
-        $values = array_values($value);
-        $callbacksCount = count($callbacks);
-
-        $index = 0;
-
-        while (count($callbacks) < count($values)) {
-            $callbacks[] = $callbacks[$index];
-            $index = $index < count($values) - 1 ? $index + 1 : 0;
+        if (count($callbacks) == 0) {
+            throw new InvalidArgumentException('No sequence expectations defined.');
         }
 
-        if ($callbacksCount > count($values)) {
-            Assert::assertLessThanOrEqual(count($value), count($callbacks));
-        }
+        $index = $valuesCount = 0;
 
-        foreach ($values as $key => $item) {
-            if ($callbacks[$key] instanceof Closure) {
-                call_user_func($callbacks[$key], new self($item), new self($keys[$key]));
+        foreach ($this->value as $key => $value) {
+            $valuesCount++;
 
-                continue;
+            if ($callbacks[$index] instanceof Closure) {
+                $callbacks[$index](new self($value), new self($key));
+            } else {
+                (new self($value))->toEqual($callbacks[$index]);
             }
 
-            (new self($item))->toEqual($callbacks[$key]);
+            $index = isset($callbacks[$index + 1]) ? $index + 1 : 0;
+        }
+
+        if ($valuesCount < count($callbacks)) {
+            throw new OutOfRangeException('Sequence expectations are more than the iterable items.');
         }
 
         return $this;
@@ -430,7 +462,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && $object->reflectionClass->isReadOnly(),
+            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')),
         );
@@ -470,6 +502,19 @@ final class Expectation
         );
     }
 
+    /**
+     * Asserts that the given expectation target has a specific method.
+     */
+    public function toHaveMethod(string $method): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->hasMethod($method),
+            'to have method',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
     /**
      * Asserts that the given expectation target is enum.
      */
@@ -593,14 +638,14 @@ final class Expectation
     }
 
     /**
-     * Asserts that the given expectation target to have the given suffix.
+     * Asserts that the given expectation target to have the given prefix.
      */
-    public function toHavePrefix(string $suffix): ArchExpectation
+    public function toHavePrefix(string $prefix): ArchExpectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => str_starts_with($object->reflectionClass->getName(), $suffix),
-            "to have prefix '{$suffix}'",
+            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')),
         );
     }
@@ -693,4 +738,144 @@ 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'))
+        );
+    }
+
+    /**
+     * Asserts that the given expectation is iterable and contains snake_case keys.
+     *
+     * @return self<TValue>
+     */
+    public function toHaveSnakeCaseKeys(string $message = ''): self
+    {
+        if (! is_iterable($this->value)) {
+            InvalidExpectationValue::expected('iterable');
+        }
+
+        foreach ($this->value as $k => $item) {
+            if (is_string($k)) {
+                $this->and($k)->toBeSnakeCase($message);
+            }
+
+            if (is_array($item)) {
+                $this->and($item)->toHaveSnakeCaseKeys($message);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the given expectation is iterable and contains kebab-case keys.
+     *
+     * @return self<TValue>
+     */
+    public function toHaveKebabCaseKeys(string $message = ''): self
+    {
+        if (! is_iterable($this->value)) {
+            InvalidExpectationValue::expected('iterable');
+        }
+
+        foreach ($this->value as $k => $item) {
+            if (is_string($k)) {
+                $this->and($k)->toBeKebabCase($message);
+            }
+
+            if (is_array($item)) {
+                $this->and($item)->toHaveKebabCaseKeys($message);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the given expectation is iterable and contains camelCase keys.
+     *
+     * @return self<TValue>
+     */
+    public function toHaveCamelCaseKeys(string $message = ''): self
+    {
+        if (! is_iterable($this->value)) {
+            InvalidExpectationValue::expected('iterable');
+        }
+
+        foreach ($this->value as $k => $item) {
+            if (is_string($k)) {
+                $this->and($k)->toBeCamelCase($message);
+            }
+
+            if (is_array($item)) {
+                $this->and($item)->toHaveCamelCaseKeys($message);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the given expectation is iterable and contains StudlyCase keys.
+     *
+     * @return self<TValue>
+     */
+    public function toHaveStudlyCaseKeys(string $message = ''): self
+    {
+        if (! is_iterable($this->value)) {
+            InvalidExpectationValue::expected('iterable');
+        }
+
+        foreach ($this->value as $k => $item) {
+            if (is_string($k)) {
+                $this->and($k)->toBeStudlyCase($message);
+            }
+
+            if (is_array($item)) {
+                $this->and($item)->toHaveStudlyCaseKeys($message);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the given expectation target to have the given attribute.
+     *
+     * @param  class-string<Attribute>  $attribute
+     */
+    public function toHaveAttribute(string $attribute): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->getAttributes($attribute) !== [],
+            "to have attribute '{$attribute}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target has a constructor method.
+     */
+    public function toHaveConstructor(): ArchExpectation
+    {
+        return $this->toHaveMethod('__construct');
+    }
+
+    /**
+     * Asserts that the given expectation target has a destructor method.
+     */
+    public function toHaveDestructor(): ArchExpectation
+    {
+        return $this->toHaveMethod('__destruct');
+    }
 }

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

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 namespace Pest\Expectations;
 
+use Attribute;
 use Pest\Arch\Contracts\ArchExpectation;
 use Pest\Arch\Expectations\Targeted;
 use Pest\Arch\Expectations\ToBeUsedIn;
@@ -109,7 +110,7 @@ final class OppositeExpectation
     {
         return Targeted::make(
             $this->original,
-            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && ! $object->reflectionClass->isReadOnly(),
+            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')),
         );
@@ -149,6 +150,19 @@ final class OppositeExpectation
         );
     }
 
+    /**
+     * Asserts that the given expectation target does not have a specific method.
+     */
+    public function toHaveMethod(string $method): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! $object->reflectionClass->hasMethod($method),
+            'to not have method',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
     /**
      * Asserts that the given expectation target is not enum.
      */
@@ -171,7 +185,7 @@ final class OppositeExpectation
     }
 
     /**
-     * Asserts that the given expectation targets is an class.
+     * Asserts that the given expectation targets is not class.
      */
     public function toBeClass(): ArchExpectation
     {
@@ -213,7 +227,7 @@ final class OppositeExpectation
     }
 
     /**
-     * Asserts that the given expectation target to be subclass of the given class.
+     * Asserts that the given expectation target to be not subclass of the given class.
      *
      * @param  class-string  $class
      */
@@ -289,19 +303,29 @@ final class OppositeExpectation
     }
 
     /**
-     * Not supported.
+     * Asserts that the given expectation target to not have the given prefix.
      */
-    public function toHavePrefix(string $suffix): never
+    public function toHavePrefix(string $prefix): ArchExpectation
     {
-        throw InvalidExpectation::fromMethods(['not', 'toHavePrefix']);
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! str_starts_with($object->reflectionClass->getShortName(), $prefix),
+            "not to have prefix '{$prefix}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
     }
 
     /**
-     * Not supported.
+     * Asserts that the given expectation target to not have the given suffix.
      */
-    public function toHaveSuffix(string $suffix): never
+    public function toHaveSuffix(string $suffix): ArchExpectation
     {
-        throw InvalidExpectation::fromMethods(['not', 'toHaveSuffix']);
+        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')),
+        );
     }
 
     /**
@@ -355,6 +379,34 @@ 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'))
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target not to have the given attribute.
+     *
+     * @param  class-string<Attribute>  $attribute
+     */
+    public function toHaveAttribute(string $attribute): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->getAttributes($attribute) === [],
+            "to not have attribute '{$attribute}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
+        );
+    }
+
     /**
      * Handle dynamic method calls into the original expectation.
      *
@@ -417,4 +469,20 @@ final class OppositeExpectation
             implode(' ', array_map(fn (mixed $argument): string => $toString($argument), $arguments)),
         ));
     }
+
+    /**
+     * Asserts that the given expectation target does not have a constructor method.
+     */
+    public function toHaveConstructor(): ArchExpectation
+    {
+        return $this->toHaveMethod('__construct');
+    }
+
+    /**
+     * Asserts that the given expectation target does not have a destructor method.
+     */
+    public function toHaveDestructor(): ArchExpectation
+    {
+        return $this->toHaveMethod('__destruct');
+    }
 }

src/Factories/Annotations/Depends.php

@@ -19,7 +19,7 @@ final class Depends implements AddsAnnotations
     public function __invoke(TestCaseMethodFactory $method, array $annotations): array
     {
         foreach ($method->depends as $depend) {
-            $depend = Str::evaluable($depend);
+            $depend = Str::evaluable($method->describing !== null ? Str::describe($method->describing, $depend) : $depend);
 
             $annotations[] = "@depends $depend";
         }

src/Factories/Annotations/TestDox.php

@@ -15,12 +15,11 @@ final class TestDox implements AddsAnnotations
     public function __invoke(TestCaseMethodFactory $method, array $annotations): array
     {
         /*
-       * 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
-       */
-
+         * 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);
 

src/Factories/Attributes/Attribute.php

@@ -20,7 +20,7 @@ abstract class Attribute
      * @param  array<int, string>  $attributes
      * @return array<int, string>
      */
-    public function __invoke(TestCaseMethodFactory $method, array $attributes): array // @phpstan-ignore-line
+    public function __invoke(TestCaseMethodFactory $method, array $attributes): array  // @phpstan-ignore-line
     {
         return $attributes;
     }

src/Factories/TestCaseFactory.php

@@ -142,7 +142,7 @@ final class TestCaseFactory
         $namespace = implode('\\', $partsFQN);
         $baseClass = sprintf('\%s', $this->class);
 
-        if ('' === trim($className)) {
+        if (trim($className) === '') {
             $className = 'InvalidTestName'.Str::random();
         }
 
@@ -241,7 +241,7 @@ final class TestCaseFactory
                 throw ShouldNotHappen::fromMessage('The test description may not be empty.');
             }
 
-            if (Str::evaluable($method->description) === $methodName) {
+            if ($methodName === Str::evaluable($method->description)) {
                 return true;
             }
         }
@@ -259,7 +259,7 @@ final class TestCaseFactory
                 throw ShouldNotHappen::fromMessage('The test description may not be empty.');
             }
 
-            if (Str::evaluable($method->description) === $methodName) {
+            if ($methodName === Str::evaluable($method->description)) {
                 return $method;
             }
         }

src/Mixins/Expectation.php

@@ -6,6 +6,7 @@ namespace Pest\Mixins;
 
 use BadMethodCallException;
 use Closure;
+use Countable;
 use DateTimeInterface;
 use Error;
 use InvalidArgumentException;
@@ -15,6 +16,7 @@ use Pest\Matchers\Any;
 use Pest\Support\Arr;
 use Pest\Support\Exporter;
 use Pest\Support\NullClosure;
+use Pest\Support\Str;
 use Pest\TestSuite;
 use PHPUnit\Framework\Assert;
 use PHPUnit\Framework\Constraint\Constraint;
@@ -264,7 +266,7 @@ final class Expectation
     public function toHaveCount(int $count, string $message = ''): self
     {
         if (! is_countable($this->value) && ! is_iterable($this->value)) {
-            InvalidExpectationValue::expected('string');
+            InvalidExpectationValue::expected('countable|iterable');
         }
 
         Assert::assertCount($count, $this->value, $message);
@@ -272,6 +274,23 @@ final class Expectation
         return $this;
     }
 
+    /**
+     * Asserts that the size of the value and $expected are the same.
+     *
+     * @param  Countable|iterable<mixed>  $expected
+     * @return self<TValue>
+     */
+    public function toHaveSameSize(Countable|iterable $expected, string $message = ''): self
+    {
+        if (! is_countable($this->value) && ! is_iterable($this->value)) {
+            InvalidExpectationValue::expected('countable|iterable');
+        }
+
+        Assert::assertSameSize($expected, $this->value, $message);
+
+        return $this;
+    }
+
     /**
      * Asserts that the value contains the property $name.
      *
@@ -502,6 +521,18 @@ final class Expectation
         return $this;
     }
 
+    /**
+     * Asserts that the value contains only digits.
+     *
+     * @return self<TValue>
+     */
+    public function toBeDigits(string $message = ''): self
+    {
+        Assert::assertTrue(ctype_digit((string) $this->value), $message);
+
+        return $this;
+    }
+
     /**
      * Asserts that the value is of type object.
      *
@@ -805,6 +836,12 @@ final class Expectation
      */
     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(),
@@ -817,22 +854,18 @@ final class Expectation
             default => InvalidExpectationValue::expected('array|object|string'),
         };
 
-        $testCase = TestSuite::getInstance()->test;
-        assert($testCase instanceof TestCase);
-        $snapshots = TestSuite::getInstance()->snapshots;
-
-        if ($snapshots->has($testCase, $string)) {
-            [$filename, $content] = $snapshots->get($testCase, $string);
+        if ($snapshots->has()) {
+            [$filename, $content] = $snapshots->get();
 
             Assert::assertSame(
-                $content,
-                $string,
+                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($testCase, $string);
+            $filename = $snapshots->save($string);
 
-            $testCase::markTestIncomplete('Snapshot created at ['.$filename.'].');
+            TestSuite::getInstance()->registerSnapshotChange("Snapshot created at [$filename]");
         }
 
         return $this;
@@ -894,7 +927,7 @@ final class Expectation
             $callback = $exception;
             $parameters = (new ReflectionFunction($exception))->getParameters();
 
-            if (1 !== count($parameters)) {
+            if (count($parameters) !== 1) {
                 throw new InvalidArgumentException('The given closure must have a single parameter type-hinted as the class string.');
             }
 
@@ -918,7 +951,7 @@ final class Expectation
             }
 
             if (! class_exists($exception)) {
-                if ($e instanceof Error && $e->getMessage() === "Class \"$exception\" not found") {
+                if ($e instanceof Error && "Class \"$exception\" not found" === $e->getMessage()) {
                     Assert::assertTrue(true);
 
                     throw $e;
@@ -934,6 +967,7 @@ final class Expectation
             }
 
             Assert::assertInstanceOf($exception, $e, $message);
+
             $callback($e);
 
             return $this;
@@ -959,4 +993,169 @@ final class Expectation
 
         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;
+    }
+
+    /**
+     * Asserts that the value is snake_case.
+     *
+     * @return self<TValue>
+     */
+    public function toBeSnakeCase(string $message = ''): self
+    {
+        $value = (string) $this->value;
+
+        if ($message === '') {
+            $message = "Failed asserting that {$value} is snake_case.";
+        }
+
+        Assert::assertTrue((bool) preg_match('/^[\p{Ll}_]+$/u', $value), $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is kebab-case.
+     *
+     * @return self<TValue>
+     */
+    public function toBeKebabCase(string $message = ''): self
+    {
+        $value = (string) $this->value;
+
+        if ($message === '') {
+            $message = "Failed asserting that {$value} is kebab-case.";
+        }
+
+        Assert::assertTrue((bool) preg_match('/^[\p{Ll}-]+$/u', $value), $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is camelCase.
+     *
+     * @return self<TValue>
+     */
+    public function toBeCamelCase(string $message = ''): self
+    {
+        $value = (string) $this->value;
+
+        if ($message === '') {
+            $message = "Failed asserting that {$value} is camelCase.";
+        }
+
+        Assert::assertTrue((bool) preg_match('/^\p{Ll}[\p{Ll}\p{Lu}]+$/u', $value), $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is StudlyCase.
+     *
+     * @return self<TValue>
+     */
+    public function toBeStudlyCase(string $message = ''): self
+    {
+        $value = (string) $this->value;
+
+        if ($message === '') {
+            $message = "Failed asserting that {$value} is StudlyCase.";
+        }
+
+        Assert::assertTrue((bool) preg_match('/^\p{Lu}+\p{Ll}[\p{Ll}\p{Lu}]+$/u', $value), $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is UUID.
+     *
+     * @return self<TValue>
+     */
+    public function toBeUuid(string $message = ''): self
+    {
+        if (! is_string($this->value)) {
+            InvalidExpectationValue::expected('string');
+        }
+
+        Assert::assertTrue(Str::isUuid($this->value), $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is between 2 specified values
+     *
+     * @return self<TValue>
+     */
+    public function toBeBetween(int|float|DateTimeInterface $lowestValue, int|float|DateTimeInterface $highestValue, string $message = ''): self
+    {
+        Assert::assertGreaterThanOrEqual($lowestValue, $this->value, $message);
+        Assert::assertLessThanOrEqual($highestValue, $this->value, $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is a url
+     *
+     * @return self<TValue>
+     */
+    public function toBeUrl(string $message = ''): self
+    {
+        if ($message === '') {
+            $message = "Failed asserting that {$this->value} is a url.";
+        }
+
+        Assert::assertTrue(Str::isUrl((string) $this->value), $message);
+
+        return $this;
+    }
 }

src/PendingCalls/TestCall.php

@@ -16,6 +16,7 @@ use Pest\Support\Backtrace;
 use Pest\Support\Exporter;
 use Pest\Support\HigherOrderCallables;
 use Pest\Support\NullClosure;
+use Pest\Support\Str;
 use Pest\TestSuite;
 use PHPUnit\Framework\TestCase;
 
@@ -104,6 +105,24 @@ final class TestCall
         return $this;
     }
 
+    /**
+     * Asserts that the test throws the given `$exceptionClass` when called if the given condition is false.
+     *
+     * @param  (callable(): bool)|bool  $condition
+     */
+    public function throwsUnless(callable|bool $condition, string|int $exception, string $exceptionMessage = null, int $exceptionCode = null): self
+    {
+        $condition = is_callable($condition)
+            ? $condition
+            : static fn (): bool => $condition;
+
+        if (! $condition()) {
+            return $this->throws($exception, $exceptionMessage, $exceptionCode);
+        }
+
+        return $this;
+    }
+
     /**
      * Runs the current test multiple times with
      * each item of the given `iterable`.
@@ -209,7 +228,7 @@ final class TestCall
      */
     private function skipOn(string $osFamily, string $message): self
     {
-        return PHP_OS_FAMILY === $osFamily
+        return $osFamily === PHP_OS_FAMILY
             ? $this->skip($message)
             : $this;
     }
@@ -361,7 +380,7 @@ final class TestCall
     {
         if (! is_null($this->describing)) {
             $this->testCaseMethod->describing = $this->describing;
-            $this->testCaseMethod->description = sprintf('`%s` → %s', $this->describing, $this->testCaseMethod->description);
+            $this->testCaseMethod->description = Str::describe($this->describing, $this->testCaseMethod->description); // @phpstan-ignore-line
         }
 
         $this->testSuite->tests->set($this->testCaseMethod);

src/Pest.php

@@ -6,10 +6,10 @@ namespace Pest;
 
 function version(): string
 {
-    return '2.10.0';
+    return '2.24.0';
 }
 
 function testDirectory(string $file = ''): string
 {
-    return TestSuite::getInstance()->testPath.'/'.$file;
+    return TestSuite::getInstance()->testPath.DIRECTORY_SEPARATOR.$file;
 }

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
  */

src/Plugins/Parallel.php

@@ -13,11 +13,12 @@ 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\Input\ArgvInput;
 
+use function Pest\version;
+
 final class Parallel implements HandlesArguments
 {
     use HandleArguments;

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,16 +22,7 @@ use function fread;
 use function fseek;
 use function ftell;
 use function fwrite;
-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 function strlen;
-use Symfony\Component\Console\Formatter\OutputFormatter;
-use Symfony\Component\Console\Output\OutputInterface;
 
 /**
  * @internal

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;
@@ -29,11 +23,20 @@ use PHPUnit\TestRunner\TestResult\Facade as TestResultFacade;
 use PHPUnit\TestRunner\TestResult\TestResult;
 use PHPUnit\TextUI\Configuration\CodeCoverageFilterRegistry;
 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;
@@ -251,11 +254,11 @@ final class WrapperRunner implements RunnerInterface
 
     private function destroyWorker(int $token): void
     {
-        // Mutation Testing tells us that the following `unset()` already destroys
-        // the `WrapperWorker`, which destroys the Symfony's `Process`, which
-        // automatically calls `Process::stop` within `Process::__destruct()`.
-        // But we prefer to have an explicit stops.
         $this->workers[$token]->stop();
+        // We need to wait for ApplicationForWrapperWorker::end to end
+        while ($this->workers[$token]->isRunning()) {
+            usleep(self::CYCLE_SLEEP);
+        }
 
         unset($this->workers[$token]);
     }
@@ -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,24 @@ 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->numberOfIssuesIgnoredByBaseline() + $testResult->numberOfIssuesIgnoredByBaseline(),
             );
         }
 
         $testResultSum = new TestResult(
-            $testResultSum->numberOfTests(),
+            ResultReflection::numberOfTests($testResultSum),
             $testResultSum->numberOfTestsRun(),
             $testResultSum->numberOfAssertions(),
             $testResultSum->testErroredEvents(),
@@ -307,14 +311,7 @@ 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(),
@@ -322,6 +319,15 @@ final class WrapperRunner implements RunnerInterface
                 $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(),
+            $testResultSum->numberOfIssuesIgnoredByBaseline(),
+
         );
 
         $this->printer->printResults(

src/Plugins/Parallel/Support/CompactPrinter.php

@@ -16,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;
 
 /**
@@ -134,6 +135,10 @@ final class CompactPrinter
             null,
             null,
             null,
+            null,
+            null,
+            null,
+            null,
         );
 
         $telemetry = new Info(

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/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
  */

src/Repositories/SnapshotRepository.php

@@ -5,14 +5,16 @@ declare(strict_types=1);
 namespace Pest\Repositories;
 
 use Pest\Exceptions\ShouldNotHappen;
-use Pest\Support\Str;
-use PHPUnit\Framework\TestCase;
+use Pest\TestSuite;
 
 /**
  * @internal
  */
 final class SnapshotRepository
 {
+    /** @var array<string, int> */
+    private static array $expectationsCounter = [];
+
     /**
      * Creates a snapshot repository instance.
      */
@@ -25,11 +27,9 @@ final class SnapshotRepository
     /**
      * Checks if the snapshot exists.
      */
-    public function has(TestCase $testCase, string $description): bool
+    public function has(): bool
     {
-        [$filename, $description] = $this->getFilenameAndDescription($testCase);
-
-        return file_exists($this->getSnapshotFilename($filename, $description));
+        return file_exists($this->getSnapshotFilename());
     }
 
     /**
@@ -39,11 +39,9 @@ final class SnapshotRepository
      *
      * @throws ShouldNotHappen
      */
-    public function get(TestCase $testCase, string $description): array
+    public function get(): array
     {
-        [$filename, $description] = $this->getFilenameAndDescription($testCase);
-
-        $contents = file_get_contents($snapshotFilename = $this->getSnapshotFilename($filename, $description));
+        $contents = file_get_contents($snapshotFilename = $this->getSnapshotFilename());
 
         if ($contents === false) {
             throw ShouldNotHappen::fromMessage('Snapshot file could not be read.');
@@ -57,11 +55,9 @@ final class SnapshotRepository
     /**
      * Saves the given snapshot for the given test case.
      */
-    public function save(TestCase $testCase, string $snapshot): string
+    public function save(string $snapshot): string
     {
-        [$filename, $description] = $this->getFilenameAndDescription($testCase);
-
-        $snapshotFilename = $this->getSnapshotFilename($filename, $description);
+        $snapshotFilename = $this->getSnapshotFilename();
 
         if (! file_exists(dirname($snapshotFilename))) {
             mkdir(dirname($snapshotFilename), 0755, true);
@@ -103,33 +99,43 @@ final class SnapshotRepository
         }
     }
 
-    /**
-     * Gets the snapshot's "filename" and "description".
-     *
-     * @return array{0: string, 1: string}
-     */
-    private function getFilenameAndDescription(TestCase $testCase): array
-    {
-        $filename = (fn () => self::$__filename)->call($testCase, $testCase::class); // @phpstan-ignore-line
-
-        $description = str_replace('__pest_evaluable_', '', $testCase->name());
-        $datasetAsString = str_replace('__pest_evaluable_', '', Str::evaluable($testCase->dataSetAsStringWithData()));
-
-        $description = str_replace(' ', '_', $description.$datasetAsString);
-
-        return [$filename, $description];
-    }
-
     /**
      * Gets the snapshot's "filename".
      */
-    private function getSnapshotFilename(string $filename, string $description): string
+    private function getSnapshotFilename(): string
     {
-        $relativePath = str_replace($this->testsPath, '', $filename);
+        $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,6 +4,7 @@ declare(strict_types=1);
 
 namespace Pest;
 
+use NunoMaduro\Collision\Adapters\Phpunit\Support\ResultReflection;
 use PHPUnit\TestRunner\TestResult\TestResult;
 use PHPUnit\TextUI\Configuration\Configuration;
 
@@ -44,7 +45,7 @@ final class Result
             return self::SUCCESS_EXIT;
         }
 
-        if ($configuration->failOnEmptyTestSuite() && $result->numberOfTests() === 0) {
+        if ($configuration->failOnEmptyTestSuite() && ResultReflection::numberOfTests($result) === 0) {
             return self::FAILURE_EXIT;
         }
 
@@ -53,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;

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;

src/Support/DatasetInfo.php

@@ -4,6 +4,8 @@ declare(strict_types=1);
 
 namespace Pest\Support;
 
+use function Pest\testDirectory;
+
 /**
  * @internal
  */
@@ -25,6 +27,10 @@ final class DatasetInfo
 
     public static function scope(string $file): string
     {
+        if (Str::endsWith($file, testDirectory('Pest.php'))) {
+            return dirname($file);
+        }
+
         if (self::isInsideADatasetsDirectory($file)) {
             return dirname($file, 2);
         }

src/Support/StateGenerator.php

@@ -74,64 +74,76 @@ final class StateGenerator
             ));
         }
 
-        foreach ($testResult->testTriggeredDeprecationEvents() as $testResultEvent) {
-            $testResultEvent = $testResultEvent[0];
+        foreach ($testResult->deprecations() as $testResultEvent) {
+            foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
+                ['test' => $test] = $triggeringTest;
 
-            $state->add(TestResult::fromPestParallelTestCase(
-                $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::fromPestParallelTestCase(
-                $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::fromPestParallelTestCase(
-                $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::fromPestParallelTestCase(
-                $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::fromPestParallelTestCase(
-                $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::fromPestParallelTestCase(
-                $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
@@ -140,7 +152,7 @@ final class StateGenerator
                 new TestMethod(
                     "$i", // @phpstan-ignore-line
                     '', // @phpstan-ignore-line
-                    '',
+                    '', // @phpstan-ignore-line
                     1,
                     TestDoxBuilder::fromClassNameAndMethodName('', ''), // @phpstan-ignore-line
                     MetadataCollection::fromArray([]),

src/Support/Str.php

@@ -51,7 +51,7 @@ final class Str
             return true;
         }
 
-        return substr($target, -$length) === $search;
+        return $search === substr($target, -$length);
     }
 
     /**
@@ -92,4 +92,28 @@ final class Str
     {
         return $search === '' ? $subject : array_reverse(explode($search, $subject, 2))[0];
     }
+
+    /**
+     * Determine if a given value is a valid UUID.
+     */
+    public static function isUuid(string $value): bool
+    {
+        return preg_match('/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iD', $value) > 0;
+    }
+
+    /**
+     * Creates a describe block as `$describeDescription` → `$testDescription` format.
+     */
+    public static function describe(string $describeDescription, string $testDescription): string
+    {
+        return sprintf('`%s` → %s', $describeDescription, $testDescription);
+    }
+
+    /**
+     * Determine if a given value is a valid URL.
+     */
+    public static function isUrl(string $value): bool
+    {
+        return (bool) filter_var($value, FILTER_VALIDATE_URL);
+    }
 }

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

@@ -11,6 +11,7 @@ use Pest\Repositories\BeforeAllRepository;
 use Pest\Repositories\BeforeEachRepository;
 use Pest\Repositories\SnapshotRepository;
 use Pest\Repositories\TestRepository;
+use Pest\Support\Str;
 use PHPUnit\Framework\TestCase;
 
 /**
@@ -105,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
+    }
 }

stubs/init-laravel/phpunit.xml.stub

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:noNamespaceSchemaLocation="./vendor/phpunit/phpunit/phpunit.xsd"
+         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.3/phpunit.xsd"
          bootstrap="vendor/autoload.php"
          colors="true"
 >
@@ -12,11 +12,6 @@
             <directory suffix="Test.php">./tests/Feature</directory>
         </testsuite>
     </testsuites>
-    <coverage>
-        <include>
-            <directory suffix=".php">./app</directory>
-        </include>
-    </coverage>
     <php>
         <env name="APP_ENV" value="testing"/>
         <env name="BCRYPT_ROUNDS" value="4"/>
@@ -28,4 +23,9 @@
         <env name="SESSION_DRIVER" value="array"/>
         <env name="TELESCOPE_ENABLED" value="false"/>
     </php>
+    <source>
+        <include>
+            <directory suffix=".php">./app</directory>
+        </include>
+    </source>
 </phpunit>

stubs/init/phpunit.xml.stub

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:noNamespaceSchemaLocation="./vendor/phpunit/phpunit/phpunit.xsd"
+         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.3/phpunit.xsd"
          bootstrap="vendor/autoload.php"
          colors="true"
 >
@@ -9,10 +9,10 @@
             <directory suffix="Test.php">./tests</directory>
         </testsuite>
     </testsuites>
-    <coverage>
+    <source>
         <include>
             <directory suffix=".php">./app</directory>
             <directory suffix=".php">./src</directory>
         </include>
-    </coverage>
+    </source>
 </phpunit>

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/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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
 
-  Pest Testing Framework 2.10.0.  
+  Pest Testing Framework 2.24.0.  
 
   USAGE: pest <file> [options]  
 
@@ -14,6 +14,9 @@
   --cache-directory [dir] ............................ Specify cache directory  
   --generate-configuration  Generate configuration file with suggested settings  
   --migrate-configuration ....... Migrate configuration file to current format  
+  --generate-baseline [file] .................... Generate baseline for issues  
+  --use-baseline [file] ........................ Use baseline to ignore issues  
+  --ignore-baseline ..................... Do not use baseline to ignore issues  
 
   SELECTION OPTIONS:
   --bail ........................... Stop execution upon first not-passed test  
@@ -89,7 +92,7 @@
   --testdox-html [file] .. Write test results in TestDox format (HTML) to file  
   --testdox-text [file]  Write test results in TestDox format (plain text) to file  
   --log-events-text [file] ............... Stream events as plain text to file  
-  --log-events-verbose-text [file]  Stream events as plain text (with telemetry information) to file  
+  --log-events-verbose-text [file]  Stream events as plain text with extended information to file  
   --no-logging ....... Ignore logging configured in the XML configuration file  
 
   CODE COVERAGE OPTIONS:

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

@@ -1,3 +1,3 @@
 
-  Pest Testing Framework 2.10.0.  
+  Pest Testing Framework 2.24.0.  
 

tests/.snapshots/success.txt

@@ -187,6 +187,10 @@
   ✓ with with (1)
   ✓ with on hook → value with (2)
   ✓ with on describe → value with (3)
+  ✓ depends on describe → foo
+  ✓ depends on describe → bar
+  ✓ depends on describe using with → foo with (3)
+  ✓ depends on describe using with → bar with (3)
 
    PASS  Tests\Features\DescriptionLess
   ✓ get 'foo'
@@ -211,6 +215,14 @@
   ✓ it can just define the code if given condition is true
   ✓ it can just define the message if given condition is 1
   ✓ it can just define the code if given condition is 1
+  ✓ it not catch exceptions if given condition is true
+  ✓ it catch exceptions if given condition is false
+  ✓ it catch exceptions and messages if given condition is false
+  ✓ it catch exceptions, messages and code if given condition is false
+  ✓ it can just define the message if given condition is false
+  ✓ it can just define the code if given condition is false
+  ✓ it can just define the message if given condition is 0
+  ✓ it can just define the code if given condition is 0
 
    PASS  Tests\Features\Expect\HigherOrder\methods
   ✓ it can access methods
@@ -297,23 +309,49 @@
 
    PASS  Tests\Features\Expect\sequence
   ✓ an exception is thrown if the the type is not iterable
+  ✓ an exception is thrown if there are no expectations
   ✓ allows for sequences of checks to be run on iterable data
   ✓ loops back to the start if it runs out of sequence items
-  ✓ fails if the number of iterable items is greater than the number of expectations
+  ✓ fails if the number of iterable items is less than the number of expectations
   ✓ it works with associative arrays
   ✓ it can be passed non-callable values
   ✓ it can be passed a mixture of value types
+  ✓ it works with traversables
 
    PASS  Tests\Features\Expect\toBe
   ✓ strict comparisons
   ✓ failures
   ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeAlpha
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeAlphaNumeric
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
   ✓ not failures
 
    PASS  Tests\Features\Expect\toBeArray
   ✓ pass
   ✓ failures
   ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeBetween
+  ✓ passes with int
+  ✓ passes with float
+  ✓ passes with float and int
+  ✓ passes with DateTime
+  ✓ failure with int
+  ✓ failure with float
+  ✓ failure with float and int
+  ✓ failure with DateTime
+  ✓ failures with custom message
   ✓ not failures
 
    PASS  Tests\Features\Expect\toBeBool
@@ -326,6 +364,18 @@
   ✓ pass
   ✓ failures
   ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeCamelCase
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeDigits
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
   ✓ not failures
 
    PASS  Tests\Features\Expect\toBeDirectory
@@ -411,6 +461,14 @@
   ✓ failures with custom message
   ✓ not failures
 
+   PASS  Tests\Features\Expect\toBeInvokable
+  ✓ class is invokable
+  ✓ opposite class is invokable
+  ✓ class is invokable via a parent class
+  ✓ class is invokable via a trait
+  ✓ failure when the class is not invokable
+  ✓ class is not invokable
+
    PASS  Tests\Features\Expect\toBeIterable
   ✓ pass
   ✓ failures
@@ -421,6 +479,12 @@
   ✓ pass
   ✓ failures
   ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeKebabCase
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
   ✓ not failures
 
    PASS  Tests\Features\Expect\toBeLessThan
@@ -435,6 +499,12 @@
   ✓ passes with DateTime and DateTimeImmutable
   ✓ failures
   ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeLowercase
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
   ✓ not failures
 
    PASS  Tests\Features\Expect\toBeNAN
@@ -483,12 +553,24 @@
   ✓ pass
   ✓ failures
   ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeSnakeCase
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
   ✓ not failures
 
    PASS  Tests\Features\Expect\toBeString
   ✓ pass
   ✓ failures
   ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeStudlyCase
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
   ✓ not failures
 
    PASS  Tests\Features\Expect\toBeTrue
@@ -510,6 +592,26 @@
   ✓ passes as not truthy with ('0')
   ✓ failures
   ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeUppercase
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeUrl
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
+  ✓ failures with default message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeUuid
+  ✓ failures with wrong type
+  ✓ pass
+  ✓ failures
+  ✓ failures with message
   ✓ not failures
 
    PASS  Tests\Features\Expect\toBeWritableDirectory
@@ -566,8 +668,34 @@
   ✓ failures with custom message
   ✓ not failures
 
+   PASS  Tests\Features\Expect\toHaveAttribute
+  ✓ class has attribute
+  ✓ opposite class has attribute
+  ✓ class not has attribute
+
+   PASS  Tests\Features\Expect\toHaveCamelCaseKeys
+  ✓ pass
+  ✓ failures
+  ✓ failures with message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toHaveConstructor
+  ✓ class has constructor
+  ✓ class has no constructor
+
    PASS  Tests\Features\Expect\toHaveCount
   ✓ pass
+  ✓ failures with invalid type
+  ✓ failures
+  ✓ failures with message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toHaveDestructor
+  ✓ class has destructor
+  ✓ class has no destructor
+
+   PASS  Tests\Features\Expect\toHaveKebabCaseKeys
+  ✓ pass
   ✓ failures
   ✓ failures with message
   ✓ not failures
@@ -618,10 +746,12 @@
   ✓ it fails with message
 
    PASS  Tests\Features\Expect\toHaveMethod
-  ✓ pass
-  ✓ failures
-  ✓ failures with message
-  ✓ not failures
+  ✓ class has method
+  ✓ opposite class has method
+  ✓ class has method via a parent class
+  ✓ class has method via a trait
+  ✓ failure when the class has no method
+  ✓ class has no method
 
    PASS  Tests\Features\Expect\toHaveMethods
   ✓ pass
@@ -629,6 +759,12 @@
   ✓ failures with custom message
   ✓ not failures
 
+   PASS  Tests\Features\Expect\toHavePrefix
+  ✓ missing prefix
+  ✓ has prefix
+  ✓ opposite missing prefix
+  ✓ opposite has prefix
+
    PASS  Tests\Features\Expect\toHaveProperties
   ✓ pass
   ✓ failures
@@ -642,6 +778,31 @@
   ✓ failures with message and Any matcher
   ✓ not failures
 
+   PASS  Tests\Features\Expect\toHaveSameSize
+  ✓ failures with wrong type
+  ✓ pass
+  ✓ failures
+  ✓ failures with message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toHaveSnakeCaseKeys
+  ✓ pass
+  ✓ failures
+  ✓ failures with message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toHaveStudlyCaseKeys
+  ✓ pass
+  ✓ failures
+  ✓ failures with message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toHaveSuffix
+  ✓ missing suffix
+  ✓ has suffix
+  ✓ opposite missing suffix
+  ✓ opposite has suffix
+
    PASS  Tests\Features\Expect\toMatch
   ✓ pass
   ✓ failures
@@ -678,6 +839,22 @@
   ✓ failures
   ✓ failures with custom message
   ✓ not failures
+  ✓ multiple snapshot expectations
+  ✓ multiple snapshot expectations with datasets with (1)
+  ✓ multiple snapshot expectations with datasets with ('foo')
+  ✓ multiple snapshot expectations with datasets with ('bar')
+  ✓ multiple snapshot expectations with datasets with ('baz')
+  ✓ describable → multiple snapshot expectations with describe
+  ✓ multiple snapshot expectations with repeat @ repetition 1 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 2 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 3 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 4 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 5 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 6 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 7 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 8 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 9 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 10 of 10
 
    PASS  Tests\Features\Expect\toStartWith
   ✓ pass
@@ -891,6 +1068,9 @@
   ✓ uses dataset with (1)
   ✓ uses dataset with (2)
   ✓ the right dataset is taken
+  ✓ it can see datasets defined in Pest.php file with ('A')
+  ✓ it can see datasets defined in Pest.php file with ('B')
+  ✓ Pest.php dataset is taken
 
    WARN  Tests\Features\Skip
   ✓ it do not skips
@@ -979,9 +1159,15 @@
    PASS  Tests\PHPUnit\CustomAffixes\snakecasespec
   ✓ it runs file names like snake_case_spec.php
 
+   PASS  Tests\CustomTestCase\ChildTest
+  ✓ override method
+
    PASS  Tests\CustomTestCase\ExecutedTest
   ✓ that gets executed
 
+   PASS  Tests\CustomTestCase\ParentTest
+  ✓ override method
+
    PASS  Tests\PHPUnit\CustomTestCase\UsesPerDirectory
   ✓ closure was bound to CustomTestCase
 
@@ -1174,4 +1360,4 @@
    WARN  Tests\Visual\Version
   - visual snapshot of help command output
 
-  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 13 todos, 19 skipped, 830 passed (1927 assertions)
+  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 13 todos, 19 skipped, 966 passed (2292 assertions)

tests/.snapshots/todo.txt

@@ -19,7 +19,13 @@
   ↓ something todo later chained
   ↓ something todo later chained and with function body
 
+   PASS  Tests\CustomTestCase\ChildTest
+  ✓ override method
+
    PASS  Tests\CustomTestCase\ExecutedTest
   ✓ that gets executed
 
-  Tests:    13 todos, 1 passed (1 assertions)
+   PASS  Tests\CustomTestCase\ParentTest
+  ✓ override method
+
+  Tests:    13 todos, 3 passed (3 assertions)

tests/Arch.php

@@ -3,7 +3,7 @@
 use Pest\Expectation;
 
 test('globals')
-    ->expect(['dd', 'dump', 'ray'])
+    ->expect(['dd', 'dump', 'ray', 'die', 'var_dump', 'sleep'])
     ->not->toBeUsed()
     ->ignoring(Expectation::class);
 

tests/Features/Describe.php

@@ -76,3 +76,23 @@ describe('with on describe', function () {
         expect($foo)->toBe(3);
     });
 })->with([3]);
+
+describe('depends on describe', function () {
+    test('foo', function () {
+        expect('foo')->toBe('foo');
+    });
+
+    test('bar', function () {
+        expect('bar')->toBe('bar');
+    })->depends('foo');
+});
+
+describe('depends on describe using with', function () {
+    test('foo', function ($foo) {
+        expect($foo)->toBe(3);
+    });
+
+    test('bar', function ($foo) {
+        expect($foo + $foo)->toBe(6);
+    })->depends('foo');
+})->with([3]);

tests/Features/Exceptions.php

@@ -59,3 +59,37 @@ it('can just define the message if given condition is 1', function () {
 it('can just define the code if given condition is 1', function () {
     throw new Exception('Something bad happened', 1);
 })->throwsIf(1, 1);
+
+it('not catch exceptions if given condition is true', function () {
+    $this->assertTrue(true);
+})->throwsUnless(true, Exception::class);
+
+it('catch exceptions if given condition is false', function () {
+    throw new Exception('Something bad happened');
+})->throwsUnless(function () {
+    return false;
+}, Exception::class);
+
+it('catch exceptions and messages if given condition is false', function () {
+    throw new Exception('Something bad happened');
+})->throwsUnless(false, Exception::class, 'Something bad happened');
+
+it('catch exceptions, messages and code if given condition is false', function () {
+    throw new Exception('Something bad happened', 1);
+})->throwsUnless(false, Exception::class, 'Something bad happened', 1);
+
+it('can just define the message if given condition is false', function () {
+    throw new Exception('Something bad happened');
+})->throwsUnless(false, 'Something bad happened');
+
+it('can just define the code if given condition is false', function () {
+    throw new Exception('Something bad happened', 1);
+})->throwsUnless(false, 1);
+
+it('can just define the message if given condition is 0', function () {
+    throw new Exception('Something bad happened');
+})->throwsUnless(0, 'Something bad happened');
+
+it('can just define the code if given condition is 0', function () {
+    throw new Exception('Something bad happened', 1);
+})->throwsUnless(0, 1);

tests/Features/Expect/sequence.php

@@ -1,11 +1,13 @@
 <?php
 
-use PHPUnit\Framework\ExpectationFailedException;
-
 test('an exception is thrown if the the type is not iterable', function () {
     expect('Foobar')->each->sequence();
 })->throws(BadMethodCallException::class, 'Expectation value is not iterable.');
 
+test('an exception is thrown if there are no expectations', function () {
+    expect(['Foobar'])->sequence();
+})->throws(InvalidArgumentException::class, 'No sequence expectations defined.');
+
 test('allows for sequences of checks to be run on iterable data', function () {
     expect([1, 2, 3])
         ->sequence(
@@ -40,7 +42,7 @@ test('loops back to the start if it runs out of sequence items', function () {
     expect(static::getCount())->toBe(16);
 });
 
-test('fails if the number of iterable items is greater than the number of expectations', function () {
+test('fails if the number of iterable items is less than the number of expectations', function () {
     expect([1, 2])
         ->sequence(
             function ($expectation) {
@@ -53,7 +55,7 @@ test('fails if the number of iterable items is greater than the number of expect
                 $expectation->toBeInt()->toEqual(3);
             },
         );
-})->throws(ExpectationFailedException::class);
+})->throws(OutOfRangeException::class, 'Sequence expectations are more than the iterable items.');
 
 test('it works with associative arrays', function () {
     expect(['foo' => 'bar', 'baz' => 'boom'])
@@ -86,3 +88,26 @@ test('it can be passed a mixture of value types', function () {
 
     expect(static::getCount())->toBe(4);
 });
+
+test('it works with traversables', function () {
+    $generator = (function () {
+        yield 'one' => (fn () => yield from [1, 2, 3])();
+        yield 'two' => (fn () => yield from [4, 5, 6])();
+        yield 'three' => (fn () => yield from [7, 8, 9])();
+    })();
+
+    expect($generator)->sequence(
+        fn ($value, $key) => $key->toBe('one')
+            ->and($value)
+            ->toBeInstanceOf(Generator::class)
+            ->sequence(1, 2, 3),
+        fn ($value, $key) => $key->toBe('two')
+            ->and($value)
+            ->toBeInstanceOf(Generator::class)
+            ->sequence(4, 5, 6),
+        fn ($value, $key) => $key->toBe('three')
+            ->and($value)
+            ->toBeInstanceOf(Generator::class)
+            ->sequence(7, 8, 9),
+    );
+});

tests/Features/Expect/toBeAlpha.php

@@ -0,0 +1,20 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('abc')->toBeAlpha();
+    expect('123')->not->toBeAlpha();
+});
+
+test('failures', function () {
+    expect('123')->toBeAlpha();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('123')->toBeAlpha('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('abc')->not->toBeAlpha();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeAlphaNumeric.php

@@ -0,0 +1,20 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('abc123')->toBeAlphaNumeric();
+    expect('-')->not->toBeAlphaNumeric();
+});
+
+test('failures', function () {
+    expect('-')->toBeAlphaNumeric();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('-')->toBeAlphaNumeric('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('abc123')->not->toBeAlphaNumeric();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeBetween.php

@@ -0,0 +1,43 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('passes with int', function () {
+    expect(2)->toBeBetween(1, 3);
+});
+
+test('passes with float', function () {
+    expect(1.5)->toBeBetween(1.25, 1.75);
+});
+
+test('passes with float and int', function () {
+    expect(1.5)->toBeBetween(1, 2);
+});
+
+test('passes with DateTime', function () {
+    expect(new DateTime('2023-09-22'))->toBeBetween(new DateTime('2023-09-21'), new DateTime('2023-09-23'));
+});
+
+test('failure with int', function () {
+    expect(4)->toBeBetween(1, 3);
+})->throws(ExpectationFailedException::class);
+
+test('failure with float', function () {
+    expect(2)->toBeBetween(1.5, 1.75);
+})->throws(ExpectationFailedException::class);
+
+test('failure with float and int', function () {
+    expect(2.1)->toBeBetween(1, 2);
+})->throws(ExpectationFailedException::class);
+
+test('failure with DateTime', function () {
+    expect(new DateTime('2023-09-20'))->toBeBetween(new DateTime('2023-09-21'), new DateTime('2023-09-23'));
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect(4)->toBeBetween(1, 3, 'oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect(2)->not->toBeBetween(1, 3);
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeCamelCase.php

@@ -0,0 +1,23 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('abc')->toBeCamelCase();
+    expect('abcDef')->toBeCamelCase();
+    expect('abc-def')->not->toBeCamelCase();
+    expect('abc-def')->not->toBeCamelCase();
+    expect('AbcDef')->not->toBeCamelCase();
+});
+
+test('failures', function () {
+    expect('Abc')->toBeCamelCase();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('Abc')->toBeCamelCase('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('abcDef')->not->toBeCamelCase();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeDigits.php

@@ -0,0 +1,20 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('123')->toBeDigits();
+    expect('123.14')->not->toBeDigits();
+});
+
+test('failures', function () {
+    expect('123.14')->toBeDigits();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('123.14')->toBeDigits('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('445')->not->toBeDigits();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeInvokable.php

@@ -0,0 +1,29 @@
+<?php
+
+use Pest\Arch\Exceptions\ArchExpectationFailedException;
+
+test('class is invokable')
+    ->expect('Tests\\Fixtures\\Arch\\ToBeInvokable\\IsInvokable\\InvokableClass')
+    ->toBeInvokable();
+
+test('opposite class is invokable')
+    ->throws(ArchExpectationFailedException::class)
+    ->expect('Tests\\Fixtures\\Arch\\ToBeInvokable\\IsInvokable\\InvokableClass')
+    ->not->toBeInvokable();
+
+test('class is invokable via a parent class')
+    ->expect('Tests\\Fixtures\\Arch\\ToBeInvokable\\IsInvokable\\InvokableClassViaParent')
+    ->toBeInvokable();
+
+test('class is invokable via a trait')
+    ->expect('Tests\\Fixtures\\Arch\\ToBeInvokable\\IsInvokable\\InvokableClassViaTrait')
+    ->toBeInvokable();
+
+test('failure when the class is not invokable')
+    ->throws(ArchExpectationFailedException::class)
+    ->expect('Tests\\Fixtures\\Arch\\ToBeInvokable\\IsNotInvokable\\IsNotInvokableClass')
+    ->toBeInvokable();
+
+test('class is not invokable')
+    ->expect('Tests\\Fixtures\\Arch\\ToBeInvokable\\IsNotInvokable\\IsNotInvokableClass')
+    ->not->toBeInvokable();

tests/Features/Expect/toBeKebabCase.php

@@ -0,0 +1,23 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('abc')->toBeKebabCase();
+    expect('abc-def')->toBeKebabCase();
+    expect('abc_def')->not->toBeKebabCase();
+    expect('abcDef')->not->toBeKebabCase();
+    expect('AbcDef')->not->toBeKebabCase();
+});
+
+test('failures', function () {
+    expect('Abc')->toBeKebabCase();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('Abc')->toBeKebabCase('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('abc-def')->not->toBeKebabCase();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeLowercase.php

@@ -0,0 +1,20 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('lowercase')->toBeLowercase();
+    expect('UPPERCASE')->not->toBeLowercase();
+});
+
+test('failures', function () {
+    expect('UPPERCASE')->toBeLowercase();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('UPPERCASE')->toBeLowercase('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('lowercase')->not->toBeLowercase();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeSnakeCase.php

@@ -0,0 +1,23 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('abc')->toBeSnakeCase();
+    expect('abc_def')->toBeSnakeCase();
+    expect('abc-def')->not->toBeSnakeCase();
+    expect('abcDef')->not->toBeSnakeCase();
+    expect('AbcDef')->not->toBeSnakeCase();
+});
+
+test('failures', function () {
+    expect('Abc')->toBeSnakeCase();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('Abc')->toBeSnakeCase('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('abc_def')->not->toBeSnakeCase();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeStudlyCase.php

@@ -0,0 +1,23 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('Abc')->toBeStudlyCase();
+    expect('AbcDef')->toBeStudlyCase();
+    expect('abc-def')->not->toBeStudlyCase();
+    expect('abc-def')->not->toBeStudlyCase();
+    expect('abc')->not->toBeStudlyCase();
+});
+
+test('failures', function () {
+    expect('abc')->toBeStudlyCase();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('abc')->toBeStudlyCase('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('AbcDef')->not->toBeStudlyCase();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeUppercase.php

@@ -0,0 +1,20 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('UPPERCASE')->toBeUppercase();
+    expect('lowercase')->not->toBeUppercase();
+});
+
+test('failures', function () {
+    expect('lowercase')->toBeUppercase();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('lowercase')->toBeUppercase('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('UPPERCASE')->not->toBeUppercase();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeUrl.php

@@ -0,0 +1,24 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('https://pestphp.com')->toBeUrl()
+        ->and('pestphp.com')->not->toBeUrl();
+});
+
+test('failures', function () {
+    expect('pestphp.com')->toBeUrl();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('pestphp.com')->toBeUrl('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('failures with default message', function () {
+    expect('pestphp.com')->toBeUrl();
+})->throws(ExpectationFailedException::class, 'Failed asserting that pestphp.com is a url.');
+
+test('not failures', function () {
+    expect('https://pestphp.com')->not->toBeUrl();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeUuid.php

@@ -0,0 +1,31 @@
+<?php
+
+use Pest\Exceptions\InvalidExpectationValue;
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('failures with wrong type', function () {
+    expect([])->toBeUuid();
+})->throws(InvalidExpectationValue::class, 'Invalid expectation value type. Expected [string].');
+
+test('pass', function () {
+    expect('3cafb226-4326-11ee-a516-846993788c86')->toBeUuid(); // version 1
+    expect('0000415c-4326-21ee-a700-846993788c86')->toBeUuid(); // version 2
+    expect('3f703955-aaba-3e70-a3cb-baff6aa3b28f')->toBeUuid(); // version 3
+    expect('ca0a8228-cdf6-41db-b34b-c2f31485796c')->toBeUuid(); // version 4
+    expect('a35477ae-bfb1-5f2e-b5a4-4711594d855f')->toBeUuid(); // version 5
+    expect('1ee43263-cf5a-6fd8-8f47-846993788c86')->toBeUuid(); // version 6
+    expect('018a2bef-09f2-728c-becb-c3f569d91486')->toBeUuid(); // version 7
+    expect('00112233-4455-8677-8899-aabbccddeeff')->toBeUuid(); // version 8
+});
+
+test('failures', function () {
+    expect('foo')->toBeUuid();
+})->throws(ExpectationFailedException::class);
+
+test('failures with message', function () {
+    expect('bar')->toBeUuid('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('foo')->not->toBeUuid();
+});