release: v2.30.0

Fix typo in `toBeClass`

.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

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

.github/workflows/static.yml

@@ -13,12 +13,13 @@ jobs:
 
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: true
       matrix:
         dependency-version: [prefer-lowest, prefer-stable]
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
 
     - name: Setup PHP
       uses: shivammathur/setup-php@v2

.github/workflows/tests.yml

@@ -6,22 +6,27 @@ on:
   schedule:
     - cron: '0 0 * * *'
 
-
 jobs:
-  ci:
+  tests:
     if: github.event_name != 'schedule' || github.repository == 'pestphp/pest'
+
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: true
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        php: ['8.1', '8.2']
-        dependency-version: [prefer-lowest, prefer-stable]
+        symfony: ['6.4.0', '7.0.1']
+        php: ['8.1', '8.2', '8.3']
+        dependency_version: [prefer-lowest, prefer-stable]
+        exclude:
+          - php: '8.1'
+            symfony: '7.0.1'
 
-    name: PHP ${{ matrix.php }} - ${{ matrix.os }} - ${{ matrix.dependency-version }}
+    name: PHP ${{ matrix.php }} - Symfony ^${{ matrix.symfony }} - ${{ matrix.os }} - ${{ matrix.dependency_version }}
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
 
     - name: Setup PHP
       uses: shivammathur/setup-php@v2
@@ -36,11 +41,13 @@ jobs:
         echo "::add-matcher::${{ runner.tool_cache }}/phpunit.json"
 
     - name: Install PHP dependencies
-      run: composer update --${{ matrix.dependency-version }} --no-interaction --no-progress --ansi
+      run: composer update --${{ matrix.dependency_version }} --no-interaction --no-progress --ansi --with="symfony/console:^${{ matrix.symfony }}"
 
     - name: Unit Tests
       run: composer test:unit
 
-    - name: Unit Tests in Parallel
+    - name: Parallel Tests
       run: composer test:parallel
 
+    - name: Integration Tests
+      run: composer test:integration

CHANGELOG.md

@@ -1,210 +0,0 @@
-# Release Notes for 2.x
-
-## Unreleased
-
-## [v2.12.0 (2023-08-02)](https://github.com/pestphp/pest/compare/v2.11.0...v2.12.0)
-
-### Added
-
-- Allows multiple `toMatchSnapshot` per test ([#881](https://github.com/pestphp/pest/pull/881))
-
-### Changed
-
-- Bumps PHPUnit to `^10.2.7` ([43107c1](https://github.com/pestphp/pest/commit/43107c17436e41e23018ae31705c688168c14784))
-
-## [v2.11.0 (2023-08-01)](https://github.com/pestphp/pest/compare/v2.10.1...v2.11.0)
-
-### Added
-
-- `toBeInvokable`expectation ([#891](https://github.com/pestphp/pest/pull/891))
-
-## [v2.10.1 (2023-07-31)](https://github.com/pestphp/pest/compare/v2.10.0...v2.10.1)
-
-### Fixed
-
-- `not->toHaveSuffix` and `toHavePrefix` expectations ([#888](https://github.com/pestphp/pest/pull/888))
-
-## [v2.10.0 (2023-07-31)](https://github.com/pestphp/pest/compare/v2.9.5...v2.10.0)
-
-### Added
-
-- `repeat` feature ([f3f35a2](https://github.com/pestphp/pest/commit/f3f35a2ed119f63eefd323a8c66d3387e908df3f))
-
-### Fixed
-
-- `-v` option ([86a6b32](https://github.com/pestphp/pest/commit/86a6b3271518742dc39761228687a5107551d279))
-
-## [v2.9.5 (2023-07-22)](https://github.com/pestphp/pest/compare/v2.9.4...v2.9.5)
-
-### Fixed
-
-- Assertions count on arch expectations ([632ffc2](https://github.com/pestphp/pest/commit/632ffc2f8e1fe45f739b12b818426ae14700079e))
-
-## [v2.9.4 (2023-07-22)](https://github.com/pestphp/pest/compare/v2.9.3...v2.9.4)
-
-### Fixed
-
-- Output on `describe` `beforeEach` failure ([5637dfa](https://github.com/pestphp/pest/commit/5637dfa75d1a331adc810935536cde7c3196af06))
-
-## [v2.9.3 (2023-07-20)](https://github.com/pestphp/pest/compare/v2.9.2...v2.9.3)
-
-### Fixed
-
-- Snapshots directory on Windows environments ([cf52752](https://github.com/pestphp/pest/commit/cf5275293fe693ec2cf4dbadbadae01daaa08169))
-
-## [v2.9.2 (2023-07-20)](https://github.com/pestphp/pest/compare/v2.9.1...v2.9.2)
-
-### Fixed
-
-- `beforeEach` on Windows environments ([a37a3b9](https://github.com/pestphp/pest/commit/a37a3b9f9931bc1ab1ea9e1d6d38dfb55dde3f74))
-
-## [v2.9.1 (2023-07-20)](https://github.com/pestphp/pest/compare/v2.9.0...v2.9.1)
-
-### Chore
-
-- Bumps PHPUnit to `^10.2.6` ([8fdb0b3](https://github.com/pestphp/pest/commit/8fdb0b3d32ce9ee12bd182f22751c2b41a53e97b))
-
-## [v2.9.0 (2023-07-19)](https://github.com/pestphp/pest/compare/v2.8.1...v2.9.0)
-
-> "Spicy Summer" is the codename assigned to Pest 2.9, for full details check our announcement: [https://pestphp.com/docs/pest-spicy-summer-release](https://pestphp.com/docs/pest-spicy-summer-release)
-
-### Added
-
-- Built-in Snapshot Testing ([c828756](https://github.com/pestphp/pest/commit/c8287567eb8c3dbea5845b2a6f70804b094b4b60))
-- Describe Blocks ([c828756](https://github.com/pestphp/pest/commit/c8287567eb8c3dbea5845b2a6f70804b094b4b60))
-- Architectural Testing++ ([c828756](https://github.com/pestphp/pest/commit/c8287567eb8c3dbea5845b2a6f70804b094b4b60))
-- Type Coverage Plugin ([c828756](https://github.com/pestphp/pest/commit/c8287567eb8c3dbea5845b2a6f70804b094b4b60))
-- Drift Plugin ([c828756](https://github.com/pestphp/pest/commit/c8287567eb8c3dbea5845b2a6f70804b094b4b60))
-
-## [v2.8.1 (2023-06-20)](https://github.com/pestphp/pest/compare/v2.8.0...v2.8.1)
-
-### Fixed
-- Fixes "Cannot find TestCase object on call stack" ([eb7bb34](https://github.com/pestphp/pest/commit/eb7bb348253f412e806a6ba6f0df46c0435d0dfe))
-
-## [v2.8.0 (2023-06-19)](https://github.com/pestphp/pest/compare/v2.7.0...v2.8.0)
-
-### Added
-- Support for `globs` in `uses` ([#829](https://github.com/pestphp/pest/pull/829))
-
-## [v2.7.0 (2023-06-15)](https://github.com/pestphp/pest/compare/v2.6.3...v2.7.0)
-
-### Added
-- Support for unexpected output on printer ([eb9f31e](https://github.com/pestphp/pest/commit/eb9f31edeb00a88c449874f3d48156128a00fff8))
-
-### Chore
-- Bumps PHPUnit to `^10.2.2` ([0e5470b](https://github.com/pestphp/pest/commit/0e5470b192b259ba2db7c02a50371216c98fc0a6))
-
-## [v2.6.3 (2023-06-07)](https://github.com/pestphp/pest/compare/v2.6.2...v2.6.3)
-
-### Chore
-- Bumps PHPUnit to `^10.2.1` ([73a859e](https://github.com/pestphp/pest/commit/73a859ee563fe96944ba39b191dceca28ef703c2))
-
-## [v2.6.2 (2023-06-02)](https://github.com/pestphp/pest/compare/v2.6.1...v2.6.2)
-
-### Chore
-- Bumps PHPUnit to `^10.2.0` ([a0041f1](https://github.com/pestphp/pest/commit/a0041f139cba94fe5d15318c38e275f2e2fb3350))
-
-## [v2.6.1 (2023-04-12)](https://github.com/pestphp/pest/compare/v2.6.0...v2.6.1)
-
-### Fixes
-- PHPStorm issue output problem for tests throwing an exception before the first assertion ([#809](https://github.com/pestphp/pest/pull/809))
-- Allow traits to be covered ([#804](https://github.com/pestphp/pest/pull/804))
-
-### Chore
-- Bumps PHPUnit to `^10.1.3` ([c993252](https://github.com/pestphp/pest/commit/c99325275acf1fd3759b487b93ec50473f706709))
-
-## [v2.6.0 (2023-04-05)](https://github.com/pestphp/pest/compare/v2.5.2...v2.6.0)
-
-### Adds
-- Allows `toThrow` to be used against an exception instance ([#797](https://github.com/pestphp/pest/pull/797))
-
-## [v2.5.2 (2023-04-19)](https://github.com/pestphp/pest/compare/v2.5.1...v2.5.2)
-
-### Chore
-- Removes `myclabs/php-enuma` dependency ([1a05df1](https://github.com/pestphp/pest/commit/1a05df14d0ce7d12583df26ff716807db6f81f13))
-
-## [v2.5.1 (2023-04-18)](https://github.com/pestphp/pest/compare/v2.5.0...v2.5.1)
-
-### Chore
-- Bumps PHPUnit to `^10.1.1` ([ec6a817](https://github.com/pestphp/pest/commit/ec6a81735af19f5463d24545df97535d77697ec6))
-
-## [v2.5.0 (2023-04-14)](https://github.com/pestphp/pest/compare/v2.4.0...v2.5.0)
-
-### Chore
-- Bumps PHPUnit to `^10.1.0` ([#780](https://github.com/pestphp/pest/pull/780))
-
-## [v2.4.0 (2023-04-03)](https://github.com/pestphp/pest/compare/v2.3.0...v2.4.0)
-
-### Added
-- `skipOnWindows()`, `skipOnMac()`, and `skipOnLinux()` ([#757](https://github.com/pestphp/pest/pull/757))
-- source architecture testing violation ([#1](https://github.com/pestphp/pest-plugin-arch/pull/1))([8e66263](https://github.com/pestphp/pest-plugin-arch/commit/8e66263104304e99e3d6ceda25c7ed679b27fb03))
-- `toHaveProperties` may now also check values ([#760](https://github.com/pestphp/pest/pull/760))
-
-### Fixed
-- Tests on `tests/Helpers` directory not being executed ([#753](https://github.com/pestphp/pest/pull/753))
-- Teamcity count ([#747](https://github.com/pestphp/pest/pull/747))
-- Parallel execution when class extends class with same name ([#748](https://github.com/pestphp/pest/pull/748))
-- Wording on `uses()` hint ([#745](https://github.com/pestphp/pest/pull/745/files))
-
-## [v2.3.0 (2023-03-28)](https://github.com/pestphp/pest/compare/v2.2.3...v2.3.0)
-
-### Added
-- Better error handler about missing uses ([#743](https://github.com/pestphp/pest/pull/743))
-
-### Fixed
-- Inconsistent spelling of `dataset` ([#739](https://github.com/pestphp/pest/pull/739))
-
-### Chore
-- Bumps PHPUnit to `^10.0.19` ([3d7e621](https://github.com/pestphp/pest/commit/3d7e621b7dfc03f0b2d9dcf6eb06c26bc383f502))
-
-## [v2.2.3 (2023-03-24)](https://github.com/pestphp/pest/compare/v2.2.2...v2.2.3)
-
-### Fixed
-- Unnecessary dataset on dataset arguments mismatch ([#736](https://github.com/pestphp/pest/pull/736))
-- Parallel arguments on plugins order ([#703](https://github.com/pestphp/pest/pull/703))
-- Arch plugin runtime exceptions on bad phpdocs ([2f2b51c](https://github.com/pestphp/pest/commit/2f2b51ce3d1b000be9d6add0e785fd0044931b3b))
-
-## [v2.2.2 (2023-03-23)](https://github.com/pestphp/pest/compare/v2.2.1...v2.2.2)
-
-### Fixed
-- Edge case in parallel execution test description ([3ce6408](https://github.com/pestphp/pest/commit/3ce640819541ca6022b250e000f336d87c3e7889))
-
-## [v2.2.1 (2023-03-22)](https://github.com/pestphp/pest/compare/v2.2.0...v2.2.1)
-
-### Fixed
-- Collision between tests names with underscores ([#724](https://github.com/pestphp/pest/pull/724))
-
-### Chore
-- Bumps PHPUnit to `^10.0.18` ([1408cff](https://github.com/pestphp/pest/commit/1408cffc028690057e44f00038f9390f776e6bfb))
-
-## [v2.2.0 (2023-03-22)](https://github.com/pestphp/pest/compare/v2.1.0...v2.2.0)
-
-### Added
-- Improved error messages on dataset arguments mismatch ([#698](https://github.com/pestphp/pest/pull/698))
-- Allows the usage of `DateTimeInterface` on multiple expectations ([#716](https://github.com/pestphp/pest/pull/716))
-
-### Fixed
-- `--dirty` option on Windows environments ([#721](https://github.com/pestphp/pest/pull/721))
-- Parallel exit code when `phpunit.xml` is outdated ([14dd5cb](https://github.com/pestphp/pest/commit/14dd5cb57b9432300ac4e8095f069941cb43bdb5))
-
-## [v2.1.0 (2023-03-21)](https://github.com/pestphp/pest/compare/v2.0.2...v2.1.0)
-
-### Added
-- `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

@@ -22,18 +22,16 @@ We cannot thank our sponsors enough for their incredible support in funding Pest
 ### Platinum Sponsors
 
 - **[Forge](https://forge.laravel.com)**
-- **[LoadForge](https://loadforge.com)**
 - **[Spatie](https://spatie.be)**
 - **[Worksome](https://www.worksome.com/)**
 
 ### Premium Sponsors
 
 - [Akaunting](https://akaunting.com)
-- [Codecourse](https://codecourse.com/)
-- [Laracasts](https://laracasts.com/)
+- [Codecourse](https://codecourse.com)
+- [Laracasts](https://laracasts.com)
+- [Laradir](https://laradir.com)
 - [Localazy](https://localazy.com)
-- [Fathom Analytics](https://usefathom.com/)
-- [Meema](https://meema.io)
 - [Zapiet](https://www.zapiet.com)
 
 Pest is an open-sourced software licensed under the **[MIT license](https://opensource.org/licenses/MIT)**.

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

@@ -38,7 +38,7 @@ use Symfony\Component\Console\Output\ConsoleOutput;
             unset($args[$key]);
         }
 
-        if ($value === '--todos') {
+        if (in_array($value, ['--todo', '--todos'], true)) {
             $todo = true;
             unset($args[$key]);
         }

composer.json

@@ -18,16 +18,17 @@
     ],
     "require": {
         "php": "^8.1.0",
-        "brianium/paratest": "^7.2.4",
-        "nunomaduro/collision": "^7.8.0",
-        "nunomaduro/termwind": "^1.15.1",
-        "pestphp/pest-plugin": "^2.0.1",
-        "pestphp/pest-plugin-arch": "^2.2.3",
-        "phpunit/phpunit": "^10.3.1"
+        "brianium/paratest": "^7.3.1",
+        "nunomaduro/collision": "^7.10.0|^8.0.1",
+        "nunomaduro/termwind": "^1.15.1|^2.0.0",
+        "pestphp/pest-plugin": "^2.1.1",
+        "pestphp/pest-plugin-arch": "^2.5.0",
+        "phpunit/phpunit": "^10.5.5"
     },
     "conflict": {
-        "webmozart/assert": "<1.11.0",
-        "phpunit/phpunit": ">10.3.1"
+        "phpunit/phpunit": ">10.5.5",
+        "sebastian/exporter": "<5.1.0",
+        "webmozart/assert": "<1.11.0"
     },
     "autoload": {
         "psr-4": {
@@ -50,9 +51,9 @@
         ]
     },
     "require-dev": {
-        "pestphp/pest-dev-tools": "^2.14.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.6.0",
+        "symfony/process": "^6.4.0|^7.0.0"
     },
     "minimum-stability": "dev",
     "prefer-stable": true,
@@ -75,7 +76,7 @@
         "test:type:coverage": "php bin/pest --type-coverage --min=100",
         "test:unit": "php bin/pest --colors=always --exclude-group=integration --compact",
         "test:inline": "php bin/pest --colors=always --configuration=phpunit.inline.xml",
-        "test:parallel": "php bin/pest --colors=always --exclude-group=integration --parallel --processes=10",
+        "test:parallel": "php bin/pest --colors=always --exclude-group=integration --parallel --processes=3",
         "test:integration": "php bin/pest --colors=always --group=integration",
         "update:snapshots": "REBUILD_SNAPSHOTS=true php bin/pest --colors=always --update-snapshots",
         "test": [
@@ -108,6 +109,11 @@
                 "Pest\\Plugins\\Version",
                 "Pest\\Plugins\\Parallel"
             ]
+        },
+        "phpstan": {
+            "includes": [
+                "extension.neon"
+            ]
         }
     }
 }

docker/Dockerfile

@@ -1,21 +1,16 @@
 ARG PHP=8.1
 FROM php:${PHP}-cli-alpine
 
-RUN apk update \
-    && apk add zip libzip-dev icu-dev git
+RUN apk update && apk add \
+    zip libzip-dev icu-dev git \
 
-RUN docker-php-ext-configure zip
-RUN docker-php-ext-install zip
-RUN docker-php-ext-enable zip
+RUN docker-php-ext-configure zip intl
+RUN docker-php-ext-install zip intl
+RUN docker-php-ext-enable zip intl
 
-RUN docker-php-ext-configure intl
-RUN docker-php-ext-install intl
-RUN docker-php-ext-enable intl
-
-RUN apk add --no-cache $PHPIZE_DEPS linux-headers
+RUN apk add --no-cache linux-headers
 RUN pecl install xdebug
 RUN docker-php-ext-enable xdebug
-
 COPY --from=composer:2 /usr/bin/composer /usr/bin/composer
 
 WORKDIR /var/www/html

extension.neon

@@ -0,0 +1,4 @@
+parameters:
+    universalObjectCratesClasses:
+        - Pest\Support\HigherOrderTapProxy
+        - Pest\Expectation

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

overrides/Runner/TestSuiteLoader.php

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

@@ -193,6 +193,7 @@ trait Testable
         $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
 
         $description = $this->dataName() ? $method->description.' with '.$this->dataName() : $method->description;
+        $description = htmlspecialchars(html_entity_decode($description), ENT_NOQUOTES);
 
         if ($method->repetitions > 1) {
             $matches = [];

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,12 +31,9 @@ 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;
 
 /**
- * @internal
- *
  * @template TValue
  *
  * @property OppositeExpectation $not Creates the opposite expectation.
@@ -127,6 +127,40 @@ final class Expectation
         exit(1);
     }
 
+    /**
+     * Dump the expectation value when the result of the condition is truthy.
+     *
+     * @param  (\Closure(TValue): bool)|bool  $condition
+     * @return self<TValue>
+     */
+    public function ddWhen(Closure|bool $condition, mixed ...$arguments): Expectation
+    {
+        $condition = $condition instanceof Closure ? $condition($this->value) : $condition;
+
+        if (! $condition) {
+            return $this;
+        }
+
+        $this->dd(...$arguments);
+    }
+
+    /**
+     * Dump the expectation value when the result of the condition is falsy.
+     *
+     * @param  (\Closure(TValue): bool)|bool  $condition
+     * @return self<TValue>
+     */
+    public function ddUnless(Closure|bool $condition, mixed ...$arguments): Expectation
+    {
+        $condition = $condition instanceof Closure ? $condition($this->value) : $condition;
+
+        if ($condition) {
+            return $this;
+        }
+
+        $this->dd(...$arguments);
+    }
+
     /**
      * Send the expectation value to Ray along with all given arguments.
      *
@@ -156,7 +190,7 @@ final class Expectation
      *
      * @return EachExpectation<TValue>
      */
-    public function each(callable $callback = null): EachExpectation
+    public function each(?callable $callback = null): EachExpectation
     {
         if (! is_iterable($this->value)) {
             throw new BadMethodCallException('Expectation value is not iterable.');
@@ -185,30 +219,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;
@@ -470,6 +500,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.
      */
@@ -492,7 +535,7 @@ final class Expectation
     }
 
     /**
-     * Asserts that the given expectation targets is an class.
+     * Asserts that the given expectation target is a class.
      */
     public function toBeClass(): ArchExpectation
     {
@@ -706,4 +749,131 @@ final class Expectation
             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;
@@ -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
      */
@@ -378,6 +392,21 @@ final class OppositeExpectation
         );
     }
 
+    /**
+     * 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.
      *
@@ -440,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/Functions.php

@@ -55,7 +55,7 @@ if (! function_exists('beforeEach')) {
      *
      * @return HigherOrderTapProxy<Expectable|TestCall|TestCase>|Expectable|TestCall|TestCase|mixed
      */
-    function beforeEach(Closure $closure = null): BeforeEachCall
+    function beforeEach(?Closure $closure = null): BeforeEachCall
     {
         $filename = Backtrace::file();
 
@@ -116,7 +116,7 @@ if (! function_exists('test')) {
      *
      * @return Expectable|TestCall|TestCase|mixed
      */
-    function test(string $description = null, Closure $closure = null): HigherOrderTapProxy|TestCall
+    function test(?string $description = null, ?Closure $closure = null): HigherOrderTapProxy|TestCall
     {
         if ($description === null && TestSuite::getInstance()->test instanceof \PHPUnit\Framework\TestCase) {
             return new HigherOrderTapProxy(TestSuite::getInstance()->test);
@@ -136,7 +136,7 @@ if (! function_exists('it')) {
      *
      * @return Expectable|TestCall|TestCase|mixed
      */
-    function it(string $description, Closure $closure = null): TestCall
+    function it(string $description, ?Closure $closure = null): TestCall
     {
         $description = sprintf('it %s', $description);
 
@@ -171,7 +171,7 @@ if (! function_exists('afterEach')) {
      *
      * @return Expectable|HigherOrderTapProxy<Expectable|TestCall|TestCase>|TestCall|mixed
      */
-    function afterEach(Closure $closure = null): AfterEachCall
+    function afterEach(?Closure $closure = null): AfterEachCall
     {
         $filename = Backtrace::file();
 

src/Logging/TeamCity/ServiceMessage.php

@@ -106,7 +106,7 @@ final class ServiceMessage
         ]);
     }
 
-    public static function testIgnored(string $name, string $message, string $details = null): self
+    public static function testIgnored(string $name, string $message, ?string $details = null): self
     {
         return new self('testIgnored', [
             'name' => $name,

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.
      *
@@ -813,6 +844,7 @@ final class Expectation
 
         $string = match (true) {
             is_string($this->value) => $this->value,
+            is_object($this->value) && method_exists($this->value, 'toSnapshot') => $this->value->toSnapshot(),
             is_object($this->value) && method_exists($this->value, '__toString') => $this->value->__toString(),
             is_object($this->value) && method_exists($this->value, 'toString') => $this->value->toString(),
             $this->value instanceof \Illuminate\Testing\TestResponse => $this->value->getContent(), // @phpstan-ignore-line
@@ -888,7 +920,7 @@ final class Expectation
      * @param  (Closure(Throwable): mixed)|string  $exception
      * @return self<TValue>
      */
-    public function toThrow(callable|string|Throwable $exception, string $exceptionMessage = null, string $message = ''): self
+    public function toThrow(callable|string|Throwable $exception, ?string $exceptionMessage = null, string $message = ''): self
     {
         $callback = NullClosure::create();
 
@@ -896,7 +928,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.');
             }
 
@@ -920,7 +952,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;
@@ -936,6 +968,7 @@ final class Expectation
             }
 
             Assert::assertInstanceOf($exception, $e, $message);
+
             $callback($e);
 
             return $this;
@@ -961,4 +994,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/AfterEachCall.php

@@ -35,7 +35,7 @@ final class AfterEachCall
     public function __construct(
         private readonly TestSuite $testSuite,
         private readonly string $filename,
-        Closure $closure = null
+        ?Closure $closure = null
     ) {
         $this->closure = $closure instanceof Closure ? $closure : NullClosure::create();
 

src/PendingCalls/BeforeEachCall.php

@@ -40,7 +40,7 @@ final class BeforeEachCall
     public function __construct(
         public readonly TestSuite $testSuite,
         private readonly string $filename,
-        Closure $closure = null
+        ?Closure $closure = null
     ) {
         $this->closure = $closure instanceof Closure ? $closure : NullClosure::create();
 

src/PendingCalls/TestCall.php

@@ -16,7 +16,9 @@ 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\AssertionFailedError;
 use PHPUnit\Framework\TestCase;
 
 /**
@@ -44,8 +46,8 @@ final class TestCall
     public function __construct(
         private readonly TestSuite $testSuite,
         private readonly string $filename,
-        string $description = null,
-        Closure $closure = null
+        ?string $description = null,
+        ?Closure $closure = null
     ) {
         $this->testCaseMethod = new TestCaseMethodFactory($filename, $description, $closure);
 
@@ -56,10 +58,18 @@ final class TestCall
         $this->testSuite->beforeEach->get($this->filename)[0]($this);
     }
 
+    /**
+     * Asserts that the test fails with the given message.
+     */
+    public function fails(?string $message = null): self
+    {
+        return $this->throws(AssertionFailedError::class, $message);
+    }
+
     /**
      * Asserts that the test throws the given `$exceptionClass` when called.
      */
-    public function throws(string|int $exception, string $exceptionMessage = null, int $exceptionCode = null): self
+    public function throws(string|int $exception, ?string $exceptionMessage = null, ?int $exceptionCode = null): self
     {
         if (is_int($exception)) {
             $exceptionCode = $exception;
@@ -91,7 +101,7 @@ final class TestCall
      *
      * @param  (callable(): bool)|bool  $condition
      */
-    public function throwsIf(callable|bool $condition, string|int $exception, string $exceptionMessage = null, int $exceptionCode = null): self
+    public function throwsIf(callable|bool $condition, string|int $exception, ?string $exceptionMessage = null, ?int $exceptionCode = null): self
     {
         $condition = is_callable($condition)
             ? $condition
@@ -104,6 +114,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,11 +237,35 @@ 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;
     }
 
+    /**
+     * Skips the current test unless the given test is running on Windows.
+     */
+    public function onlyOnWindows(): self
+    {
+        return $this->skipOnMac()->skipOnLinux();
+    }
+
+    /**
+     * Skips the current test unless the given test is running on Mac.
+     */
+    public function onlyOnMac(): self
+    {
+        return $this->skipOnWindows()->skipOnLinux();
+    }
+
+    /**
+     * Skips the current test unless the given test is running on Linux.
+     */
+    public function onlyOnLinux(): self
+    {
+        return $this->skipOnWindows()->skipOnMac();
+    }
+
     /**
      * Repeats the current test the given number of times.
      */
@@ -332,7 +384,7 @@ final class TestCall
      *
      * @param  array<int, mixed>|null  $arguments
      */
-    private function addChain(string $file, int $line, string $name, array $arguments = null): self
+    private function addChain(string $file, int $line, string $name, ?array $arguments = null): self
     {
         $exporter = Exporter::default();
 
@@ -361,7 +413,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.12.0';
+    return '2.30.0';
 }
 
 function testDirectory(string $file = ''): string
 {
-    return TestSuite::getInstance()->testPath.'/'.$file;
+    return TestSuite::getInstance()->testPath.DIRECTORY_SEPARATOR.$file;
 }

src/Plugins/Environment.php

@@ -45,7 +45,7 @@ final class Environment implements HandlesArguments
     /**
      * Gets the environment name.
      */
-    public static function name(string $name = null): string
+    public static function name(?string $name = null): string
     {
         if (is_string($name)) {
             self::$name = $name;

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;
@@ -33,7 +34,7 @@ final class Parallel implements HandlesArguments
     /**
      * @var string[]
      */
-    private const UNSUPPORTED_ARGUMENTS = ['--todos', '--retry'];
+    private const UNSUPPORTED_ARGUMENTS = ['--todo', '--todos', '--retry'];
 
     /**
      * Whether the given command line arguments indicate that the test suite should be run in parallel.

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,8 @@ 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;
@@ -30,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;
@@ -252,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]);
     }
@@ -295,6 +297,7 @@ final class WrapperRunner implements RunnerInterface
                 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(),
             );
         }
 
@@ -323,6 +326,8 @@ final class WrapperRunner implements RunnerInterface
             $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;
 
 /**

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

@@ -54,8 +54,8 @@ final class Result
                 $returnCode = self::FAILURE_EXIT;
             }
 
-            $warnings = $result->numberOfTestsWithTestTriggeredPhpunitWarningEvents() +
-                +count($result->warnings())
+            $warnings = $result->numberOfTestsWithTestTriggeredPhpunitWarningEvents()
+                + count($result->warnings())
                 + count($result->phpWarnings());
 
             if ($configuration->failOnWarning() && $warnings > 0) {

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

@@ -41,7 +41,7 @@ final class Exporter
      *
      * @param  array<int|string, mixed>  $data
      */
-    public function shortenedRecursiveExport(array &$data, Context $context = null): string
+    public function shortenedRecursiveExport(array &$data, ?Context $context = null): string
     {
         $result = [];
         $array = $data;

src/Support/Reflection.php

@@ -190,7 +190,7 @@ final class Reflection
             }
 
             $arguments[$parameter->getName()] = implode('|', array_map(
-                static fn (ReflectionNamedType $type): string => $type->getName(),
+                static fn (ReflectionNamedType $type): string => $type->getName(), // @phpstan-ignore-line
                 ($types instanceof ReflectionNamedType)
                     ? [$types] // NOTE: normalize as list of to handle unions
                     : $types->getTypes(),

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

@@ -87,8 +87,8 @@ final class TestSuite
      * Returns the current instance of the test suite.
      */
     public static function getInstance(
-        string $rootPath = null,
-        string $testPath = null,
+        ?string $rootPath = null,
+        ?string $testPath = null,
     ): TestSuite {
         if (is_string($rootPath) && is_string($testPath)) {
             self::$instance = new TestSuite($rootPath, $testPath);

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

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

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

@@ -1,5 +1,5 @@
 
-  Pest Testing Framework 2.12.0.  
+  Pest Testing Framework 2.30.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.12.0.  
+  Pest Testing Framework 2.30.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
@@ -429,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
@@ -443,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
@@ -491,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
@@ -518,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
@@ -574,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
@@ -626,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
@@ -654,6 +776,25 @@
   ✓ failures
   ✓ failures with message
   ✓ 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
@@ -695,6 +836,7 @@
   ✓ within describe → pass with dataset with ('my-datas-set-value')
   ✓ pass with toArray
   ✓ pass with array
+  ✓ pass with toSnapshot
   ✓ failures
   ✓ failures with custom message
   ✓ not failures
@@ -756,6 +898,14 @@
   ✓ it skips with falsy closure condition
   ✓ it can be used in higher order tests
 
+   PASS  Tests\Features\Fail
+  ✓ it may fail
+  ✓ it may fail with the given message
+
+   PASS  Tests\Features\Fails
+  ✓ it may fail
+  ✓ it may fail with the given message
+
    WARN  Tests\Features\Helpers
   ✓ it can set/get properties on $this
   ! it gets null if property do not exist → Undefined property Tests\Features\Helpers::$wqdwqdqw
@@ -927,6 +1077,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
@@ -976,17 +1129,9 @@
    PASS  Tests\Helpers\TestInHelpers
   ✓ it executes tests in the Helpers directory
 
-   PASS  Tests\Hooks\AfterAllTest
-  ✓ global afterAll execution order
-  ✓ it only gets called once per file
-
    PASS  Tests\Hooks\AfterEachTest
   ✓ global afterEach execution order
 
-   PASS  Tests\Hooks\BeforeAllTest
-  ✓ global beforeAll execution order
-  ✓ it only gets called once per file
-
    PASS  Tests\Hooks\BeforeEachTest
   ✓ global beforeEach execution order
 
@@ -1015,9 +1160,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
 
@@ -1052,6 +1203,7 @@
   ✓ it show the correct description for mixed named and not-named datasets
   ✓ it shows the correct description for long texts with newlines
   ✓ it shows the correct description for arrays with many elements
+  ✓ it shows the correct description of datasets with html
 
    PASS  Tests\Unit\Expectations\OppositeExpectation
   ✓ it throw expectation failed exception with string argument
@@ -1204,10 +1356,12 @@
   - visual snapshot of team city with ('SuccessOnly.php')
 
    PASS  Tests\Visual\Todo
+  ✓ todos
+  ✓ todos in parallel
   ✓ todo
   ✓ todo in parallel
 
    WARN  Tests\Visual\Version
   - visual snapshot of help command output
 
-  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 13 todos, 19 skipped, 860 passed (1975 assertions)
+  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 13 todos, 19 skipped, 970 passed (2296 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/.snapshots/todos.txt

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

tests/Arch.php

@@ -2,12 +2,12 @@
 
 use Pest\Expectation;
 
-test('globals')
-    ->expect(['dd', 'dump', 'ray'])
+arch('globals')
+    ->expect(['dd', 'dump', 'ray', 'die', 'var_dump', 'sleep'])
     ->not->toBeUsed()
     ->ignoring(Expectation::class);
 
-test('dependencies')
+arch('dependencies')
     ->expect('Pest')
     ->toOnlyUse([
         'dd',
@@ -24,7 +24,7 @@ test('dependencies')
         'Symfony\Component\Process',
     ])->ignoring(['Composer', 'PHPUnit', 'SebastianBergmann']);
 
-test('contracts')
+arch('contracts')
     ->expect('Pest\Contracts')
     ->toOnlyUse([
         'NunoMaduro\Collision\Contracts',

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/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();
+});

tests/Features/Expect/toHaveAttribute.php

@@ -0,0 +1,18 @@
+<?php
+
+use Pest\Arch\Exceptions\ArchExpectationFailedException;
+
+test('class has attribute')
+    ->expect('Tests\\Fixtures\\Arch\\ToHaveAttribute\\HaveAttribute')
+    ->toHaveAttribute('Tests\\Fixtures\\Arch\\ToHaveAttribute\\Attributes\\AsAttribute');
+
+test('opposite class has attribute')
+    ->throws(ArchExpectationFailedException::class)
+    ->expect('Tests\\Fixtures\\Arch\\ToHaveAttribute\\HaveAttribute')
+    ->not
+    ->toHaveAttribute('Tests\\Fixtures\\Arch\\ToHaveAttribute\\Attributes\\AsAttribute');
+
+test('class not has attribute')
+    ->expect('Tests\\Fixtures\\Arch\\ToHaveAttribute\\NotHaveAttribute')
+    ->not
+    ->toHaveAttribute('Tests\\Fixtures\\Arch\\ToHaveAttribute\\Attributes\\AsAttribute');

tests/Features/Expect/toHaveCamelCaseKeys.php

@@ -0,0 +1,36 @@
+<?php
+
+use Pest\Exceptions\InvalidExpectationValue;
+use PHPUnit\Framework\ExpectationFailedException;
+
+$array = [
+    'camel' => true,
+    'camelCase' => [
+        'camel' => true,
+        'camelCase' => [
+            'camel' => true,
+            'camelCase' => true,
+        ],
+        'list' => [
+            'abc',
+            'def',
+            'ghi',
+        ],
+    ],
+];
+
+test('pass', function () use ($array) {
+    expect($array)->toHaveCamelCaseKeys();
+});
+
+test('failures', function () {
+    expect('not-an-array')->toHaveCamelCaseKeys();
+})->throws(InvalidExpectationValue::class);
+
+test('failures with message', function () use ($array) {
+    expect($array)->not->toHaveCamelCaseKeys('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () use ($array) {
+    expect($array)->not->toHaveCamelCaseKeys();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toHaveConstructor.php

@@ -0,0 +1,9 @@
+<?php
+
+test('class has constructor')
+    ->expect('Tests\Fixtures\Arch\ToHaveConstructor\HasConstructor\HasConstructor')
+    ->toHaveConstructor();
+
+test('class has no constructor')
+    ->expect('Tests\Fixtures\Arch\ToHaveConstructor\HasNoConstructor\HasNoConstructor')
+    ->not->toHaveConstructor();

tests/Features/Expect/toHaveCount.php

@@ -1,11 +1,16 @@
 <?php
 
+use Pest\Exceptions\InvalidExpectationValue;
 use PHPUnit\Framework\ExpectationFailedException;
 
 test('pass', function () {
     expect([1, 2, 3])->toHaveCount(3);
 });
 
+test('failures with invalid type', function () {
+    expect('foo')->toHaveCount(3);
+})->throws(InvalidExpectationValue::class, 'Invalid expectation value type. Expected [countable|iterable]');
+
 test('failures', function () {
     expect([1, 2, 3])->toHaveCount(4);
 })->throws(ExpectationFailedException::class);

tests/Features/Expect/toHaveDestructor.php

@@ -0,0 +1,9 @@
+<?php
+
+test('class has destructor')
+    ->expect('Tests\Fixtures\Arch\ToHaveDestructor\HasDestructor\HasDestructor')
+    ->toHaveDestructor();
+
+test('class has no destructor')
+    ->expect('Tests\Fixtures\Arch\ToHaveDestructor\HasNoDestructor\HasNoDestructor')
+    ->not->toHaveDestructor();

tests/Features/Expect/toHaveKebabCaseKeys.php

@@ -0,0 +1,36 @@
+<?php
+
+use Pest\Exceptions\InvalidExpectationValue;
+use PHPUnit\Framework\ExpectationFailedException;
+
+$array = [
+    'kebab' => true,
+    'kebab-case' => [
+        'kebab' => true,
+        'kebab-case' => [
+            'kebab' => true,
+            'kebab-case' => true,
+        ],
+        'list' => [
+            'abc',
+            'def',
+            'ghi',
+        ],
+    ],
+];
+
+test('pass', function () use ($array) {
+    expect($array)->toHaveKebabCaseKeys();
+});
+
+test('failures', function () {
+    expect('not-an-array')->toHaveKebabCaseKeys();
+})->throws(InvalidExpectationValue::class);
+
+test('failures with message', function () use ($array) {
+    expect($array)->not->toHaveKebabCaseKeys('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () use ($array) {
+    expect($array)->not->toHaveKebabCaseKeys();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toHaveKey.php

@@ -62,15 +62,15 @@ test('fails with wrong value and plain key with dots', function () use ($test_ar
 
 test('not failures', function () use ($test_array) {
     expect($test_array)->not->toHaveKey('c');
-})->throws(ExpectationFailedException::class, "Expecting Array (…) not to have key 'c'");
+})->throws(ExpectationFailedException::class, "Expecting […] not to have key 'c'");
 
 test('not failures with nested key', function () use ($test_array) {
     expect($test_array)->not->toHaveKey('d.e');
-})->throws(ExpectationFailedException::class, "Expecting Array (…) not to have key 'd.e'");
+})->throws(ExpectationFailedException::class, "Expecting […] not to have key 'd.e'");
 
 test('not failures with plain key with dots', function () use ($test_array) {
     expect($test_array)->not->toHaveKey('key.with.dots');
-})->throws(ExpectationFailedException::class, "Expecting Array (…) not to have key 'key.with.dots'");
+})->throws(ExpectationFailedException::class, "Expecting […] not to have key 'key.with.dots'");
 
 test('not failures with correct value', function () use ($test_array) {
     expect($test_array)->not->toHaveKey('c', 'world');

tests/Features/Expect/toHaveMethod.php

@@ -1,28 +1,29 @@
 <?php
 
-use PHPUnit\Framework\ExpectationFailedException;
+use Pest\Arch\Exceptions\ArchExpectationFailedException;
 
-$object = new class
-{
-    public function foo(): void
-    {
-    }
-};
+test('class has method')
+    ->expect('Tests\Fixtures\Arch\ToHaveMethod\HasMethod\HasMethod')
+    ->toHaveMethod('foo');
 
-test('pass', function () use ($object) {
-    expect($object)->toHaveMethod('foo')
-        ->and($object)->toHaveMethod('foo')
-        ->and($object)->not->toHaveMethod('fooNull');
-});
+test('opposite class has method')
+    ->throws(ArchExpectationFailedException::class)
+    ->expect('Tests\Fixtures\Arch\ToHaveMethod\HasMethod\HasMethod')
+    ->not->toHaveMethod('foo');
 
-test('failures', function () use ($object) {
-    expect($object)->toHaveMethod('bar');
-})->throws(ExpectationFailedException::class);
+test('class has method via a parent class')
+    ->expect('Tests\Fixtures\Arch\ToHaveMethod\HasMethod\HasMethodViaParent')
+    ->toHaveMethod('foo');
 
-test('failures with message', function () use ($object) {
-    expect($object)->toHaveMethod(name: 'bar', message: 'oh no!');
-})->throws(ExpectationFailedException::class, 'oh no!');
+test('class has method via a trait')
+    ->expect('Tests\Fixtures\Arch\ToHaveMethod\HasMethod\HasMethodViaTrait')
+    ->toHaveMethod('foo');
 
-test('not failures', function () use ($object) {
-    expect($object)->not->toHaveMethod('foo');
-})->throws(ExpectationFailedException::class);
+test('failure when the class has no method')
+    ->throws(ArchExpectationFailedException::class)
+    ->expect('Tests\Fixtures\Arch\ToHaveMethod\HasNoMethod\HasNoMethodClass')
+    ->toHaveMethod('foo');
+
+test('class has no method')
+    ->expect('Tests\Fixtures\Arch\ToHaveMethod\HasNoMethod\HasNoMethodClass')
+    ->not->toHaveMethod('foo');

tests/Features/Expect/toHaveSameSize.php

@@ -0,0 +1,24 @@
+<?php
+
+use Pest\Exceptions\InvalidExpectationValue;
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('failures with wrong type', function () {
+    expect('foo')->toHaveSameSize([1]);
+})->throws(InvalidExpectationValue::class, 'Invalid expectation value type. Expected [countable|iterable].');
+
+test('pass', function () {
+    expect([1, 2, 3])->toHaveSameSize([4, 5, 6]);
+});
+
+test('failures', function () {
+    expect([1, 2, 3])->toHaveSameSize([1]);
+})->throws(ExpectationFailedException::class);
+
+test('failures with message', function () {
+    expect([1, 2, 3])->toHaveSameSize([1], 'oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect([1, 2, 3])->not->toHaveSameSize([1]);
+});

tests/Features/Expect/toHaveSnakeCaseKeys.php

@@ -0,0 +1,36 @@
+<?php
+
+use Pest\Exceptions\InvalidExpectationValue;
+use PHPUnit\Framework\ExpectationFailedException;
+
+$array = [
+    'snake' => true,
+    'snake_case' => [
+        'snake' => true,
+        'snake_case' => [
+            'snake' => true,
+            'snake_case' => true,
+        ],
+        'list' => [
+            'abc',
+            'def',
+            'ghi',
+        ],
+    ],
+];
+
+test('pass', function () use ($array) {
+    expect($array)->toHaveSnakeCaseKeys();
+});
+
+test('failures', function () {
+    expect('not-an-array')->toHaveSnakeCaseKeys();
+})->throws(InvalidExpectationValue::class);
+
+test('failures with message', function () use ($array) {
+    expect($array)->not->toHaveSnakeCaseKeys('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () use ($array) {
+    expect($array)->not->toHaveSnakeCaseKeys();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toHaveStudlyCaseKeys.php

@@ -0,0 +1,36 @@
+<?php
+
+use Pest\Exceptions\InvalidExpectationValue;
+use PHPUnit\Framework\ExpectationFailedException;
+
+$array = [
+    'Studly' => true,
+    'StudlyCase' => [
+        'Studly' => true,
+        'StudlyCase' => [
+            'Studly' => true,
+            'StudlyCase' => true,
+        ],
+        'List' => [
+            'abc',
+            'def',
+            'ghi',
+        ],
+    ],
+];
+
+test('pass', function () use ($array) {
+    expect($array)->toHaveStudlyCaseKeys();
+});
+
+test('failures', function () {
+    expect('not-an-array')->toHaveStudlyCaseKeys();
+})->throws(InvalidExpectationValue::class);
+
+test('failures with message', function () use ($array) {
+    expect($array)->not->toHaveStudlyCaseKeys('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () use ($array) {
+    expect($array)->not->toHaveStudlyCaseKeys();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toMatchSnapshot.php

@@ -103,6 +103,26 @@ test('pass with array', function () {
     ])->toMatchSnapshot();
 });
 
+test('pass with `toSnapshot`', function () {
+    TestSuite::getInstance()->snapshots->save(json_encode(['key' => $this->snapshotable], JSON_PRETTY_PRINT));
+
+    $object = new class($this->snapshotable)
+    {
+        public function __construct(protected string $snapshotable)
+        {
+        }
+
+        public function toSnapshot()
+        {
+            return json_encode([
+                'key' => $this->snapshotable,
+            ], JSON_PRETTY_PRINT);
+        }
+    };
+
+    expect($object)->toMatchSnapshot();
+});
+
 test('failures', function () {
     TestSuite::getInstance()->snapshots->save($this->snapshotable);
 

tests/Features/Expect/toThrow.php

@@ -57,8 +57,9 @@ test('failures 3', function () {
     expect(function () {
         throw new Exception();
     })->toThrow(function (RuntimeException $e) {
+        //
     });
-})->throws(ExpectationFailedException::class, 'Failed asserting that Exception Object');
+})->throws(ExpectationFailedException::class, 'Failed asserting that an object is an instance of class RuntimeException.');
 
 test('failures 4', function () {
     expect(function () {
@@ -73,7 +74,7 @@ test('failures 5', function () {
     expect(function () {
         throw new Exception('actual message');
     })->toThrow('expected message');
-})->throws(ExpectationFailedException::class, 'Failed asserting that \'actual message\' contains "expected message".');
+})->throws(ExpectationFailedException::class, 'Failed asserting that \'actual message\' [ASCII](length: 14) contains "expected message" [ASCII](length: 16).');
 
 test('failures 6', function () {
     expect(function () {

tests/Features/Fail.php

@@ -0,0 +1,11 @@
+<?php
+
+use PHPUnit\Framework\AssertionFailedError;
+
+it('may fail', function () {
+    $this->fail();
+})->throws(AssertionFailedError::class);
+
+it('may fail with the given message', function () {
+    $this->fail('this is a failure');
+})->throws(AssertionFailedError::class, 'this is a failure');

tests/Features/Fails.php

@@ -0,0 +1,9 @@
+<?php
+
+it('may fail', function () {
+    $this->fail();
+})->fails();
+
+it('may fail with the given message', function () {
+    $this->fail('this is a failure');
+})->fails('this is a failure');

tests/Features/ScopedDatasets/TestFileOutOfScope.php

@@ -10,3 +10,12 @@ test('uses dataset', function ($value) use ($state) {
 test('the right dataset is taken', function () use ($state) {
     expect($state->text)->toBe('12');
 });
+
+it('can see datasets defined in Pest.php file', function (string $value) use ($state) {
+    $state->text .= $value;
+    expect(true)->toBe(true);
+})->with('dataset_in_pest_file');
+
+test('Pest.php dataset is taken', function () use ($state) {
+    expect($state->text)->toBe('12AB');
+});

tests/Features/TestCycle.php

@@ -8,16 +8,16 @@ $foo->beforeEach = false;
 $foo->afterEach = false;
 $foo->afterAll = false;
 
-beforeAll(function () {
+beforeAll(function () use ($foo) {
     $foo->beforeAll = true;
 });
-beforeEach(function () {
+beforeEach(function () use ($foo) {
     $foo->beforeEach = true;
 });
-afterEach(function () {
+afterEach(function () use ($foo) {
     $foo->afterEach = true;
 });
-afterAll(function () {
+afterAll(function () use ($foo) {
     $foo->afterAll = true;
 });
 

tests/Fixtures/Arch/ToHaveAttribute/Attributes/AsAttribute.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Fixtures\Arch\ToHaveAttribute\Attributes;
+
+use Attribute;
+
+#[Attribute()]
+class AsAttribute
+{
+}

tests/Fixtures/Arch/ToHaveAttribute/HaveAttribute/HaveAttributeClass.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Fixtures\Arch\ToHaveAttribute\HaveAttribute;
+
+use Tests\Fixtures\Arch\ToHaveAttribute\Attributes\AsAttribute;
+
+#[AsAttribute]
+class HaveAttributeClass
+{
+}

tests/Fixtures/Arch/ToHaveAttribute/NotHaveAttribute/NotHaveAttributeClass.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Fixtures\Arch\ToHaveAttribute\NotHaveAttribute;
+
+class NotHaveAttributeClass
+{
+}

tests/Fixtures/Arch/ToHaveConstructor/HasConstructor/HasConstructor.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Fixtures\Arch\ToHaveConstructor\HasConstructor;
+
+class HasConstructor
+{
+    public function __construct()
+    {
+
+    }
+}

tests/Fixtures/Arch/ToHaveConstructor/HasNoConstructor/HasNoConstructor.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Fixtures\Arch\ToHaveConstructor\HasNoConstructor;
+
+class HasNoConstructor
+{
+}

tests/Fixtures/Arch/ToHaveDestructor/HasDestructor/HasDestructor.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Fixtures\Arch\ToHaveDestructor\HasDestructor;
+
+class HasDestructor
+{
+    public function __destruct()
+    {
+
+    }
+}

tests/Fixtures/Arch/ToHaveDestructor/HasNoDestructor/HasNoDestructor.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Fixtures\Arch\ToHaveDestructor\HasNoDestructor;
+
+class HasNoDestructor
+{
+}