release: v2.18.0

[2.x] Correct some  comment messages in `OppositeExpectation`

.editorconfig

@@ -14,5 +14,5 @@ trim_trailing_whitespace = true
 [*.md]
 trim_trailing_whitespace = false
 
-[*.yml]
+[*.{yml,yaml}]
 indent_size = 2

.gitattributes

@@ -1,16 +1,18 @@
-/art               export-ignore
+/docker                  export-ignore
 /docs                    export-ignore
 /tests                   export-ignore
 /scripts                 export-ignore
 /.github                 export-ignore
-/.php_cs           export-ignore
 .editorconfig            export-ignore
 .gitattributes           export-ignore
 .gitignore               export-ignore
-.travis.yml        export-ignore
-phpstan.neon       export-ignore
-rector.yaml        export-ignore
-phpunit.xml        export-ignore
-CHANGELOG.md       export-ignore
-CONTRIBUTING.md    export-ignore
-README.md          export-ignore
+/phpstan.neon            export-ignore
+/phpunit.xml             export-ignore
+/CHANGELOG.md            export-ignore
+/CONTRIBUTING.md         export-ignore
+/docker-compose.yml      export-ignore
+/Makefile                export-ignore
+/rector.php              export-ignore
+/README.md               export-ignore
+/RELEASE.md              export-ignore
+

.github/FUNDING.yml

@@ -1,5 +1,4 @@
 # These are supported funding model platforms
 
-github: nunomaduro
-patreon: nunomaduro
-custom: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=66BYDWAT92N6L
+github: [nunomaduro]
+custom: https://www.paypal.com/paypalme/enunomaduro

.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

@@ -0,0 +1,16 @@
+<!--
+- 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/formats.yml

@@ -1,46 +0,0 @@
-name: Formats
-
-on: ['push', 'pull_request']
-
-jobs:
-  ci:
-    runs-on: ${{ matrix.os }}
-
-    strategy:
-      fail-fast: true
-      matrix:
-        os: [ubuntu-latest]
-        php: [7.4]
-        dependency-version: [prefer-lowest, prefer-stable]
-
-    name: Formats P${{ matrix.php }} - ${{ matrix.os }} - ${{ matrix.dependency-version }}
-
-    steps:
-
-    - name: Checkout
-      uses: actions/checkout@v2
-
-    - name: Cache dependencies
-      uses: actions/cache@v1
-      with:
-        path: ~/.composer/cache/files
-        key: dependencies-php-${{ matrix.php }}-composer-${{ hashFiles('composer.json') }}
-
-    - name: Setup PHP
-      uses: shivammathur/setup-php@v2
-      with:
-        php-version: ${{ matrix.php }}
-        extensions: mbstring, zip
-        tools: prestissimo
-        coverage: pcov
-
-    - name: Install Composer dependencies
-      run: composer update --${{ matrix.dependency-version }} --no-interaction --prefer-dist
-
-    - name: Coding Style Checks
-      run: |
-           vendor/bin/rector process src --dry-run
-           vendor/bin/php-cs-fixer fix -v --dry-run
-
-    - name: Type Checks
-      run: vendor/bin/phpstan analyse --ansi

.github/workflows/integration-tests.yml

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

.github/workflows/static.yml

@@ -0,0 +1,43 @@
+name: Static Analysis
+
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: '0 0 * * *'
+
+jobs:
+  static:
+    if: github.event_name != 'schedule' || github.repository == 'pestphp/pest'
+    name: Static Tests
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        dependency-version: [prefer-lowest, prefer-stable]
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Setup PHP
+      uses: shivammathur/setup-php@v2
+      with:
+        php-version: 8.1
+        tools: composer:v2
+        coverage: none
+
+    - name: Install Dependencies
+      run: composer update --prefer-stable --no-interaction --no-progress --ansi
+
+    - name: Type Check
+      run: composer test:type:check
+
+    - name: Type Coverage
+      run: composer test:type:coverage
+
+    - name: Refacto
+      run: composer test:refacto
+
+    - name: Style
+      run: composer test:lint

.github/workflows/tests.yml

@@ -1,42 +1,46 @@
 name: Tests
 
-on: ['push', 'pull_request']
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: '0 0 * * *'
+
 
 jobs:
   ci:
+    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: [7.3, 7.4]
+        php: ['8.1', '8.2', '8.3']
         dependency-version: [prefer-lowest, prefer-stable]
 
-    name: Tests P${{ matrix.php }} - ${{ matrix.os }} - ${{ matrix.dependency-version }}
+    name: PHP ${{ matrix.php }} - ${{ matrix.os }} - ${{ matrix.dependency-version }}
 
     steps:
-
     - name: Checkout
       uses: actions/checkout@v2
 
-    - name: Cache dependencies
-      uses: actions/cache@v1
-      with:
-        path: ~/.composer/cache/files
-        key: dependencies-php-${{ matrix.php }}-composer-${{ hashFiles('composer.json') }}
-
     - name: Setup PHP
       uses: shivammathur/setup-php@v2
       with:
         php-version: ${{ matrix.php }}
-        extensions: mbstring, zip
+        tools: composer:v2
         coverage: none
 
-    - name: Install Composer dependencies
-      run: composer update --${{ matrix.dependency-version }} --no-interaction --prefer-dist
+    - 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: Unit Tests
-      run: bin/pest --colors=always --exclude-group=integration
+      run: composer test:unit
+
+    - name: Unit Tests in Parallel
+      run: composer test:parallel
 
-    - name: Integration Tests
-      run: bin/pest --colors=always --group=integration

.gitignore

@@ -1,10 +1,14 @@
 .idea/*
 .idea/codeStyleSettings.xml
+.temp/*
 composer.lock
 /vendor/
 coverage.xml
 .phpunit.result.cache
-.php_cs.cache
+.phpunit.cache
+/.php-cs-fixer.php
+.php-cs-fixer.cache
 .temp/coverage.php
 *.swp
 *.swo
+.vscode/

.php_cs

@@ -1,32 +0,0 @@
-<?php
-
-$finder = PhpCsFixer\Finder::create()
-    ->in(__DIR__ . DIRECTORY_SEPARATOR . 'tests')
-    ->in(__DIR__ . DIRECTORY_SEPARATOR . 'bin')
-    ->in(__DIR__ . DIRECTORY_SEPARATOR . 'compiled')
-    ->in(__DIR__ . DIRECTORY_SEPARATOR . 'scripts')
-    ->in(__DIR__ . DIRECTORY_SEPARATOR . 'stubs')
-    ->in(__DIR__ . DIRECTORY_SEPARATOR . 'src')
-    ->append(['.php_cs']);
-
-$rules = [
-    '@Symfony'               => true,
-    'phpdoc_no_empty_return' => false,
-    'array_syntax'           => ['syntax' => 'short'],
-    'yoda_style'             => false,
-    'binary_operator_spaces' => [
-        'operators' => [
-            '=>' => 'align',
-            '='  => 'align',
-        ],
-    ],
-    'concat_space'            => ['spacing' => 'one'],
-    'not_operator_with_space' => false,
-];
-
-$rules['increment_style'] = ['style' => 'post'];
-
-return PhpCsFixer\Config::create()
-    ->setUsingCache(true)
-    ->setRules($rules)
-    ->setFinder($finder);

CHANGELOG.md

@@ -1,37 +1,274 @@
-# Changelog
-All notable changes to this project will be documented in this file.
+# Release Notes for 2.x
 
-The format is based on [Keep a Changelog](http://keepachangelog.com/)
-and this project adheres to [Semantic Versioning](http://semver.org/).
+## Unreleased
 
-## [Unreleased]
+## [v2.17.0 (2023-09-04)](https://github.com/pestphp/pest/compare/v2.16.1...v2.17.0)
 
-## [v0.1.5 (2020-05-24)](https://github.com/pestphp/pest/compare/v0.1.4...v0.1.5)
-### Fixed
-- Missing default decorated output on coverage ([88d2391(https://github.com/pestphp/pest/commit/88d2391d2e6fe9c9416462734b9b523cb418f469))
-
-## [v0.1.4 (2020-05-24)](https://github.com/pestphp/pest/compare/v0.1.3...v0.1.4)
 ### Added
-- Support to Lumen on artisan commands ([#18](https://github.com/pestphp/pest/pull/18))
+
+- `toHaveMethod` expectation ([#947](https://github.com/pestphp/pest/pull/947))
+- `toHaveAttribute` expectation ([#934](https://github.com/pestphp/pest/pull/934))
+
+## [v2.16.1 (2023-08-29)](https://github.com/pestphp/pest/compare/v2.16.0...v2.16.1)
+
+> New changelog format starting this release.
+
+### Added
+* `toHaveSameSize` expectation by @hungthai1401 in https://github.com/pestphp/pest/pull/924, https://github.com/pestphp/pest/pull/930
 
 ### Fixed
-- Mockery tests without assertions being considered risky ([415f571](https://github.com/pestphp/pest/commit/415f5719101b30c11d87f74810a71686ef2786c6))
+* Inconsistent type have count exception by @hungthai1401 in https://github.com/pestphp/pest/pull/923
+* Datasets defined in `Pest.php` 
 
-## [v0.1.3 (2020-05-21)](https://github.com/pestphp/pest/compare/v0.1.2...v0.1.3)
-### Added
-- `Plugin::uses()` method for making traits globally available ([6c4be01](https://github.com/pestphp/pest/commit/6c4be0190e9493702a976b996bbbf5150cc6bb53))
+## [v2.16.0 (2023-08-21)](https://github.com/pestphp/pest/compare/v2.15.0...v2.16.0)
 
-## [v0.1.2 (2020-05-15)](https://github.com/pestphp/pest/compare/v0.1.1...v0.1.2)
 ### Added
-- Support to custom helpers ([#7](https://github.com/pestphp/pest/pull/7))
 
-## [v0.1.1 (2020-05-14)](https://github.com/pestphp/pest/compare/v0.1.0...v0.1.1)
-### Added
-- `test` function without any arguments returns the current test case ([6fc55be](https://github.com/pestphp/pest/commit/6fc55becc8aecff685a958617015be1a4c118b01))
+- `toBeDigits` ([#911](https://github.com/pestphp/pest/pull/911))
+- `toBeCamelCase`, `toBeKebabCase`, `toBeSnakeCase`, `toBeStudlyCase`, `toHaveSnakeCaseKeys`, `toHaveKebabCaseKeys`, `toHaveCamelCaseKeys`, `toHaveStudlyCaseKeys`` ([#921](https://github.com/pestphp/pest/pull/921))
+- native functions support on `arch` expectations, e.g: `expect('sleep')->toBeUsed();` ([#4](https://github.com/pestphp/pest-plugin-arch/pull/4))
+
+### Changed
+
+- `phpunit.xml` stub ([#915](https://github.com/pestphp/pest/pull/915))
 
 ### Fixed
-- "No coverage driver error" now returns proper error on Laravel ([28d8822](https://github.com/pestphp/pest/commit/28d8822de01f4fa92c62d8b8e019313f382b97e9))
 
-## [v0.1.0 (2020-05-09)](https://github.com/pestphp/pest/commit/de2929077b344a099ef9c2ddc2f48abce14e248f)
+- Nested sequences ([#895](https://github.com/pestphp/pest/pull/895))
+
+## [v2.15.0 (2023-08-17)](https://github.com/pestphp/pest/compare/v2.14.1...v2.15.0)
+
 ### Added
-- First version
+
+- PHP 8.3 support ([0b261ef](https://github.com/pestphp/pest/commit/0b261ef97b7ceed20cbeeb2b0b41e08e0a8fcaa1))
+
+## [v2.14.1 (2023-08-16)](https://github.com/pestphp/pest/compare/v2.14.0...v2.14.1)
+
+### Changed
+
+- Bumps PHPUnit to `^10.3.2` ([e012517](https://github.com/pestphp/pest/commit/e012517b1643002b36a68096f4a5e26682b1e175))
+
+## [v2.14.0 (2023-08-14)](https://github.com/pestphp/pest/compare/v2.13.0...v2.14.0)
+
+### Added
+
+- `toBeUppercase()`, `toBeLowercase()`, `toBeAlphaNumeric()`, `toBeAlpha()` ([#906](https://github.com/pestphp/pest/pull/906))
+
+## [v2.13.0 (2023-08-09)](https://github.com/pestphp/pest/compare/v2.12.2...v2.13.0)
+
+### Added
+
+- `expect()->ddWhen` and `expect()->ddUnless` ([306b7eb](https://github.com/pestphp/pest/commit/306b7eb2a6a57e570d58228b46501ad9ba4062b4))
+
+## [v2.12.2 (2023-08-07)](https://github.com/pestphp/pest/compare/v2.12.0...v2.12.2)
+
+### Fixed
+
+- Running tests from `uses` parent class ([#898](https://github.com/pestphp/pest/pull/898))
+
+## [v2.12.0 (2023-08-02)](https://github.com/pestphp/pest/compare/v2.11.0...v2.12.0)
+
+### Added
+
+- Allows multiple `toMatchSnapshot` per test ([#881](https://github.com/pestphp/pest/pull/881))
+
+### Changed
+
+- Bumps PHPUnit to `^10.2.7` ([43107c1](https://github.com/pestphp/pest/commit/43107c17436e41e23018ae31705c688168c14784))
+
+## [v2.11.0 (2023-08-01)](https://github.com/pestphp/pest/compare/v2.10.1...v2.11.0)
+
+### Added
+
+- `toBeInvokable`expectation ([#891](https://github.com/pestphp/pest/pull/891))
+
+## [v2.10.1 (2023-07-31)](https://github.com/pestphp/pest/compare/v2.10.0...v2.10.1)
+
+### Fixed
+
+- `not->toHaveSuffix` and `toHavePrefix` expectations ([#888](https://github.com/pestphp/pest/pull/888))
+
+## [v2.10.0 (2023-07-31)](https://github.com/pestphp/pest/compare/v2.9.5...v2.10.0)
+
+### Added
+
+- `repeat` feature ([f3f35a2](https://github.com/pestphp/pest/commit/f3f35a2ed119f63eefd323a8c66d3387e908df3f))
+
+### Fixed
+
+- `-v` option ([86a6b32](https://github.com/pestphp/pest/commit/86a6b3271518742dc39761228687a5107551d279))
+
+## [v2.9.5 (2023-07-22)](https://github.com/pestphp/pest/compare/v2.9.4...v2.9.5)
+
+### Fixed
+
+- Assertions count on arch expectations ([632ffc2](https://github.com/pestphp/pest/commit/632ffc2f8e1fe45f739b12b818426ae14700079e))
+
+## [v2.9.4 (2023-07-22)](https://github.com/pestphp/pest/compare/v2.9.3...v2.9.4)
+
+### Fixed
+
+- Output on `describe` `beforeEach` failure ([5637dfa](https://github.com/pestphp/pest/commit/5637dfa75d1a331adc810935536cde7c3196af06))
+
+## [v2.9.3 (2023-07-20)](https://github.com/pestphp/pest/compare/v2.9.2...v2.9.3)
+
+### Fixed
+
+- Snapshots directory on Windows environments ([cf52752](https://github.com/pestphp/pest/commit/cf5275293fe693ec2cf4dbadbadae01daaa08169))
+
+## [v2.9.2 (2023-07-20)](https://github.com/pestphp/pest/compare/v2.9.1...v2.9.2)
+
+### Fixed
+
+- `beforeEach` on Windows environments ([a37a3b9](https://github.com/pestphp/pest/commit/a37a3b9f9931bc1ab1ea9e1d6d38dfb55dde3f74))
+
+## [v2.9.1 (2023-07-20)](https://github.com/pestphp/pest/compare/v2.9.0...v2.9.1)
+
+### Chore
+
+- Bumps PHPUnit to `^10.2.6` ([8fdb0b3](https://github.com/pestphp/pest/commit/8fdb0b3d32ce9ee12bd182f22751c2b41a53e97b))
+
+## [v2.9.0 (2023-07-19)](https://github.com/pestphp/pest/compare/v2.8.1...v2.9.0)
+
+> "Spicy Summer" is the codename assigned to Pest 2.9, for full details check our announcement: [https://pestphp.com/docs/pest-spicy-summer-release](https://pestphp.com/docs/pest-spicy-summer-release)
+
+### Added
+
+- Built-in Snapshot Testing ([c828756](https://github.com/pestphp/pest/commit/c8287567eb8c3dbea5845b2a6f70804b094b4b60))
+- Describe Blocks ([c828756](https://github.com/pestphp/pest/commit/c8287567eb8c3dbea5845b2a6f70804b094b4b60))
+- Architectural Testing++ ([c828756](https://github.com/pestphp/pest/commit/c8287567eb8c3dbea5845b2a6f70804b094b4b60))
+- Type Coverage Plugin ([c828756](https://github.com/pestphp/pest/commit/c8287567eb8c3dbea5845b2a6f70804b094b4b60))
+- Drift Plugin ([c828756](https://github.com/pestphp/pest/commit/c8287567eb8c3dbea5845b2a6f70804b094b4b60))
+
+## [v2.8.1 (2023-06-20)](https://github.com/pestphp/pest/compare/v2.8.0...v2.8.1)
+
+### Fixed
+- Fixes "Cannot find TestCase object on call stack" ([eb7bb34](https://github.com/pestphp/pest/commit/eb7bb348253f412e806a6ba6f0df46c0435d0dfe))
+
+## [v2.8.0 (2023-06-19)](https://github.com/pestphp/pest/compare/v2.7.0...v2.8.0)
+
+### Added
+- Support for `globs` in `uses` ([#829](https://github.com/pestphp/pest/pull/829))
+
+## [v2.7.0 (2023-06-15)](https://github.com/pestphp/pest/compare/v2.6.3...v2.7.0)
+
+### Added
+- Support for unexpected output on printer ([eb9f31e](https://github.com/pestphp/pest/commit/eb9f31edeb00a88c449874f3d48156128a00fff8))
+
+### Chore
+- Bumps PHPUnit to `^10.2.2` ([0e5470b](https://github.com/pestphp/pest/commit/0e5470b192b259ba2db7c02a50371216c98fc0a6))
+
+## [v2.6.3 (2023-06-07)](https://github.com/pestphp/pest/compare/v2.6.2...v2.6.3)
+
+### Chore
+- Bumps PHPUnit to `^10.2.1` ([73a859e](https://github.com/pestphp/pest/commit/73a859ee563fe96944ba39b191dceca28ef703c2))
+
+## [v2.6.2 (2023-06-02)](https://github.com/pestphp/pest/compare/v2.6.1...v2.6.2)
+
+### Chore
+- Bumps PHPUnit to `^10.2.0` ([a0041f1](https://github.com/pestphp/pest/commit/a0041f139cba94fe5d15318c38e275f2e2fb3350))
+
+## [v2.6.1 (2023-04-12)](https://github.com/pestphp/pest/compare/v2.6.0...v2.6.1)
+
+### Fixes
+- PHPStorm issue output problem for tests throwing an exception before the first assertion ([#809](https://github.com/pestphp/pest/pull/809))
+- Allow traits to be covered ([#804](https://github.com/pestphp/pest/pull/804))
+
+### Chore
+- Bumps PHPUnit to `^10.1.3` ([c993252](https://github.com/pestphp/pest/commit/c99325275acf1fd3759b487b93ec50473f706709))
+
+## [v2.6.0 (2023-04-05)](https://github.com/pestphp/pest/compare/v2.5.2...v2.6.0)
+
+### Adds
+- Allows `toThrow` to be used against an exception instance ([#797](https://github.com/pestphp/pest/pull/797))
+
+## [v2.5.2 (2023-04-19)](https://github.com/pestphp/pest/compare/v2.5.1...v2.5.2)
+
+### Chore
+- Removes `myclabs/php-enuma` dependency ([1a05df1](https://github.com/pestphp/pest/commit/1a05df14d0ce7d12583df26ff716807db6f81f13))
+
+## [v2.5.1 (2023-04-18)](https://github.com/pestphp/pest/compare/v2.5.0...v2.5.1)
+
+### Chore
+- Bumps PHPUnit to `^10.1.1` ([ec6a817](https://github.com/pestphp/pest/commit/ec6a81735af19f5463d24545df97535d77697ec6))
+
+## [v2.5.0 (2023-04-14)](https://github.com/pestphp/pest/compare/v2.4.0...v2.5.0)
+
+### Chore
+- Bumps PHPUnit to `^10.1.0` ([#780](https://github.com/pestphp/pest/pull/780))
+
+## [v2.4.0 (2023-04-03)](https://github.com/pestphp/pest/compare/v2.3.0...v2.4.0)
+
+### Added
+- `skipOnWindows()`, `skipOnMac()`, and `skipOnLinux()` ([#757](https://github.com/pestphp/pest/pull/757))
+- source architecture testing violation ([#1](https://github.com/pestphp/pest-plugin-arch/pull/1))([8e66263](https://github.com/pestphp/pest-plugin-arch/commit/8e66263104304e99e3d6ceda25c7ed679b27fb03))
+- `toHaveProperties` may now also check values ([#760](https://github.com/pestphp/pest/pull/760))
+
+### Fixed
+- Tests on `tests/Helpers` directory not being executed ([#753](https://github.com/pestphp/pest/pull/753))
+- Teamcity count ([#747](https://github.com/pestphp/pest/pull/747))
+- Parallel execution when class extends class with same name ([#748](https://github.com/pestphp/pest/pull/748))
+- Wording on `uses()` hint ([#745](https://github.com/pestphp/pest/pull/745/files))
+
+## [v2.3.0 (2023-03-28)](https://github.com/pestphp/pest/compare/v2.2.3...v2.3.0)
+
+### Added
+- Better error handler about missing uses ([#743](https://github.com/pestphp/pest/pull/743))
+
+### Fixed
+- Inconsistent spelling of `dataset` ([#739](https://github.com/pestphp/pest/pull/739))
+
+### Chore
+- Bumps PHPUnit to `^10.0.19` ([3d7e621](https://github.com/pestphp/pest/commit/3d7e621b7dfc03f0b2d9dcf6eb06c26bc383f502))
+
+## [v2.2.3 (2023-03-24)](https://github.com/pestphp/pest/compare/v2.2.2...v2.2.3)
+
+### Fixed
+- Unnecessary dataset on dataset arguments mismatch ([#736](https://github.com/pestphp/pest/pull/736))
+- Parallel arguments on plugins order ([#703](https://github.com/pestphp/pest/pull/703))
+- Arch plugin runtime exceptions on bad phpdocs ([2f2b51c](https://github.com/pestphp/pest/commit/2f2b51ce3d1b000be9d6add0e785fd0044931b3b))
+
+## [v2.2.2 (2023-03-23)](https://github.com/pestphp/pest/compare/v2.2.1...v2.2.2)
+
+### Fixed
+- Edge case in parallel execution test description ([3ce6408](https://github.com/pestphp/pest/commit/3ce640819541ca6022b250e000f336d87c3e7889))
+
+## [v2.2.1 (2023-03-22)](https://github.com/pestphp/pest/compare/v2.2.0...v2.2.1)
+
+### Fixed
+- Collision between tests names with underscores ([#724](https://github.com/pestphp/pest/pull/724))
+
+### Chore
+- Bumps PHPUnit to `^10.0.18` ([1408cff](https://github.com/pestphp/pest/commit/1408cffc028690057e44f00038f9390f776e6bfb))
+
+## [v2.2.0 (2023-03-22)](https://github.com/pestphp/pest/compare/v2.1.0...v2.2.0)
+
+### Added
+- Improved error messages on dataset arguments mismatch ([#698](https://github.com/pestphp/pest/pull/698))
+- Allows the usage of `DateTimeInterface` on multiple expectations ([#716](https://github.com/pestphp/pest/pull/716))
+
+### Fixed
+- `--dirty` option on Windows environments ([#721](https://github.com/pestphp/pest/pull/721))
+- Parallel exit code when `phpunit.xml` is outdated ([14dd5cb](https://github.com/pestphp/pest/commit/14dd5cb57b9432300ac4e8095f069941cb43bdb5))
+
+## [v2.1.0 (2023-03-21)](https://github.com/pestphp/pest/compare/v2.0.2...v2.1.0)
+
+### Added
+- `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.

CONTRIBUTING.md

@@ -31,6 +31,10 @@ composer lint
 ```
 ## Tests
 
+Update the snapshots:
+```bash
+composer update:snapshots
+```
 Run all tests:
 ```bash
 composer test
@@ -50,3 +54,22 @@ Integration tests:
 ```bash
 composer test:integration
 ```
+
+## Simplified setup using Docker
+
+If you have Docker installed, you can quickly get all dependencies for Pest in place using
+our Docker files. Assuming you have the repository cloned, you may run the following
+commands:
+
+1. `make build` to build the Docker image
+2. `make install` to install Composer dependencies
+3. `make test` to run the project tests and analysis tools
+
+If you want to check things work against a specific version of PHP, you may include
+the `PHP` build argument when building the image:
+
+```bash
+make build ARGS="--build-arg PHP=8.2"
+```
+
+The default PHP version will always be the lowest version of PHP supported by Pest.

Makefile

@@ -0,0 +1,14 @@
+# Well documented Makefiles
+DEFAULT_GOAL := help
+help:
+	@awk 'BEGIN {FS = ":.*##"; printf "\nUsage:\n  make \033[36m<target>\033[0m\n"} /^[a-zA-Z0-9_-]+:.*?##/ { printf "  \033[36m%-40s\033[0m %s\n", $$1, $$2 } /^##@/ { printf "\n\033[1m%s\033[0m\n", substr($$0, 5) } ' $(MAKEFILE_LIST)
+
+build: ## Build all docker images. Specify the command e.g. via make build ARGS="--build-arg PHP=8.2"
+	docker compose build $(ARGS)
+
+##@ [Application]
+install: ## Install the composer dependencies
+	docker compose run --rm composer install
+
+test: ## Run the tests
+	docker compose run --rm composer test

README.md

@@ -1,7 +1,7 @@
 <p align="center">
-    <img src="https://raw.githubusercontent.com/pestphp/art/master/readme.png" width="600" alt="PEST">
+    <img src="https://raw.githubusercontent.com/pestphp/art/master/v2/banner.png" width="600" alt="PEST">
     <p align="center">
-        <a href="https://github.com/pestphp/pest/actions"><img alt="GitHub Workflow Status (master)" src="https://img.shields.io/github/workflow/status/pestphp/pest/Continuous Integration/master"></a>
+        <a href="https://github.com/pestphp/pest/actions"><img alt="GitHub Workflow Status (master)" src="https://img.shields.io/github/actions/workflow/status/pestphp/pest/tests.yml?branch=2.x&label=Tests%202.x"></a>
         <a href="https://packagist.org/packages/pestphp/pest"><img alt="Total Downloads" src="https://img.shields.io/packagist/dt/pestphp/pest"></a>
         <a href="https://packagist.org/packages/pestphp/pest"><img alt="Latest Version" src="https://img.shields.io/packagist/v/pestphp/pest"></a>
         <a href="https://packagist.org/packages/pestphp/pest"><img alt="License" src="https://img.shields.io/packagist/l/pestphp/pest"></a>
@@ -9,10 +9,31 @@
 </p>
 
 ------
-**Pest** is an elegant PHP Testing Framework with a focus on simplicity. It was carefully crafted to bring the joy of testing to PHP.
+**Pest** is an elegant PHP testing Framework with a focus on simplicity, meticulously designed to bring back the joy of testing in PHP.
 
-- Explore the docs: **[pestphp.com »](https://pestphp.com)**
-- Follow us on Twitter: **[@pestphp »](https://twitter.com/pestphp)**
-- Join us on the Discord Server: **[discord.gg/bMAJv82 »](https://discord.gg/bMAJv82)**
+- Explore our docs at **[pestphp.com »](https://pestphp.com)**
+- Follow us on Twitter at **[@pestphp »](https://twitter.com/pestphp)**
+- Join us at **[discord.gg/kaHY6p54JH »](https://discord.gg/kaHY6p54JH)** or **[t.me/+kYH5G4d5MV83ODk0 »](https://t.me/+kYH5G4d5MV83ODk0)**
 
-Pest was created by **[Nuno Maduro](https://twitter.com/enunomaduro)** under the **[Sponsorware license](https://github.com/sponsorware/docs)**. It got open-sourced and is now licensed under the **[MIT license](https://opensource.org/licenses/MIT)**.
+## Sponsors
+
+We cannot thank our sponsors enough for their incredible support in funding Pest's development. Their contributions have been instrumental in making Pest the best it can be. For those who are interested in becoming a sponsor, please visit Nuno Maduro's Sponsor page at **[github.com/sponsors/nunomaduro](https://github.com/sponsors/nunomaduro)**.
+
+### 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/)
+- [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

@@ -0,0 +1,19 @@
+# Release process
+
+When releasing a new version of Pest there are some checks and updates that need to be done:
+
+> **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
+- 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"`
+- 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`
+- Publish release here: [github.com/pestphp/pest/releases/new](https://github.com/pestphp/pest/releases/new).
+
+### Plugins
+
+Plugins should be versioned using the same major (or minor for `0.x` releases) version as Pest core.

bin/pest

@@ -1,31 +1,99 @@
 #!/usr/bin/env php
 <?php declare(strict_types=1);
 
-use Pest\Actions\ValidatesEnvironment;
-use Pest\Console\Command;
+use Pest\Kernel;
+use Pest\Panic;
+use Pest\TestCaseFilters\GitDirtyTestCaseFilter;
+use Pest\TestCaseMethodFilters\TodoTestCaseFilter;
 use Pest\TestSuite;
+use Symfony\Component\Console\Input\ArgvInput;
 use Symfony\Component\Console\Output\ConsoleOutput;
 
 (static function () {
-    // Used when Pest is required using composer.
-    $vendorPath = realpath(__DIR__ . '/../../../../vendor/autoload.php');
+    // Ensures Collision's Printer is registered.
+    $_SERVER['COLLISION_PRINTER'] = 'DefaultPrinter';
 
-    // Used when Pest maintainers are running Pest tests.
-    $localPath = realpath(__DIR__ . '/../vendor/autoload.php');
+    $args = $_SERVER['argv'];
 
-    if ($vendorPath) {
-        include_once $vendorPath;
-    } else {
-        include_once $localPath;
+    $dirty = false;
+    $todo = false;
+
+    foreach ($args as $key => $value) {
+        if ($value === '--compact') {
+            $_SERVER['COLLISION_PRINTER_COMPACT'] = 'true';
+            unset($args[$key]);
         }
 
-    (new \NunoMaduro\Collision\Provider)->register();
+        if ($value === '--profile') {
+            $_SERVER['COLLISION_PRINTER_PROFILE'] = 'true';
+            unset($args[$key]);
+        }
 
-    $rootPath = getcwd();
+        if (str_contains($value, '--test-directory')) {
+            unset($args[$key]);
+        }
 
-    $testSuite = TestSuite::getInstance($rootPath);
+        if ($value === '--dirty') {
+            $dirty = true;
+            unset($args[$key]);
+        }
 
-    ValidatesEnvironment::in($testSuite);
+        if ($value === '--todos') {
+            $todo = true;
+            unset($args[$key]);
+        }
 
-    exit((new Command($testSuite, new ConsoleOutput(ConsoleOutput::VERBOSITY_NORMAL, true)))->run($_SERVER['argv']));
+        if (str_contains($value, '--teamcity')) {
+            unset($args[$key]);
+            $args[] = '--no-output';
+            unset($_SERVER['COLLISION_PRINTER']);
+        }
+    }
+
+    // Used when Pest is required using composer.
+    $vendorPath = dirname(__DIR__, 4).'/vendor/autoload.php';
+
+    // Used when Pest maintainers are running Pest tests.
+    $localPath = dirname(__DIR__).'/vendor/autoload.php';
+
+    if (file_exists($vendorPath)) {
+        include_once $vendorPath;
+        $autoloadPath = $vendorPath;
+    } else {
+        include_once $localPath;
+        $autoloadPath = $localPath;
+    }
+
+    // Get $rootPath based on $autoloadPath
+    $rootPath = dirname($autoloadPath, 2);
+    $input = new ArgvInput();
+
+    $testSuite = TestSuite::getInstance(
+        $rootPath,
+        $input->getParameterOption('--test-directory', 'tests'),
+    );
+
+    if ($dirty) {
+        $testSuite->tests->addTestCaseFilter(new GitDirtyTestCaseFilter($rootPath));
+    }
+
+    if ($todo) {
+        $testSuite->tests->addTestCaseMethodFilter(new TodoTestCaseFilter());
+    }
+
+    $isDecorated = $input->getParameterOption('--colors', 'always') !== 'never';
+
+    $output = new ConsoleOutput(ConsoleOutput::VERBOSITY_NORMAL, $isDecorated);
+
+    try {
+        $kernel = Kernel::boot($testSuite, $input, $output);
+
+        $result = $kernel->handle($args);
+
+        $kernel->shutdown();
+    } catch (Throwable|Error $e) {
+        Panic::with($e);
+    }
+
+    exit($result);
 })();

bin/worker.php

@@ -0,0 +1,104 @@
+<?php
+
+declare(strict_types=1);
+
+use ParaTest\WrapperRunner\ApplicationForWrapperWorker;
+use ParaTest\WrapperRunner\WrapperWorker;
+use Pest\Kernel;
+use Pest\Plugins\Actions\CallsHandleArguments;
+use Pest\TestSuite;
+use Symfony\Component\Console\Input\ArgvInput;
+use Symfony\Component\Console\Output\ConsoleOutput;
+use Symfony\Component\Console\Output\OutputInterface;
+
+$bootPest = (static function (): void {
+    $workerArgv = new ArgvInput();
+
+    $rootPath = dirname(PHPUNIT_COMPOSER_INSTALL, 2);
+    $testSuite = TestSuite::getInstance($rootPath, $workerArgv->getParameterOption(
+        '--test-directory',
+        'tests'
+    ));
+
+    $input = new ArgvInput();
+
+    $output = new ConsoleOutput(OutputInterface::VERBOSITY_NORMAL, true);
+
+    Kernel::boot($testSuite, $input, $output);
+});
+
+(static function () use ($bootPest): void {
+    $getopt = getopt('', [
+        'status-file:',
+        'progress-file:',
+        'unexpected-output-file:',
+        'testresult-file:',
+        'teamcity-file:',
+        'testdox-file:',
+        'testdox-color',
+        'phpunit-argv:',
+    ]);
+
+    $composerAutoloadFiles = [
+        dirname(__DIR__, 3).DIRECTORY_SEPARATOR.'autoload.php',
+        dirname(__DIR__, 2).DIRECTORY_SEPARATOR.'vendor'.DIRECTORY_SEPARATOR.'autoload.php',
+        dirname(__DIR__).DIRECTORY_SEPARATOR.'vendor'.DIRECTORY_SEPARATOR.'autoload.php',
+    ];
+
+    foreach ($composerAutoloadFiles as $file) {
+
+        if (file_exists($file)) {
+            require_once $file;
+            define('PHPUNIT_COMPOSER_INSTALL', $file);
+
+            break;
+        }
+    }
+
+    assert(isset($getopt['status-file']) && is_string($getopt['status-file']));
+    $statusFile = fopen($getopt['status-file'], 'wb');
+    assert(is_resource($statusFile));
+
+    assert(isset($getopt['progress-file']) && is_string($getopt['progress-file']));
+    assert(isset($getopt['unexpected-output-file']) && is_string($getopt['unexpected-output-file']));
+    assert(isset($getopt['testresult-file']) && is_string($getopt['testresult-file']));
+    assert(! isset($getopt['teamcity-file']) || is_string($getopt['teamcity-file']));
+    assert(! isset($getopt['testdox-file']) || is_string($getopt['testdox-file']));
+
+    assert(isset($getopt['phpunit-argv']) && is_string($getopt['phpunit-argv']));
+    $phpunitArgv = unserialize($getopt['phpunit-argv'], ['allowed_classes' => false]);
+    assert(is_array($phpunitArgv));
+
+    $bootPest();
+
+    $phpunitArgv = CallsHandleArguments::execute($phpunitArgv);
+
+    $application = new ApplicationForWrapperWorker(
+        $phpunitArgv,
+        $getopt['progress-file'],
+        $getopt['unexpected-output-file'],
+        $getopt['testresult-file'],
+        $getopt['teamcity-file'] ?? null,
+        $getopt['testdox-file'] ?? null,
+        isset($getopt['testdox-color']),
+    );
+
+    while (true) {
+        if (feof(STDIN)) {
+            $application->end();
+            exit;
+        }
+
+        $testPath = fgets(STDIN);
+        if ($testPath === false || $testPath === WrapperWorker::COMMAND_EXIT) {
+            $application->end();
+            exit;
+        }
+
+        // It must be a 1 byte string to ensure filesize() is equal to the number of tests executed
+        $exitCode = $application->runTest(realpath(trim($testPath)));
+
+        fwrite($statusFile, (string) $exitCode);
+        fflush($statusFile);
+    }
+})();

composer.json

@@ -1,6 +1,6 @@
 {
     "name": "pestphp/pest",
-    "description": "An elegant PHP Testing Framework.",
+    "description": "The elegant PHP Testing Framework.",
     "keywords": [
         "php",
         "framework",
@@ -17,22 +17,32 @@
         }
     ],
     "require": {
-        "php": "^7.3",
-        "nunomaduro/collision": "^5.0",
-        "phpunit/phpunit": "^9.1.4",
-        "sebastian/environment": "^5.1"
+        "php": "^8.1.0",
+        "brianium/paratest": "^7.2.6",
+        "nunomaduro/collision": "^7.8.1",
+        "nunomaduro/termwind": "^1.15.1",
+        "pestphp/pest-plugin": "^2.1.1",
+        "pestphp/pest-plugin-arch": "^2.3.3",
+        "phpunit/phpunit": "^10.3.3"
+    },
+    "conflict": {
+        "webmozart/assert": "<1.11.0",
+        "phpunit/phpunit": ">10.3.3"
     },
     "autoload": {
         "psr-4": {
             "Pest\\": "src/"
         },
         "files": [
-            "src/globals.php",
-            "compiled/globals.php"
+            "src/Functions.php",
+            "src/Pest.php"
         ]
     },
     "autoload-dev": {
         "psr-4": {
+            "Tests\\Fixtures\\Covers\\": "tests/Fixtures/Covers",
+            "Tests\\Fixtures\\Inheritance\\": "tests/Fixtures/Inheritance",
+            "Tests\\Fixtures\\Arch\\": "tests/Fixtures/Arch",
             "Tests\\": "tests/PHPUnit/"
         },
         "files": [
@@ -40,45 +50,63 @@
         ]
     },
     "require-dev": {
-        "ergebnis/phpstan-rules": "^0.14.4",
-        "friendsofphp/php-cs-fixer": "^2.16.3",
-        "illuminate/console": "^7.10.3",
-        "illuminate/support": "^7.10.3",
-        "mockery/mockery": "^1.3.1",
-        "phpstan/phpstan": "^0.12.25",
-        "phpstan/phpstan-strict-rules": "^0.12.2",
-        "rector/rector": "^0.7.25",
-        "symfony/var-dumper": "^5.0.8",
-        "thecodingmachine/phpstan-strict-rules": "^0.12.0"
+        "pestphp/pest-dev-tools": "^2.16.0",
+        "pestphp/pest-plugin-type-coverage": "^2.2.0",
+        "symfony/process": "^6.3.4"
     },
     "minimum-stability": "dev",
     "prefer-stable": true,
     "config": {
         "sort-packages": true,
-        "preferred-install": "dist"
+        "preferred-install": "dist",
+        "allow-plugins": {
+            "pestphp/pest-plugin": true
+        }
     },
     "bin": [
         "bin/pest"
     ],
     "scripts": {
-        "compile": "@php ./scripts/compile.php",
-        "lint": "rector process src && php-cs-fixer fix -v",
-        "test:lint": "php-cs-fixer fix -v --dry-run && rector process src --dry-run",
-        "test:types": "phpstan analyse --ansi",
-        "test:unit": "bin/pest --colors=always --exclude-group=integration",
-        "test:integration": "bin/pest --colors=always --group=integration",
-        "test:integration:snapshots": "REBUILD_SNAPSHOTS=true bin/pest --colors=always",
+        "refacto": "rector",
+        "lint": "pint",
+        "test:refacto": "rector --dry-run",
+        "test:lint": "pint --test",
+        "test:type:check": "phpstan analyse --ansi --memory-limit=-1 --debug",
+        "test:type:coverage": "php bin/pest --type-coverage --min=100",
+        "test:unit": "php bin/pest --colors=always --exclude-group=integration --compact",
+        "test:inline": "php bin/pest --colors=always --configuration=phpunit.inline.xml",
+        "test:parallel": "php bin/pest --colors=always --exclude-group=integration --parallel --processes=10",
+        "test:integration": "php bin/pest --colors=always --group=integration",
+        "update:snapshots": "REBUILD_SNAPSHOTS=true php bin/pest --colors=always --update-snapshots",
         "test": [
+            "@test:refacto",
             "@test:lint",
-            "@test:types",
+            "@test:type:check",
+            "@test:type:coverage",
             "@test:unit",
+            "@test:parallel",
             "@test:integration"
         ]
     },
     "extra": {
-        "laravel": {
-            "providers": [
-                "Pest\\Laravel\\PestServiceProvider"
+        "pest": {
+            "plugins": [
+                "Pest\\Plugins\\Bail",
+                "Pest\\Plugins\\Cache",
+                "Pest\\Plugins\\Coverage",
+                "Pest\\Plugins\\Init",
+                "Pest\\Plugins\\Environment",
+                "Pest\\Plugins\\Help",
+                "Pest\\Plugins\\Memory",
+                "Pest\\Plugins\\Only",
+                "Pest\\Plugins\\Printer",
+                "Pest\\Plugins\\ProcessIsolation",
+                "Pest\\Plugins\\Profile",
+                "Pest\\Plugins\\Retry",
+                "Pest\\Plugins\\Snapshot",
+                "Pest\\Plugins\\Verbose",
+                "Pest\\Plugins\\Version",
+                "Pest\\Plugins\\Parallel"
             ]
         }
     }

docker-compose.yml

@@ -0,0 +1,14 @@
+version: "3.8"
+
+services:
+  php:
+    build:
+      context: ./docker
+    volumes:
+      - .:/var/www/html
+  composer:
+    build:
+      context: ./docker
+    volumes:
+      - .:/var/www/html
+    entrypoint: ["composer"]

docker/Dockerfile

@@ -0,0 +1,23 @@
+ARG PHP=8.1
+FROM php:${PHP}-cli-alpine
+
+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 intl
+RUN docker-php-ext-install intl
+RUN docker-php-ext-enable intl
+
+RUN apk add --no-cache $PHPIZE_DEPS 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
+
+ENTRYPOINT ["php"]

overrides/Event/Value/ThrowableBuilder.php

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

overrides/Runner/Filter/NameFilterIterator.php

@@ -0,0 +1,172 @@
+<?php
+
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2001-2023, Sebastian Bergmann
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+namespace PHPUnit\Runner\Filter;
+
+use Exception;
+use Pest\Contracts\HasPrintableTestCaseName;
+use PHPUnit\Framework\SelfDescribing;
+use PHPUnit\Framework\Test;
+use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\TestSuite;
+use RecursiveFilterIterator;
+use RecursiveIterator;
+
+use function end;
+use function implode;
+use function preg_match;
+use function sprintf;
+use function str_replace;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class NameFilterIterator extends RecursiveFilterIterator
+{
+    private ?string $filter = null;
+
+    private ?int $filterMin = null;
+
+    private ?int $filterMax = null;
+
+    /**
+     * @throws Exception
+     */
+    public function __construct(RecursiveIterator $iterator, string $filter)
+    {
+        parent::__construct($iterator);
+
+        $this->setFilter($filter);
+    }
+
+    public function accept(): bool
+    {
+        $test = $this->getInnerIterator()->current();
+
+        if ($test instanceof TestSuite) {
+            return true;
+        }
+
+        $tmp = $this->describe($test);
+
+        if ($tmp[0] !== '') {
+            $name = implode('::', $tmp);
+        } else {
+            $name = $tmp[1];
+        }
+
+        $accepted = @preg_match($this->filter, $name, $matches);
+
+        if ($accepted && isset($this->filterMax)) {
+            $set = end($matches);
+            $accepted = $set >= $this->filterMin && $set <= $this->filterMax;
+        }
+
+        return (bool) $accepted;
+    }
+
+    /**
+     * @throws Exception
+     */
+    private function setFilter(string $filter): void
+    {
+        if (@preg_match($filter, '') === false) {
+            // Handles:
+            //  * testAssertEqualsSucceeds#4
+            //  * testAssertEqualsSucceeds#4-8
+            if (preg_match('/^(.*?)#(\d+)(?:-(\d+))?$/', $filter, $matches)) {
+                if (isset($matches[3]) && $matches[2] < $matches[3]) {
+                    $filter = sprintf(
+                        '%s.*with dataset #(\d+)$',
+                        $matches[1]
+                    );
+
+                    $this->filterMin = (int) $matches[2];
+                    $this->filterMax = (int) $matches[3];
+                } else {
+                    $filter = sprintf(
+                        '%s.*with dataset #%s$',
+                        $matches[1],
+                        $matches[2]
+                    );
+                }
+            } // Handles:
+            //  * testDetermineJsonError@JSON_ERROR_NONE
+            //  * testDetermineJsonError@JSON.*
+            elseif (preg_match('/^(.*?)@(.+)$/', $filter, $matches)) {
+                $filter = sprintf(
+                    '%s.*with dataset "%s"$',
+                    $matches[1],
+                    $matches[2]
+                );
+            }
+
+            // Escape delimiters in regular expression. Do NOT use preg_quote,
+            // to keep magic characters.
+            $filter = sprintf(
+                '/%s/i',
+                str_replace(
+                    '/',
+                    '\\/',
+                    $filter
+                )
+            );
+        }
+
+        $this->filter = $filter;
+    }
+
+    /**
+     * @psalm-return array{0: string, 1: string}
+     */
+    private function describe(Test $test): array
+    {
+        if ($test instanceof HasPrintableTestCaseName) {
+            return [
+                $test::getPrintableTestCaseName(),
+                $test->getPrintableTestCaseMethodName(),
+            ];
+        }
+
+        if ($test instanceof TestCase) {
+            return [$test::class, $test->nameWithDataSet()];
+        }
+
+        if ($test instanceof SelfDescribing) {
+            return ['', $test->toString()];
+        }
+
+        return ['', $test::class];
+    }
+}

overrides/Runner/ResultCache/DefaultResultCache.php

@@ -0,0 +1,197 @@
+<?php
+
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2001-2023, Sebastian Bergmann
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PHPUnit\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 function dirname;
+use function file_get_contents;
+use function file_put_contents;
+use function is_array;
+use function is_dir;
+use function is_file;
+use function json_decode;
+use function json_encode;
+use function Pest\version;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class DefaultResultCache implements ResultCache
+{
+    /**
+     * @var string
+     */
+    private const DEFAULT_RESULT_CACHE_FILENAME = '.phpunit.result.cache';
+
+    private readonly string $cacheFilename;
+
+    /**
+     * @psalm-var array<string, TestStatus>
+     */
+    private array $defects = [];
+
+    /**
+     * @psalm-var array<string, TestStatus>
+     */
+    private array $currentDefects = [];
+
+    /**
+     * @psalm-var array<string, float>
+     */
+    private array $times = [];
+
+    public function __construct(string $filepath = null)
+    {
+        if ($filepath !== null && is_dir($filepath)) {
+            $filepath .= DIRECTORY_SEPARATOR.self::DEFAULT_RESULT_CACHE_FILENAME;
+        }
+
+        $this->cacheFilename = $filepath ?? $_ENV['PHPUNIT_RESULT_CACHE'] ?? self::DEFAULT_RESULT_CACHE_FILENAME;
+    }
+
+    public function setStatus(string $id, TestStatus $status): void
+    {
+        if ($status->isFailure() || $status->isError()) {
+            $this->currentDefects[$id] = $status;
+            $this->defects[$id] = $status;
+        }
+    }
+
+    public function status(string $id): TestStatus
+    {
+        return $this->defects[$id] ?? TestStatus::unknown();
+    }
+
+    public function setTime(string $id, float $time): void
+    {
+        if (! isset($this->currentDefects[$id])) {
+            unset($this->defects[$id]);
+        }
+
+        $this->times[$id] = $time;
+    }
+
+    public function time(string $id): float
+    {
+        return $this->times[$id] ?? 0.0;
+    }
+
+    public function load(): void
+    {
+        if (! is_file($this->cacheFilename)) {
+            return;
+        }
+
+        $data = json_decode(
+            file_get_contents($this->cacheFilename),
+            true
+        );
+
+        if ($data === null) {
+            return;
+        }
+
+        if (! isset($data['version'])) {
+            return;
+        }
+
+        if ($data['version'] !== $this->cacheVersion()) {
+            return;
+        }
+
+        assert(isset($data['defects']) && is_array($data['defects']));
+        assert(isset($data['times']) && is_array($data['times']));
+
+        foreach (array_keys($data['defects']) as $test) {
+            $data['defects'][$test] = TestStatus::from($data['defects'][$test]);
+        }
+
+        $this->defects = $data['defects'];
+        $this->times = $data['times'];
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function persist(): void
+    {
+        if (! Filesystem::createDirectory(dirname($this->cacheFilename))) {
+            throw new DirectoryCannotBeCreatedException($this->cacheFilename);
+        }
+
+        $data = [
+            'version' => $this->cacheVersion(),
+            'defects' => [],
+            'times' => $this->times,
+        ];
+
+        foreach ($this->defects as $test => $status) {
+            $data['defects'][$test] = $status->asInt();
+        }
+
+        file_put_contents(
+            $this->cacheFilename,
+            json_encode($data),
+            LOCK_EX
+        );
+    }
+
+    /**
+     * Returns the cache version.
+     */
+    private function cacheVersion(): string
+    {
+        return 'pest_'.version();
+    }
+}

overrides/Runner/TestSuiteLoader.php

@@ -0,0 +1,221 @@
+<?php
+
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2001-2023, Sebastian Bergmann
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+declare(strict_types=1);
+
+namespace PHPUnit\Runner;
+
+use Exception;
+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;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class TestSuiteLoader
+{
+    /**
+     * @psalm-var list<class-string>
+     */
+    private static array $loadedClasses = [];
+
+    /**
+     * @psalm-var array<string, array<class-string>>
+     */
+    private static array $loadedClassesByFilename = [];
+
+    /**
+     * @psalm-var list<class-string>
+     */
+    private static array $declaredClasses = [];
+
+    public function __construct()
+    {
+        if (empty(self::$declaredClasses)) {
+            self::$declaredClasses = get_declared_classes();
+        }
+    }
+
+    /**
+     * @throws Exception
+     */
+    public function load(string $suiteClassFile): ReflectionClass
+    {
+        $suiteClassName = $this->classNameFromFileName($suiteClassFile);
+
+        (static function () use ($suiteClassFile) {
+            include_once $suiteClassFile;
+
+            TestSuite::getInstance()->tests->makeIfNeeded($suiteClassFile);
+        })();
+
+        $loadedClasses = array_values(
+            array_diff(
+                get_declared_classes(),
+                array_merge(
+                    self::$declaredClasses,
+                    self::$loadedClasses
+                )
+            )
+        );
+
+        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);
+        }
+
+        $testCaseFound = false;
+        $class = false;
+
+        foreach (array_reverse($loadedClasses) as $loadedClass) {
+            if (
+                is_subclass_of($loadedClass, HasPrintableTestCaseName::class)
+                || is_subclass_of($loadedClass, TestCase::class)) {
+                try {
+                    $class = new ReflectionClass($loadedClass);
+                    // @codeCoverageIgnoreStart
+                } catch (ReflectionException) {
+                    continue;
+                }
+
+                if ($class->isAbstract() || ($suiteClassFile !== $class->getFileName())) {
+                    if (! str_contains($class->getFileName(), 'TestCaseFactory.php')) {
+                        continue;
+                    }
+                }
+
+                $suiteClassName = $loadedClass;
+                $testCaseFound = true;
+
+                break;
+            }
+        }
+
+        if (! $testCaseFound) {
+            foreach (array_reverse($loadedClasses) as $loadedClass) {
+                $offset = 0 - strlen($suiteClassName);
+
+                if (stripos(substr($loadedClass, $offset - 1), '\\'.$suiteClassName) === 0 ||
+                    stripos(substr($loadedClass, $offset - 1), '_'.$suiteClassName) === 0) {
+                    try {
+                        $class = new ReflectionClass($loadedClass);
+                        // @codeCoverageIgnoreStart
+                    } catch (ReflectionException) {
+                        continue;
+                    }
+
+                    $suiteClassName = $loadedClass;
+                    $testCaseFound = true;
+
+                    break;
+                }
+            }
+        }
+
+        if (! $testCaseFound) {
+            return $this->exceptionFor($suiteClassName, $suiteClassFile);
+        }
+
+        if (! class_exists($suiteClassName, false)) {
+            return $this->exceptionFor($suiteClassName, $suiteClassFile);
+        }
+
+        // @codeCoverageIgnoreEnd
+
+        if ($class->isSubclassOf(TestCase::class) && ! $class->isAbstract()) {
+            return $class;
+        }
+
+        if ($class->hasMethod('suite')) {
+            try {
+                $method = $class->getMethod('suite');
+                // @codeCoverageIgnoreStart
+            } catch (ReflectionException $e) {
+                throw new Exception($e->getMessage(), (int) $e->getCode(), $e);
+            }
+            // @codeCoverageIgnoreEnd
+
+            if (! $method->isAbstract() && $method->isPublic() && $method->isStatic()) {
+                return $class;
+            }
+        }
+
+        return $this->exceptionFor($suiteClassName, $suiteClassFile);
+    }
+
+    public function reload(ReflectionClass $aClass): ReflectionClass
+    {
+        return $aClass;
+    }
+
+    private function classNameFromFileName(string $suiteClassFile): string
+    {
+        $className = basename($suiteClassFile, '.php');
+        $dotPos = strpos($className, '.');
+
+        if ($dotPos !== false) {
+            $className = substr($className, 0, $dotPos);
+        }
+
+        return $className;
+    }
+
+    private function exceptionFor(string $className, string $filename): ReflectionClass
+    {
+        return new ReflectionClass(IgnorableTestCase::class);
+    }
+}

overrides/TextUI/Command/WarmCodeCoverageCacheCommand.php

@@ -0,0 +1,104 @@
+<?php
+
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2001-2023, Sebastian Bergmann
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PHPUnit\TextUI\Command;
+
+use PHPUnit\TextUI\Configuration\CodeCoverageFilterRegistry;
+use PHPUnit\TextUI\Configuration\Configuration;
+use PHPUnit\TextUI\Configuration\NoCoverageCacheDirectoryException;
+use SebastianBergmann\CodeCoverage\StaticAnalysis\CacheWarmer;
+use SebastianBergmann\Timer\NoActiveTimerException;
+use SebastianBergmann\Timer\Timer;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class WarmCodeCoverageCacheCommand implements Command
+{
+    private readonly Configuration $configuration;
+
+    private readonly CodeCoverageFilterRegistry $codeCoverageFilterRegistry;
+
+    public function __construct(Configuration $configuration, CodeCoverageFilterRegistry $codeCoverageFilterRegistry)
+    {
+        $this->configuration = $configuration;
+        $this->codeCoverageFilterRegistry = $codeCoverageFilterRegistry;
+    }
+
+    /**
+     * @throws NoActiveTimerException
+     * @throws NoCoverageCacheDirectoryException
+     */
+    public function execute(): Result
+    {
+        if (! $this->configuration->hasCoverageCacheDirectory()) {
+            return Result::from(
+                'Cache for static analysis has not been configured'.PHP_EOL,
+                Result::FAILURE
+            );
+        }
+
+        $this->codeCoverageFilterRegistry->init($this->configuration);
+
+        if (! $this->codeCoverageFilterRegistry->configured()) {
+            return Result::from(
+                'Filter for code coverage has not been configured'.PHP_EOL,
+                Result::FAILURE
+            );
+        }
+
+        $timer = new Timer;
+        $timer->start();
+
+        (new CacheWarmer)->warmCache(
+            $this->configuration->coverageCacheDirectory(),
+            ! $this->configuration->disableCodeCoverageIgnore(),
+            $this->configuration->ignoreDeprecatedCodeUnitsFromCodeCoverage(),
+            $this->codeCoverageFilterRegistry->get()
+        );
+
+        return Result::from();
+    }
+}

overrides/TextUI/Output/Default/ProgressPrinter/TestSkippedSubscriber.php

@@ -0,0 +1,80 @@
+<?php
+
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2001-2023, Sebastian Bergmann
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PHPUnit\TextUI\Output\Default\ProgressPrinter;
+
+use PHPUnit\Event\Test\Skipped;
+use PHPUnit\Event\Test\SkippedSubscriber;
+use ReflectionClass;
+
+/**
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ *
+ * This file is overridden to allow Pest Parallel to show todo items in the progress output.
+ */
+final class TestSkippedSubscriber extends Subscriber implements SkippedSubscriber
+{
+    /**
+     * Notifies the printer that a test was skipped.
+     */
+    public function notify(Skipped $event): void
+    {
+        if (str_contains($event->message(), '__TODO__')) {
+            $this->printTodoItem();
+        }
+
+        $this->printer()->testSkipped();
+    }
+
+    /**
+     * Prints a "T" to the standard PHPUnit output to indicate a todo item.
+     */
+    private function printTodoItem(): void
+    {
+        $mirror = new ReflectionClass($this->printer());
+        $printerMirror = $mirror->getMethod('printProgress');
+        $printerMirror->invoke($this->printer(), 'T');
+    }
+}

overrides/TextUI/TestSuiteFilterProcessor.php

@@ -0,0 +1,129 @@
+<?php
+
+/*
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2001-2023, Sebastian Bergmann
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+declare(strict_types=1);
+
+/*
+ * This file is part of PHPUnit.
+ *
+ * (c) Sebastian Bergmann <sebastian@phpunit.de>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PHPUnit\TextUI;
+
+use Pest\Plugins\Only;
+use PHPUnit\Event;
+use PHPUnit\Framework\TestSuite;
+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
+ */
+final class TestSuiteFilterProcessor
+{
+    private Factory $filterFactory;
+
+    public function __construct(Factory $factory = new Factory)
+    {
+        $this->filterFactory = $factory;
+    }
+
+    /**
+     * @throws Event\RuntimeException
+     * @throws FilterNotConfiguredException
+     */
+    public function process(Configuration $configuration, TestSuite $suite): void
+    {
+        if (! $configuration->hasFilter() &&
+            ! $configuration->hasGroups() &&
+            ! $configuration->hasExcludeGroups() &&
+            ! $configuration->hasTestsCovering() &&
+            ! $configuration->hasTestsUsing() &&
+            ! Only::isEnabled()
+        ) {
+            return;
+        }
+
+        if ($configuration->hasExcludeGroups()) {
+            $this->filterFactory->addExcludeGroupFilter(
+                $configuration->excludeGroups()
+            );
+        }
+
+        if (Only::isEnabled()) {
+            $this->filterFactory->addIncludeGroupFilter(['__pest_only']);
+        } elseif ($configuration->hasGroups()) {
+            $this->filterFactory->addIncludeGroupFilter(
+                $configuration->groups()
+            );
+        }
+
+        if ($configuration->hasTestsCovering()) {
+            $this->filterFactory->addIncludeGroupFilter(
+                array_map(
+                    static fn (string $name): string => '__phpunit_covers_'.$name,
+                    $configuration->testsCovering()
+                )
+            );
+        }
+
+        if ($configuration->hasTestsUsing()) {
+            $this->filterFactory->addIncludeGroupFilter(
+                array_map(
+                    static fn (string $name): string => '__phpunit_uses_'.$name,
+                    $configuration->testsUsing()
+                )
+            );
+        }
+
+        if ($configuration->hasFilter()) {
+            $this->filterFactory->addNameFilter(
+                $configuration->filter()
+            );
+        }
+
+        $suite->injectFilter($this->filterFactory);
+
+        Event\Facade::emitter()->testSuiteFiltered(
+            Event\TestSuite\TestSuiteBuilder::from($suite)
+        );
+    }
+}

phpstan.neon

@@ -7,16 +7,17 @@ parameters:
     level: max
     paths:
         - src
-    excludes_analyse:
-        - src/globals.php
 
     checkMissingIterableValueType: true
-    checkGenericClassInNonGenericObjectType: false
     reportUnmatchedIgnoredErrors: true
 
     ignoreErrors:
+        - "#has a nullable return type declaration.#"
+        - "#Language construct isset\\(\\) should not be used.#"
         - "#is not allowed to extend#"
-        - "#Language construct eval#"
+        - "#is concrete, but does not have a Test suffix#"
+        - "#with a nullable type declaration#"
+        - "#type mixed is not subtype of native#"
         - "# with null as default value#"
-        - "#Using \\$this in static method#"
         - "#has parameter \\$closure with default value.#"
+        - "#has parameter \\$description with default value.#"

phpunit.xml

@@ -1,16 +1,29 @@
 <?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.0/phpunit.xsd"
+         backupGlobals="false"
+         beStrictAboutTestsThatDoNotTestAnything="true"
+         beStrictAboutOutputDuringTests="true"
+         bootstrap="vendor/autoload.php"
          colors="true"
+         failOnRisky="true"
+         failOnWarning="false"
+         processIsolation="false"
+         stopOnError="false"
+         stopOnFailure="false"
+         backupStaticProperties="false"
 >
   <testsuites>
     <testsuite name="default">
       <directory suffix=".php">./tests</directory>
+      <exclude>./tests/.snapshots</exclude>
+      <exclude>./tests/.tests</exclude>
+      <exclude>./tests/Fixtures/Inheritance</exclude>
     </testsuite>
   </testsuites>
-    <filter>
-        <whitelist processUncoveredFilesFromWhitelist="true">
+  <source>
+    <include>
       <directory suffix=".php">./src</directory>
-        </whitelist>
-    </filter>
+    </include>
+  </source>
 </phpunit>

rector.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\CodeQuality\Rector\Class_\InlineConstructorDefaultToPropertyRector;
+use Rector\Config\RectorConfig;
+use Rector\Set\ValueObject\LevelSetList;
+use Rector\Set\ValueObject\SetList;
+
+return static function (RectorConfig $rectorConfig): void {
+    $rectorConfig->paths([
+        __DIR__.'/src',
+    ]);
+
+    $rectorConfig->rules([
+        InlineConstructorDefaultToPropertyRector::class,
+    ]);
+
+    $rectorConfig->skip([
+        __DIR__.'/src/Plugins/Parallel/Paratest/WrapperRunner.php',
+    ]);
+
+    $rectorConfig->sets([
+        LevelSetList::UP_TO_PHP_81,
+        SetList::CODE_QUALITY,
+        SetList::DEAD_CODE,
+        SetList::EARLY_RETURN,
+        SetList::TYPE_DECLARATION,
+        SetList::PRIVATIZATION,
+    ]);
+};

rector.yaml

@@ -1,16 +0,0 @@
-# rector.yaml
-parameters:
-    sets:
-        - 'action-injection-to-constructor-injection'
-        - 'array-str-functions-to-static-call'
-        - 'celebrity'
-        - 'doctrine'
-        - 'phpstan'
-        - 'phpunit-code-quality'
-        - 'solid'
-        - 'early-return'
-        - 'doctrine-code-quality'
-        - 'code-quality'
-        - 'php71'
-        - 'php72'
-        - 'php73'

resources/views/components/badge.php

@@ -0,0 +1,17 @@
+<?php
+
+/** @var string $type */
+/** @var string $content */
+[$bgBadgeColor, $bgBadgeText] = match ($type) {
+    'INFO' => ['blue', 'INFO'],
+    'ERROR' => ['red', 'ERROR'],
+};
+
+?>
+
+<div class="my-1">
+    <span class="ml-2 px-1 bg-<?php echo $bgBadgeColor ?>-600 font-bold"><?php echo htmlspecialchars($bgBadgeText) ?></span>
+    <span class="ml-1">
+        <?php echo htmlspecialchars($content) ?>
+    </span>
+</div>

resources/views/components/new-line.php

@@ -0,0 +1 @@
+<div></div>

resources/views/components/two-column-detail.php

@@ -0,0 +1,12 @@
+<div class="flex mx-2 max-w-150">
+    <span>
+        <?php echo htmlspecialchars($left) ?>
+    </span>
+    <span class="flex-1 content-repeat-[.] text-gray ml-1"></span>
+    <?php if ($right !== '') { ?>
+        <span class="ml-1 text-gray">
+            <?php echo htmlspecialchars($right) ?>
+        </span>
+    <?php } ?>
+</div>
+

resources/views/usage.php

@@ -0,0 +1,4 @@
+<div class="mx-2">
+    <span class="text-yellow font-bold">USAGE:</span><span class="ml-1">pest</span><span class="ml-1 text-gray"><?php echo htmlspecialchars('<file>') ?> [options]</span>
+</div>
+

resources/views/version.php

@@ -0,0 +1,3 @@
+<div class="my-1 mx-2">
+    <span>Pest Testing Framework</span><span class="ml-1 text-blue font-bold"><?php echo htmlspecialchars($version) ?></span><span>.</span>
+</div>

scripts/compile.php

@@ -1,36 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-$globalsFilePath = implode(DIRECTORY_SEPARATOR, [
-    dirname(__DIR__),
-    'vendor',
-    'phpunit',
-    'phpunit',
-    'src',
-    'Framework',
-    'Assert',
-    'Functions.php',
-]);
-
-$compiledFilePath = implode(DIRECTORY_SEPARATOR, [dirname(__DIR__), 'compiled', 'globals.php']);
-
-@unlink($compiledFilePath);
-
-$replace = function ($contents, $string, $by) {
-    return str_replace($string, $by, $contents);
-};
-
-$remove = function ($contents, $string) {
-    return str_replace($string, '', $contents);
-};
-
-$contents = file_get_contents($globalsFilePath);
-$contents = $replace($contents, 'namespace PHPUnit\Framework;', 'use PHPUnit\Framework\Assert;');
-$contents = $remove($contents, 'use ArrayAccess;');
-$contents = $remove($contents, 'use Countable;');
-$contents = $remove($contents, 'use DOMDocument;');
-$contents = $remove($contents, 'use DOMElement;');
-$contents = $remove($contents, 'use Throwable;');
-
-file_put_contents(implode(DIRECTORY_SEPARATOR, [dirname(__DIR__), 'compiled', 'globals.php']), $contents);

src/Actions/AddsCoverage.php

@@ -1,79 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Actions;
-
-use Pest\Console\Coverage;
-use Pest\Support\Str;
-use Pest\TestSuite;
-use Symfony\Component\Console\Input\ArgvInput;
-use Symfony\Component\Console\Input\InputDefinition;
-use Symfony\Component\Console\Input\InputOption;
-
-/**
- * @internal
- */
-final class AddsCoverage
-{
-    /**
-     * @var string
-     */
-    private const COVERAGE_OPTION = 'coverage';
-
-    /**
-     * @var string
-     */
-    private const MIN_OPTION = 'min';
-
-    /**
-     * Holds the coverage related options.
-     *
-     * @var array<int, string>
-     */
-    private const OPTIONS = [self::COVERAGE_OPTION, self::MIN_OPTION];
-
-    /**
-     * If any, adds the coverage params to the given original arguments.
-     *
-     * @param array<int, string> $originals
-     *
-     * @return array<int, string>
-     */
-    public static function from(TestSuite $testSuite, array $originals): array
-    {
-        $arguments = array_merge([''], array_values(array_filter($originals, function ($original): bool {
-            foreach (self::OPTIONS as $option) {
-                if ($original === sprintf('--%s', $option) || Str::startsWith($original, sprintf('--%s=', $option))) {
-                    return true;
-                }
-            }
-
-            return false;
-        })));
-
-        $originals = array_flip($originals);
-        foreach ($arguments as $argument) {
-            unset($originals[$argument]);
-        }
-        $originals = array_flip($originals);
-
-        $inputs   = [];
-        $inputs[] = new InputOption(self::COVERAGE_OPTION, null, InputOption::VALUE_NONE);
-        $inputs[] = new InputOption(self::MIN_OPTION, null, InputOption::VALUE_REQUIRED);
-
-        $input = new ArgvInput($arguments, new InputDefinition($inputs));
-        if ((bool) $input->getOption(self::COVERAGE_OPTION)) {
-            $testSuite->coverage = true;
-            $originals[]         = '--coverage-php';
-            $originals[]         = Coverage::getPath();
-        }
-
-        if ($input->getOption(self::MIN_OPTION) !== null) {
-            /* @phpstan-ignore-next-line */
-            $testSuite->coverageMin = (float) $input->getOption(self::MIN_OPTION);
-        }
-
-        return $originals;
-    }
-}

src/Actions/AddsDefaults.php

@@ -1,29 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Actions;
-
-use NunoMaduro\Collision\Adapters\Phpunit\Printer;
-
-/**
- * @internal
- */
-final class AddsDefaults
-{
-    /**
-     * Adds default arguments to the given `arguments` array.
-     *
-     * @param array<string, mixed> $arguments
-     *
-     * @return array<string, mixed>
-     */
-    public static function to(array $arguments): array
-    {
-        if (!array_key_exists('printer', $arguments)) {
-            $arguments['printer'] = new Printer();
-        }
-
-        return $arguments;
-    }
-}

src/Actions/AddsTests.php

@@ -1,66 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Actions;
-
-use PHPUnit\Framework\TestCase;
-use PHPUnit\Framework\TestSuite;
-use PHPUnit\Framework\WarningTestCase;
-
-/**
- * @internal
- */
-final class AddsTests
-{
-    /**
-     * Adds tests to the given test suite.
-     *
-     * @param TestSuite<\PHPUnit\Framework\TestCase> $testSuite
-     */
-    public static function to(TestSuite $testSuite, \Pest\TestSuite $pestTestSuite): void
-    {
-        self::removeTestClosureWarnings($testSuite);
-
-        // @todo refactor this...
-
-        $testSuites = [];
-        $pestTestSuite->tests->build($pestTestSuite, function (TestCase $testCase) use (&$testSuites): void {
-            $testCaseClass = get_class($testCase);
-            if (!array_key_exists($testCaseClass, $testSuites)) {
-                $testSuites[$testCaseClass] = [];
-            }
-
-            $testSuites[$testCaseClass][] = $testCase;
-        });
-
-        foreach ($testSuites as $testCaseName => $testCases) {
-            $testTestSuite = new TestSuite($testCaseName);
-            $testTestSuite->setTests([]);
-            foreach ($testCases as $testCase) {
-                $testTestSuite->addTest($testCase, $testCase->getGroups());
-            }
-            $testSuite->addTestSuite($testTestSuite);
-        }
-    }
-
-    /**
-     * @param TestSuite<\PHPUnit\Framework\TestCase> $testSuite
-     */
-    private static function removeTestClosureWarnings(TestSuite $testSuite): void
-    {
-        $tests = $testSuite->tests();
-
-        foreach ($tests as $key => $test) {
-            if ($test instanceof TestSuite) {
-                self::removeTestClosureWarnings($test);
-            }
-
-            if ($test instanceof WarningTestCase) {
-                unset($tests[$key]);
-            }
-        }
-
-        $testSuite->setTests($tests);
-    }
-}

src/Actions/LoadStructure.php

@@ -1,62 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Actions;
-
-use Pest\Support\Str;
-use PHPUnit\TextUI\Configuration\Configuration;
-use PHPUnit\Util\FileLoader;
-use RecursiveDirectoryIterator;
-use RecursiveIteratorIterator;
-
-/**
- * @internal
- */
-final class LoadStructure
-{
-    /**
-     * The Pest convention.
-     *
-     * @var array<int, string>
-     */
-    private const STRUCTURE = [
-        'Datasets.php',
-        'Helpers.php',
-        'Pest.php',
-        'Datasets',
-    ];
-
-    /**
-     * Validates the configuration in the given `configuration`.
-     */
-    public static function in(string $rootPath): void
-    {
-        $testsPath = $rootPath . DIRECTORY_SEPARATOR . 'tests';
-
-        $load = function ($filename): bool {
-            return file_exists($filename) && (bool) FileLoader::checkAndLoad($filename);
-        };
-
-        foreach (self::STRUCTURE as $filename) {
-            $filename = sprintf('%s%s%s', $testsPath, DIRECTORY_SEPARATOR, $filename);
-
-            if (!file_exists($filename)) {
-                continue;
-            }
-
-            if (is_dir($filename)) {
-                $directory = new RecursiveDirectoryIterator($filename);
-                $iterator  = new RecursiveIteratorIterator($directory);
-                foreach ($iterator as $file) {
-                    $filename = $file->__toString();
-                    if (Str::endsWith($filename, '.php') && file_exists($filename)) {
-                        require_once $filename;
-                    }
-                }
-            } else {
-                $load($filename);
-            }
-        }
-    }
-}

src/Actions/ValidatesConfiguration.php

@@ -1,41 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Actions;
-
-use Pest\Exceptions\AttributeNotSupportedYet;
-use Pest\Exceptions\FileOrFolderNotFound;
-use PHPUnit\TextUI\Configuration\Configuration;
-use PHPUnit\TextUI\Configuration\Registry;
-
-/**
- * @internal
- */
-final class ValidatesConfiguration
-{
-    /**
-     * @var string
-     */
-    private const CONFIGURATION_KEY = 'configuration';
-
-    /**
-     * Validates the configuration in the given `configuration`.
-     *
-     * @param array<string, mixed> $arguments
-     */
-    public static function in($arguments): void
-    {
-        if (!array_key_exists(self::CONFIGURATION_KEY, $arguments) || !file_exists($arguments[self::CONFIGURATION_KEY])) {
-            throw new FileOrFolderNotFound('phpunit.xml');
-        }
-
-        $configuration = Registry::getInstance()
-            ->get($arguments[self::CONFIGURATION_KEY])
-            ->phpunit();
-
-        if ($configuration->processIsolation()) {
-            throw new AttributeNotSupportedYet('processIsolation', 'true');
-        }
-    }
-}

src/Actions/ValidatesEnvironment.php

@@ -1,42 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Actions;
-
-use Pest\Exceptions\FileOrFolderNotFound;
-use Pest\TestSuite;
-
-/**
- * @internal
- */
-final class ValidatesEnvironment
-{
-    /**
-     * The need files on the root path.
-     *
-     * @var array<int, string>
-     */
-    private const NEEDED_FILES = [
-        'composer.json',
-        'tests',
-    ];
-
-    /**
-     * Validates the environment.
-     */
-    public static function in(TestSuite $testSuite): void
-    {
-        $rootPath = $testSuite->rootPath;
-
-        $exists = function ($neededFile) use ($rootPath): bool {
-            return file_exists(sprintf('%s%s%s', $rootPath, DIRECTORY_SEPARATOR, $neededFile));
-        };
-
-        foreach (self::NEEDED_FILES as $neededFile) {
-            if (!$exists($neededFile)) {
-                throw new FileOrFolderNotFound($neededFile);
-            }
-        }
-    }
-}

src/Bootstrappers/BootExcludeList.php

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

src/Bootstrappers/BootFiles.php

@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Bootstrappers;
+
+use Pest\Contracts\Bootstrapper;
+use Pest\Support\DatasetInfo;
+use Pest\Support\Str;
+use Pest\TestSuite;
+use RecursiveDirectoryIterator;
+use RecursiveIteratorIterator;
+use SebastianBergmann\FileIterator\Facade as PhpUnitFileIterator;
+
+use function Pest\testDirectory;
+
+/**
+ * @internal
+ */
+final class BootFiles implements Bootstrapper
+{
+    /**
+     * The structure of the tests directory.
+     *
+     * @var array<int, string>
+     */
+    private const STRUCTURE = [
+        'Expectations',
+        'Expectations.php',
+        'Helpers',
+        'Helpers.php',
+        'Pest.php',
+    ];
+
+    /**
+     * Boots the structure of the tests directory.
+     */
+    public function boot(): void
+    {
+        $rootPath = TestSuite::getInstance()->rootPath;
+        $testsPath = $rootPath.DIRECTORY_SEPARATOR.testDirectory();
+
+        foreach (self::STRUCTURE as $filename) {
+            $filename = sprintf('%s%s%s', $testsPath, DIRECTORY_SEPARATOR, $filename);
+
+            if (! file_exists($filename)) {
+                continue;
+            }
+
+            if (is_dir($filename)) {
+                $directory = new RecursiveDirectoryIterator($filename);
+                $iterator = new RecursiveIteratorIterator($directory);
+                /** @var \DirectoryIterator $file */
+                foreach ($iterator as $file) {
+                    $this->load($file->__toString());
+                }
+            } else {
+                $this->load($filename);
+            }
+        }
+
+        $this->bootDatasets($testsPath);
+    }
+
+    /**
+     * Loads, if possible, the given file.
+     */
+    private function load(string $filename): void
+    {
+        if (! Str::endsWith($filename, '.php')) {
+            return;
+        }
+        if (! file_exists($filename)) {
+            return;
+        }
+        include_once $filename;
+    }
+
+    private function bootDatasets(string $testsPath): void
+    {
+        assert(strlen($testsPath) > 0);
+
+        $files = (new PhpUnitFileIterator)->getFilesAsArray($testsPath, '.php');
+
+        foreach ($files as $file) {
+            if (DatasetInfo::isADatasetsFile($file) || DatasetInfo::isInsideADatasetsDirectory($file)) {
+                $this->load($file);
+            }
+        }
+    }
+}

src/Bootstrappers/BootKernelDump.php

@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Bootstrappers;
+
+use Pest\Contracts\Bootstrapper;
+use Pest\KernelDump;
+use Pest\Support\Container;
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * @internal
+ */
+final class BootKernelDump implements Bootstrapper
+{
+    /**
+     * Creates a new Boot Kernel Dump instance.
+     */
+    public function __construct(
+        private readonly OutputInterface $output,
+    ) {
+        // ...
+    }
+
+    /**
+     * Boots the kernel dump.
+     */
+    public function boot(): void
+    {
+        Container::getInstance()->add(KernelDump::class, $kernelDump = new KernelDump(
+            $this->output,
+        ));
+
+        $kernelDump->enable();
+    }
+}

src/Bootstrappers/BootOverrides.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Bootstrappers;
+
+use Pest\Contracts\Bootstrapper;
+use Pest\Exceptions\ShouldNotHappen;
+
+/**
+ * @internal
+ */
+final class BootOverrides implements Bootstrapper
+{
+    /**
+     * The list of files to be overridden.
+     *
+     * @var array<int, string>
+     */
+    private const FILES = [
+        'Runner/Filter/NameFilterIterator.php',
+        'Runner/ResultCache/DefaultResultCache.php',
+        'Runner/TestSuiteLoader.php',
+        'TextUI/Command/WarmCodeCoverageCacheCommand.php',
+        'TextUI/Output/Default/ProgressPrinter/TestSkippedSubscriber.php',
+        'TextUI/TestSuiteFilterProcessor.php',
+        'Event/Value/ThrowableBuilder.php',
+    ];
+
+    /**
+     * Boots the list of files to be overridden.
+     */
+    public function boot(): void
+    {
+        foreach (self::FILES as $file) {
+            $file = __DIR__."/../../overrides/$file";
+
+            if (! file_exists($file)) {
+                throw ShouldNotHappen::fromMessage(sprintf('File [%s] does not exist.', $file));
+            }
+
+            require_once $file;
+        }
+    }
+}

src/Bootstrappers/BootSubscribers.php

@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Bootstrappers;
+
+use Pest\Contracts\Bootstrapper;
+use Pest\Subscribers;
+use Pest\Support\Container;
+use PHPUnit\Event;
+use PHPUnit\Event\Subscriber;
+
+/**
+ * @internal
+ */
+final class BootSubscribers implements Bootstrapper
+{
+    /**
+     * The list of Subscribers.
+     *
+     * @var array<int, class-string<Subscriber>>
+     */
+    private const SUBSCRIBERS = [
+        Subscribers\EnsureConfigurationIsAvailable::class,
+        Subscribers\EnsureIgnorableTestCasesAreIgnored::class,
+        Subscribers\EnsureKernelDumpIsFlushed::class,
+        Subscribers\EnsureTeamCityEnabled::class,
+    ];
+
+    /**
+     * Creates a new instance of the Boot Subscribers.
+     */
+    public function __construct(
+        private readonly Container $container,
+    ) {
+    }
+
+    /**
+     * Boots the list of Subscribers.
+     */
+    public function boot(): void
+    {
+        foreach (self::SUBSCRIBERS as $subscriber) {
+            $instance = $this->container->get($subscriber);
+
+            assert($instance instanceof Subscriber);
+
+            Event\Facade::instance()->registerSubscriber($instance);
+        }
+    }
+}

src/Bootstrappers/BootView.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Bootstrappers;
+
+use Pest\Contracts\Bootstrapper;
+use Pest\Support\View;
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * @internal
+ */
+final class BootView implements Bootstrapper
+{
+    /**
+     * Creates a new instance of the Boot View.
+     */
+    public function __construct(
+        private readonly OutputInterface $output
+    ) {
+        // ..
+    }
+
+    /**
+     * Boots the view renderer.
+     */
+    public function boot(): void
+    {
+        View::renderUsing($this->output);
+    }
+}

src/Concerns/Expectable.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Concerns;
+
+use Pest\Expectation;
+
+/**
+ * @internal
+ */
+trait Expectable
+{
+    /**
+     * @template TValue
+     *
+     * Creates a new Expectation.
+     *
+     * @param  TValue  $value
+     * @return Expectation<TValue>
+     */
+    public function expect(mixed $value): Expectation
+    {
+        return new Expectation($value);
+    }
+}

src/Concerns/Extendable.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Concerns;
+
+use Closure;
+
+/**
+ * @internal
+ */
+trait Extendable
+{
+    /**
+     * The list of extends.
+     *
+     * @var array<string, Closure>
+     */
+    private static array $extends = [];
+
+    /**
+     * Register a new extend.
+     */
+    public function extend(string $name, Closure $extend): void
+    {
+        static::$extends[$name] = $extend;
+    }
+
+    /**
+     * Checks if given extend name is registered.
+     */
+    public static function hasExtend(string $name): bool
+    {
+        return array_key_exists($name, static::$extends);
+    }
+}

src/Concerns/Logging/WritesToConsole.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Concerns\Logging;
+
+/**
+ * @internal
+ */
+trait WritesToConsole
+{
+    /**
+     * Writes the given success message to the console.
+     */
+    private function writeSuccess(string $message): void
+    {
+        $this->writePestTestOutput($message, 'fg-green, bold', '✓');
+    }
+
+    /**
+     * Writes the given error message to the console.
+     */
+    private function writeError(string $message): void
+    {
+        $this->writePestTestOutput($message, 'fg-red, bold', '⨯');
+    }
+
+    /**
+     * Writes the given warning message to the console.
+     */
+    private function writeWarning(string $message): void
+    {
+        $this->writePestTestOutput($message, 'fg-yellow, bold', '-');
+    }
+
+    /**
+     * Writes the give message to the console.
+     */
+    private function writePestTestOutput(string $message, string $color, string $symbol): void
+    {
+        $this->writeWithColor($color, "$symbol ", false);
+        $this->write($message);
+        $this->writeNewLine();
+    }
+}

src/Concerns/Pipeable.php

@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Concerns;
+
+use Closure;
+
+/**
+ * @internal
+ */
+trait Pipeable
+{
+    /**
+     * The list of pipes.
+     *
+     * @var array<string, array<Closure(Closure, mixed ...$arguments): void>>
+     */
+    private static array $pipes = [];
+
+    /**
+     * The list of interceptors.
+     *
+     * @var array<string, array<Closure(Closure, mixed ...$arguments): void>>
+     */
+    private static array $interceptors = [];
+
+    /**
+     * Register a pipe to be applied before an expectation is checked.
+     */
+    public function pipe(string $name, Closure $pipe): void
+    {
+        self::$pipes[$name][] = $pipe;
+    }
+
+    /**
+     * Register an interceptor that should replace an existing expectation.
+     *
+     * @param  string|Closure(mixed $value, mixed ...$arguments):bool  $filter
+     */
+    public function intercept(string $name, string|Closure $filter, Closure $handler): void
+    {
+        if (is_string($filter)) {
+            $filter = fn ($value): bool => $value instanceof $filter;
+        }
+
+        self::$interceptors[$name][] = $handler;
+
+        $this->pipe($name, function ($next, ...$arguments) use ($handler, $filter): void {
+            /* @phpstan-ignore-next-line */
+            if ($filter($this->value, ...$arguments)) {
+                // @phpstan-ignore-next-line
+                $handler->bindTo($this, $this::class)(...$arguments);
+
+                return;
+            }
+
+            $next();
+        });
+    }
+
+    /**
+     * Get th list of pipes by the given name.
+     *
+     * @return array<int, Closure>
+     */
+    private function pipes(string $name, object $context, string $scope): array
+    {
+        return array_map(fn (Closure $pipe): \Closure => $pipe->bindTo($context, $scope), self::$pipes[$name] ?? []);
+    }
+}

src/Concerns/Retrievable.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Concerns;
+
+/**
+ * @internal
+ */
+trait Retrievable
+{
+    /**
+     * @template TRetrievableValue
+     *
+     * Safely retrieve the value at the given key from an object or array.
+     * @template TRetrievableValue
+     *
+     * @param  array<string, TRetrievableValue>|object  $value
+     * @param  TRetrievableValue|null  $default
+     * @return TRetrievableValue|null
+     */
+    private function retrieve(string $key, mixed $value, mixed $default = null): mixed
+    {
+        if (is_array($value)) {
+            return $value[$key] ?? $default;
+        }
+
+        // @phpstan-ignore-next-line
+        return $value->$key ?? $default;
+    }
+}

src/Concerns/TestCase.php

@@ -1,149 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Concerns;
-
-use Closure;
-use Pest\Support\ExceptionTrace;
-use Pest\TestSuite;
-use PHPUnit\Util\Test;
-
-/**
- * To avoid inheritance conflicts, all the fields related
- * to Pest only will be prefixed by double underscore.
- *
- * @internal
- */
-trait TestCase
-{
-    /**
-     * The test case description. Contains the first
-     * argument of global functions like `it` and `test`.
-     *
-     * @var string
-     */
-    private $__description;
-
-    /**
-     * Holds the test closure function.
-     *
-     * @var Closure
-     */
-    private $__test;
-
-    /**
-     * Creates a new instance of the test case.
-     */
-    public function __construct(Closure $test, string $description, array $data)
-    {
-        $this->__test        = $test;
-        $this->__description = $description;
-
-        parent::__construct('__test', $data);
-    }
-
-    /**
-     * Adds the groups to the current test case.
-     */
-    public function addGroups(array $groups): void
-    {
-        $groups = array_unique(array_merge($this->getGroups(), $groups));
-
-        $this->setGroups($groups);
-    }
-
-    /**
-     * Returns the test case name. Note that, in Pest
-     * we ignore withDataset argument as the description
-     * already contains the dataset description.
-     */
-    public function getName(bool $withDataSet = true): string
-    {
-        return $this->__description;
-    }
-
-    /**
-     * This method is called before the first test of this test class is run.
-     */
-    public static function setUpBeforeClass(): void
-    {
-        parent::setUpBeforeClass();
-
-        $beforeAll = TestSuite::getInstance()->beforeAll->get(self::$__filename);
-
-        call_user_func(Closure::bind($beforeAll, null, self::class));
-    }
-
-    /**
-     * This method is called after the last test of this test class is run.
-     */
-    public static function tearDownAfterClass(): void
-    {
-        $afterAll = TestSuite::getInstance()->afterAll->get(self::$__filename);
-
-        call_user_func(Closure::bind($afterAll, null, self::class));
-
-        parent::tearDownAfterClass();
-    }
-
-    /**
-     * Gets executed before the test.
-     */
-    protected function setUp(): void
-    {
-        TestSuite::getInstance()->test = $this;
-
-        parent::setUp();
-
-        $beforeEach = TestSuite::getInstance()->beforeEach->get(self::$__filename);
-
-        $this->__callClosure($beforeEach, func_get_args());
-    }
-
-    /**
-     * Gets executed after the test.
-     */
-    protected function tearDown(): void
-    {
-        $afterEach = TestSuite::getInstance()->afterEach->get(self::$__filename);
-
-        $this->__callClosure($afterEach, func_get_args());
-
-        parent::tearDown();
-
-        TestSuite::getInstance()->test = null;
-    }
-
-    /**
-     * Returns the test case as string.
-     */
-    public function toString(): string
-    {
-        return \sprintf(
-            '%s::%s',
-            self::$__filename,
-            $this->__description
-        );
-    }
-
-    /**
-     * Runs the test.
-     */
-    public function __test(): void
-    {
-        $this->__callClosure($this->__test, func_get_args());
-    }
-
-    private function __callClosure(Closure $closure, array $arguments): void
-    {
-        ExceptionTrace::ensure(function () use ($closure, $arguments) {
-            call_user_func_array(Closure::bind($closure, $this, get_class($this)), $arguments);
-        });
-    }
-
-    public function getPrintableTestCaseName(): string
-    {
-        return ltrim(self::class, 'P\\');
-    }
-}

src/Concerns/Testable.php

@@ -0,0 +1,380 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Concerns;
+
+use Closure;
+use Pest\Exceptions\DatasetArgsCountMismatch;
+use Pest\Support\ChainableClosure;
+use Pest\Support\ExceptionTrace;
+use Pest\Support\Reflection;
+use Pest\TestSuite;
+use PHPUnit\Framework\TestCase;
+use ReflectionException;
+use ReflectionFunction;
+use Throwable;
+
+/**
+ * @internal
+ *
+ * @mixin TestCase
+ */
+trait Testable
+{
+    /**
+     * The test's description.
+     */
+    private string $__description;
+
+    /**
+     * The test's latest description.
+     */
+    private static string $__latestDescription;
+
+    /**
+     * The test's describing, if any.
+     */
+    public ?string $__describing = null;
+
+    /**
+     * The test's test closure.
+     */
+    private Closure $__test;
+
+    /**
+     * The test's before each closure.
+     */
+    private ?Closure $__beforeEach = null;
+
+    /**
+     * The test's after each closure.
+     */
+    private ?Closure $__afterEach = null;
+
+    /**
+     * The test's before all closure.
+     */
+    private static ?Closure $__beforeAll = null;
+
+    /**
+     * The test's after all closure.
+     */
+    private static ?Closure $__afterAll = null;
+
+    /**
+     * The list of snapshot changes, if any.
+     */
+    private array $__snapshotChanges = [];
+
+    /**
+     * Resets the test case static properties.
+     */
+    public static function flush(): void
+    {
+        self::$__beforeAll = null;
+        self::$__afterAll = null;
+    }
+
+    /**
+     * Creates a new Test Case instance.
+     */
+    public function __construct(string $name)
+    {
+        parent::__construct($name);
+
+        $test = TestSuite::getInstance()->tests->get(self::$__filename);
+
+        if ($test->hasMethod($name)) {
+            $method = $test->getMethod($name);
+            $this->__description = self::$__latestDescription = $method->description;
+            $this->__describing = $method->describing;
+            $this->__test = $method->getClosure($this);
+        }
+    }
+
+    /**
+     * Adds a new "setUpBeforeClass" to the Test Case.
+     */
+    public function __addBeforeAll(?Closure $hook): void
+    {
+        if (! $hook instanceof \Closure) {
+            return;
+        }
+
+        self::$__beforeAll = (self::$__beforeAll instanceof Closure)
+            ? ChainableClosure::boundStatically(self::$__beforeAll, $hook)
+            : $hook;
+    }
+
+    /**
+     * Adds a new "tearDownAfterClass" to the Test Case.
+     */
+    public function __addAfterAll(?Closure $hook): void
+    {
+        if (! $hook instanceof \Closure) {
+            return;
+        }
+
+        self::$__afterAll = (self::$__afterAll instanceof Closure)
+            ? ChainableClosure::boundStatically(self::$__afterAll, $hook)
+            : $hook;
+    }
+
+    /**
+     * Adds a new "setUp" to the Test Case.
+     */
+    public function __addBeforeEach(?Closure $hook): void
+    {
+        $this->__addHook('__beforeEach', $hook);
+    }
+
+    /**
+     * Adds a new "tearDown" to the Test Case.
+     */
+    public function __addAfterEach(?Closure $hook): void
+    {
+        $this->__addHook('__afterEach', $hook);
+    }
+
+    /**
+     * Adds a new "hook" to the Test Case.
+     */
+    private function __addHook(string $property, ?Closure $hook): void
+    {
+        if (! $hook instanceof \Closure) {
+            return;
+        }
+
+        $this->{$property} = ($this->{$property} instanceof Closure)
+            ? ChainableClosure::bound($this->{$property}, $hook)
+            : $hook;
+    }
+
+    /**
+     * This method is called before the first test of this Test Case is run.
+     */
+    public static function setUpBeforeClass(): void
+    {
+        parent::setUpBeforeClass();
+
+        $beforeAll = TestSuite::getInstance()->beforeAll->get(self::$__filename);
+
+        if (self::$__beforeAll instanceof Closure) {
+            $beforeAll = ChainableClosure::boundStatically(self::$__beforeAll, $beforeAll);
+        }
+
+        call_user_func(Closure::bind($beforeAll, null, self::class));
+    }
+
+    /**
+     * This method is called after the last test of this Test Case is run.
+     */
+    public static function tearDownAfterClass(): void
+    {
+        $afterAll = TestSuite::getInstance()->afterAll->get(self::$__filename);
+
+        if (self::$__afterAll instanceof Closure) {
+            $afterAll = ChainableClosure::boundStatically(self::$__afterAll, $afterAll);
+        }
+
+        call_user_func(Closure::bind($afterAll, null, self::class));
+
+        parent::tearDownAfterClass();
+    }
+
+    /**
+     * Gets executed before the Test Case.
+     */
+    protected function setUp(): void
+    {
+        TestSuite::getInstance()->test = $this;
+
+        $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
+
+        $description = $this->dataName() ? $method->description.' with '.$this->dataName() : $method->description;
+
+        if ($method->repetitions > 1) {
+            $matches = [];
+            preg_match('/\((.*?)\)/', $description, $matches);
+
+            if (count($matches) > 1) {
+                if (str_contains($description, 'with '.$matches[0].' /')) {
+                    $description = str_replace('with '.$matches[0].' /', '', $description);
+                } else {
+                    $description = str_replace('with '.$matches[0], '', $description);
+                }
+            }
+
+            $description .= ' @ repetition '.($matches[1].' of '.$method->repetitions);
+        }
+
+        $this->__description = self::$__latestDescription = $description;
+
+        parent::setUp();
+
+        $beforeEach = TestSuite::getInstance()->beforeEach->get(self::$__filename)[1];
+
+        if ($this->__beforeEach instanceof Closure) {
+            $beforeEach = ChainableClosure::bound($this->__beforeEach, $beforeEach);
+        }
+
+        $this->__callClosure($beforeEach, func_get_args());
+    }
+
+    /**
+     * Gets executed after the Test Case.
+     */
+    protected function tearDown(): void
+    {
+        $afterEach = TestSuite::getInstance()->afterEach->get(self::$__filename);
+
+        if ($this->__afterEach instanceof Closure) {
+            $afterEach = ChainableClosure::bound($this->__afterEach, $afterEach);
+        }
+
+        $this->__callClosure($afterEach, func_get_args());
+
+        parent::tearDown();
+
+        TestSuite::getInstance()->test = null;
+    }
+
+    /**
+     * Executes the Test Case current test.
+     *
+     * @throws Throwable
+     */
+    private function __runTest(Closure $closure, ...$args): mixed
+    {
+        $arguments = $this->__resolveTestArguments($args);
+        $this->__ensureDatasetArgumentNumberMatches($arguments);
+
+        return $this->__callClosure($closure, $arguments);
+    }
+
+    /**
+     * Resolve the passed arguments. Any Closures will be bound to the testcase and resolved.
+     *
+     * @throws Throwable
+     */
+    private function __resolveTestArguments(array $arguments): array
+    {
+        $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
+
+        if ($method->repetitions > 1) {
+            array_shift($arguments);
+        }
+
+        $underlyingTest = Reflection::getFunctionVariable($this->__test, 'closure');
+        $testParameterTypes = array_values(Reflection::getFunctionArguments($underlyingTest));
+
+        if (count($arguments) !== 1) {
+            foreach ($arguments as $argumentIndex => $argumentValue) {
+                if (! $argumentValue instanceof Closure) {
+                    continue;
+                }
+
+                if (in_array($testParameterTypes[$argumentIndex], [Closure::class, 'callable', 'mixed'])) {
+                    continue;
+                }
+
+                $arguments[$argumentIndex] = $this->__callClosure($argumentValue, []);
+            }
+
+            return $arguments;
+        }
+
+        if (! $arguments[0] instanceof Closure) {
+            return $arguments;
+        }
+
+        if (in_array($testParameterTypes[0], [Closure::class, 'callable'])) {
+            return $arguments;
+        }
+
+        $boundDatasetResult = $this->__callClosure($arguments[0], []);
+        if (count($testParameterTypes) === 1) {
+            return [$boundDatasetResult];
+        }
+        if (! is_array($boundDatasetResult)) {
+            return [$boundDatasetResult];
+        }
+
+        return array_values($boundDatasetResult);
+    }
+
+    /**
+     * Ensures dataset items count matches underlying test case required parameters
+     *
+     * @throws ReflectionException
+     * @throws DatasetArgsCountMismatch
+     */
+    private function __ensureDatasetArgumentNumberMatches(array $arguments): void
+    {
+        if ($arguments === []) {
+            return;
+        }
+
+        $underlyingTest = Reflection::getFunctionVariable($this->__test, 'closure');
+        $testReflection = new ReflectionFunction($underlyingTest);
+        $requiredParametersCount = $testReflection->getNumberOfRequiredParameters();
+        $suppliedParametersCount = count($arguments);
+
+        if ($suppliedParametersCount >= $requiredParametersCount) {
+            return;
+        }
+
+        throw new DatasetArgsCountMismatch($requiredParametersCount, $suppliedParametersCount);
+    }
+
+    /**
+     * @throws Throwable
+     */
+    private function __callClosure(Closure $closure, array $arguments): mixed
+    {
+        return ExceptionTrace::ensure(fn (): mixed => call_user_func_array(Closure::bind($closure, $this, $this::class), $arguments));
+    }
+
+    /** @postCondition */
+    protected function __MarkTestIncompleteIfSnapshotHaveChanged(): void
+    {
+        if (count($this->__snapshotChanges) === 0) {
+            return;
+        }
+
+        if (count($this->__snapshotChanges) === 1) {
+            $this->markTestIncomplete($this->__snapshotChanges[0]);
+
+            return;
+        }
+
+        $messages = implode(PHP_EOL, array_map(static fn (string $message): string => '- $message', $this->__snapshotChanges));
+
+        $this->markTestIncomplete($messages);
+    }
+
+    /**
+     * The printable test case name.
+     */
+    public static function getPrintableTestCaseName(): string
+    {
+        return preg_replace('/P\\\/', '', self::class, 1);
+    }
+
+    /**
+     * The printable test case method name.
+     */
+    public function getPrintableTestCaseMethodName(): string
+    {
+        return $this->__description;
+    }
+
+    /**
+     * The latest printable test case method name.
+     */
+    public static function getLatestPrintableTestCaseMethodName(): string
+    {
+        return self::$__latestDescription;
+    }
+}

src/Console/Command.php

@@ -1,145 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Console;
-
-use Pest\Actions\AddsCoverage;
-use Pest\Actions\AddsDefaults;
-use Pest\Actions\AddsTests;
-use Pest\Actions\LoadStructure;
-use Pest\Actions\ValidatesConfiguration;
-use Pest\TestSuite;
-use PHPUnit\Framework\TestSuite as BaseTestSuite;
-use PHPUnit\TextUI\Command as BaseCommand;
-use PHPUnit\TextUI\TestRunner;
-use SebastianBergmann\FileIterator\Facade as FileIteratorFacade;
-use Symfony\Component\Console\Output\OutputInterface;
-
-/**
- * @internal
- */
-final class Command extends BaseCommand
-{
-    /**
-     * Holds the current testing suite.
-     *
-     * @var TestSuite
-     */
-    private $testSuite;
-
-    /**
-     * Holds the current console output.
-     *
-     * @var OutputInterface
-     */
-    private $output;
-
-    /**
-     * Creates a new instance of the command class.
-     */
-    public function __construct(TestSuite $testSuite, OutputInterface $output)
-    {
-        $this->testSuite = $testSuite;
-        $this->output    = $output;
-    }
-
-    /**
-     * {@inheritdoc}
-     *
-     * @phpstan-ignore-next-line
-     *
-     * @param array<int, string> $argv
-     */
-    protected function handleArguments(array $argv): void
-    {
-        /*
-         * First, let's handle pest is own `--coverage` param.
-         */
-        $argv = AddsCoverage::from($this->testSuite, $argv);
-
-        /*
-         * Next, as usual, let's send the console arguments to PHPUnit.
-         */
-        parent::handleArguments($argv);
-
-        /*
-         * Finally, let's validate the configuration. Making
-         * sure all options are yet supported by Pest.
-         */
-        ValidatesConfiguration::in($this->arguments);
-    }
-
-    /**
-     * Creates a new PHPUnit test runner.
-     */
-    protected function createRunner(): TestRunner
-    {
-        /*
-         * First, let's add the defaults we use on `pest`. Those
-         * are the printer class, and others that may be appear.
-         */
-        $this->arguments = AddsDefaults::to($this->arguments);
-
-        $testRunner = new TestRunner($this->arguments['loader']);
-        $testSuite  = $this->arguments['test'];
-
-        if (is_string($testSuite)) {
-            if (\is_dir($testSuite)) {
-                /** @var string[] $files */
-                $files = (new FileIteratorFacade())->getFilesAsArray(
-                    $testSuite,
-                    $this->arguments['testSuffixes']
-                );
-            } else {
-                $files = [$testSuite];
-            }
-
-            $testSuite = new BaseTestSuite($testSuite);
-
-            $testSuite->addTestFiles($files);
-
-            $this->arguments['test'] = $testSuite;
-        }
-
-        LoadStructure::in($this->testSuite->rootPath);
-        AddsTests::to($testSuite, $this->testSuite);
-
-        return $testRunner;
-    }
-
-    /**
-     * {@inheritdoc}
-     *
-     * @phpstan-ignore-next-line
-     *
-     * @param array<int, string> $argv
-     */
-    public function run(array $argv, bool $exit = true): int
-    {
-        $result = parent::run($argv, false);
-
-        if ($result === 0 && $this->testSuite->coverage) {
-            if (!Coverage::isAvailable()) {
-                $this->output->writeln(
-                    "\n  <fg=white;bg=red;options=bold> ERROR </> No code coverage driver is available.</>",
-                );
-                exit(1);
-            }
-
-            $coverage = Coverage::report($this->output);
-
-            $result = (int) ($coverage < $this->testSuite->coverageMin);
-
-            if ($result === 1) {
-                $this->output->writeln(sprintf(
-                    "\n  <fg=white;bg=red;options=bold> FAIL </> Code coverage below expected:<fg=red;options=bold> %s %%</>. Minimum:<fg=white;options=bold> %s %%</>.",
-                    number_format($coverage, 1),
-                    number_format($this->testSuite->coverageMin, 1)
-                ));
-            }
-        }
-
-        exit($result);
-    }
-}

src/Console/Coverage.php

@@ -1,167 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Console;
-
-use Pest\Exceptions\ShouldNotHappen;
-use SebastianBergmann\CodeCoverage\Node\Directory;
-use SebastianBergmann\CodeCoverage\Node\File;
-use SebastianBergmann\Environment\Runtime;
-use Symfony\Component\Console\Output\OutputInterface;
-use Symfony\Component\Console\Terminal;
-
-/**
- * @internal
- */
-final class Coverage
-{
-    /**
-     * Returns the coverage path.
-     */
-    public static function getPath(): string
-    {
-        return implode(DIRECTORY_SEPARATOR, [
-            dirname(__DIR__, 2),
-            '.temp',
-            'coverage.php',
-        ]);
-    }
-
-    /**
-     * Runs true there is any code
-     * coverage driver available.
-     */
-    public static function isAvailable(): bool
-    {
-        return (new Runtime())->canCollectCodeCoverage();
-    }
-
-    /**
-     * Reports the code coverage report to the
-     * console and returns the result in float.
-     */
-    public static function report(OutputInterface $output): float
-    {
-        if (!file_exists($reportPath = self::getPath())) {
-            throw ShouldNotHappen::fromMessage(sprintf('Coverage not found in path: %s.', $reportPath));
-        }
-
-        /** @var \SebastianBergmann\CodeCoverage\CodeCoverage $codeCoverage */
-        $codeCoverage = require $reportPath;
-        unlink($reportPath);
-
-        $totalWidth = (new Terminal())->getWidth();
-
-        $dottedLineLength = $totalWidth <= 70 ? $totalWidth : 70;
-
-        $totalCoverage = $codeCoverage->getReport()->getLineExecutedPercent();
-
-        $output->writeln(
-            sprintf(
-                '  <fg=white;options=bold>Cov:    </><fg=default>%s</>',
-                $totalCoverage
-            )
-        );
-
-        $output->writeln('');
-
-        /** @var Directory<File|Directory> $report */
-        $report = $codeCoverage->getReport();
-
-        foreach ($report->getIterator() as $file) {
-            if (!$file instanceof File) {
-                continue;
-            }
-            $dirname  = dirname($file->getId());
-            $basename = basename($file->getId(), '.php');
-
-            $name = $dirname === '.' ? $basename : implode(DIRECTORY_SEPARATOR, [
-                $dirname,
-                $basename,
-            ]);
-            $rawName = $dirname === '.' ? $basename : implode(DIRECTORY_SEPARATOR, [
-                $dirname,
-                $basename,
-            ]);
-
-            $linesExecutedTakenSize = 0;
-
-            if ($file->getLineExecutedPercent() != '0.00%') {
-                $linesExecutedTakenSize = strlen($uncoveredLines = trim(implode(', ', self::getMissingCoverage($file)))) + 1;
-                $name .= sprintf(' <fg=red>%s</>', $uncoveredLines);
-            }
-
-            $percentage = $file->getNumExecutableLines() === 0
-                ? '100.0'
-                : number_format((float) $file->getLineExecutedPercent(), 1, '.', '');
-
-            $takenSize = strlen($rawName . $percentage) + 4 + $linesExecutedTakenSize; // adding 3 space and percent sign
-
-            $percentage = sprintf(
-                '<fg=%s>%s</>',
-                $percentage === '100.0' ? 'green' : ($percentage === '0.0' ? 'red' : 'yellow'),
-                $percentage
-            );
-
-            $output->writeln(sprintf('  %s %s %s %%',
-                $name,
-                str_repeat('.', max($dottedLineLength - $takenSize, 1)),
-                $percentage
-            ));
-        }
-
-        return (float) $totalCoverage;
-    }
-
-    /**
-     * Generates an array of missing coverage on the following format:.
-     *
-     * ```
-     * ['11', '20..25', '50', '60...80'];
-     * ```
-     *
-     * @param File $file
-     *
-     * @return array<int, string>
-     */
-    public static function getMissingCoverage($file): array
-    {
-        $shouldBeNewLine = true;
-
-        $eachLine = function (array $array, array $tests, int $line) use (&$shouldBeNewLine): array {
-            if (count($tests) > 0) {
-                $shouldBeNewLine = true;
-
-                return $array;
-            }
-
-            if ($shouldBeNewLine) {
-                $array[]         = (string) $line;
-                $shouldBeNewLine = false;
-
-                return $array;
-            }
-
-            $lastKey = count($array) - 1;
-
-            if (array_key_exists($lastKey, $array) && strpos($array[$lastKey], '..') !== false) {
-                [$from]          = explode('..', $array[$lastKey]);
-                $array[$lastKey] = sprintf('%s..%s', $from, $line);
-
-                return $array;
-            }
-
-            $array[$lastKey] = sprintf('%s..%s', $array[$lastKey], $line);
-
-            return $array;
-        };
-
-        $array = [];
-        foreach (array_filter($file->getCoverageData(), 'is_array') as $line => $tests) {
-            $array = $eachLine($array, $tests, $line);
-        }
-
-        return $array;
-    }
-}

src/Console/Help.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Console;
+
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * @internal
+ */
+final class Help
+{
+    /**
+     * The Command messages.
+     *
+     * @var array<int, string>
+     */
+    private const HELP_MESSAGES = [
+        '<comment>Pest Options:</comment>',
+        '  <info>--init</info>                      Initialise a standard Pest configuration',
+        '  <info>--coverage</info>                  Enable coverage and output to standard output',
+        '  <info>--min=<fg=cyan><N></></info>                   Set the minimum required coverage percentage (<N>), and fail if not met',
+        '  <info>--group=<fg=cyan><name></></info>              Only runs tests from the specified group(s)',
+    ];
+
+    /**
+     * Creates a new Console Command instance.
+     */
+    public function __construct(private readonly OutputInterface $output)
+    {
+        // ..
+    }
+
+    /**
+     * Executes the Console Command.
+     */
+    public function __invoke(): void
+    {
+        foreach (self::HELP_MESSAGES as $message) {
+            $this->output->writeln($message);
+        }
+    }
+}

src/Console/Thanks.php

@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Console;
+
+use Pest\Bootstrappers\BootView;
+use Pest\Support\View;
+use Symfony\Component\Console\Helper\SymfonyQuestionHelper;
+use Symfony\Component\Console\Input\ArrayInput;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Question\ConfirmationQuestion;
+
+/**
+ * @internal
+ */
+final class Thanks
+{
+    /**
+     * The support options.
+     *
+     * @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',
+    ];
+
+    /**
+     * Creates a new Console Command instance.
+     */
+    public function __construct(
+        private readonly InputInterface $input,
+        private readonly OutputInterface $output
+    ) {
+        // ..
+    }
+
+    /**
+     * Executes the Console Command.
+     */
+    public function __invoke(): void
+    {
+        $bootstrapper = new BootView($this->output);
+        $bootstrapper->boot();
+
+        $wantsToSupport = false;
+
+        if (getenv('PEST_NO_SUPPORT') !== 'true' && $this->input->isInteractive()) {
+            $wantsToSupport = (new SymfonyQuestionHelper())->ask(
+                new ArrayInput([]),
+                $this->output,
+                new ConfirmationQuestion(
+                    ' <options=bold>Wanna show Pest some love by starring it on GitHub?</>',
+                    false,
+                )
+            );
+
+            View::render('components.new-line');
+
+            foreach (self::FUNDING_MESSAGES as $message => $link) {
+                View::render('components.two-column-detail', [
+                    'left' => $message,
+                    'right' => $link,
+                ]);
+            }
+
+            View::render('components.new-line');
+        }
+
+        if ($wantsToSupport === true) {
+            if (PHP_OS_FAMILY == 'Darwin') {
+                exec('open https://github.com/pestphp/pest');
+            }
+            if (PHP_OS_FAMILY == 'Windows') {
+                exec('start https://github.com/pestphp/pest');
+            }
+            if (PHP_OS_FAMILY == 'Linux') {
+                exec('xdg-open https://github.com/pestphp/pest');
+            }
+        }
+    }
+}

src/Contracts/AddsAnnotations.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Contracts;
+
+use Pest\Factories\TestCaseMethodFactory;
+
+/**
+ * @internal
+ */
+interface AddsAnnotations
+{
+    /**
+     * Adds annotations to the given test case method.
+     *
+     * @param  array<int, string>  $annotations
+     * @return array<int, string>
+     */
+    public function __invoke(TestCaseMethodFactory $method, array $annotations): array;
+}

src/Contracts/Bootstrapper.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Contracts;
+
+/**
+ * @internal
+ */
+interface Bootstrapper
+{
+    /**
+     * Boots the bootstrapper.
+     */
+    public function boot(): void;
+}

src/Contracts/HasPrintableTestCaseName.php

@@ -4,18 +4,12 @@ declare(strict_types=1);
 
 namespace Pest\Contracts;
 
-if (interface_exists(\NunoMaduro\Collision\Contracts\Adapters\Phpunit\HasPrintableTestCaseName::class)) {
+use NunoMaduro\Collision\Contracts\Adapters\Phpunit\HasPrintableTestCaseName as BaseHasPrintableTestCaseName;
+
 /**
  * @internal
  */
-    interface HasPrintableTestCaseName extends \NunoMaduro\Collision\Contracts\Adapters\Phpunit\HasPrintableTestCaseName
+interface HasPrintableTestCaseName extends BaseHasPrintableTestCaseName
 {
-    }
-} else {
-    /**
-     * @internal
-     */
-    interface HasPrintableTestCaseName
-    {
-    }
+    // ..
 }

src/Contracts/Panicable.php

@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Contracts;
+
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * @internal
+ */
+interface Panicable
+{
+    /**
+     * Renders the panic on the given output.
+     */
+    public function render(OutputInterface $output): void;
+
+    /**
+     * The exit code to be used.
+     */
+    public function exitCode(): int;
+}

src/Contracts/Plugins/AddsOutput.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Contracts\Plugins;
+
+/**
+ * @internal
+ */
+interface AddsOutput
+{
+    /**
+     * Adds output after the Test Suite execution.
+     */
+    public function addOutput(int $exitCode): int;
+}

src/Contracts/Plugins/Bootable.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Contracts\Plugins;
+
+/**
+ * @internal
+ */
+interface Bootable
+{
+    /**
+     * Boots the plugin.
+     */
+    public function boot(): void;
+}

src/Contracts/Plugins/HandlesArguments.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Contracts\Plugins;
+
+/**
+ * @internal
+ */
+interface HandlesArguments
+{
+    /**
+     * Adds arguments before the Test Suite execution.
+     *
+     * @param  array<int, string>  $arguments
+     * @return array<int, string>
+     */
+    public function handleArguments(array $arguments): array;
+}

src/Contracts/Plugins/Shutdownable.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Contracts\Plugins;
+
+/**
+ * @internal
+ */
+interface Shutdownable
+{
+    /**
+     * Shutdowns the plugin.
+     */
+    public function shutdown(): void;
+}

src/Contracts/TestCaseFilter.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Contracts;
+
+interface TestCaseFilter
+{
+    /**
+     * Whether the test case is accepted.
+     */
+    public function accept(string $testCaseFilename): bool;
+}

src/Contracts/TestCaseMethodFilter.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Contracts;
+
+use Pest\Factories\TestCaseMethodFactory;
+
+interface TestCaseMethodFilter
+{
+    /**
+     * Whether the test case method is accepted.
+     */
+    public function accept(TestCaseMethodFactory $factory): bool;
+}

src/Datasets.php

@@ -1,97 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest;
-
-use Closure;
-use Pest\Exceptions\DatasetAlreadyExist;
-use Pest\Exceptions\DatasetDoesNotExist;
-use SebastianBergmann\Exporter\Exporter;
-use Traversable;
-
-/**
- * @internal
- */
-final class Datasets
-{
-    /**
-     * Holds the datasets.
-     *
-     * @var array<string, \Closure|iterable<int, mixed>>
-     */
-    private static $datasets = [];
-
-    /**
-     * Sets the given.
-     *
-     * @param Closure|iterable<int, mixed> $data
-     */
-    public static function set(string $name, $data): void
-    {
-        if (array_key_exists($name, self::$datasets)) {
-            throw new DatasetAlreadyExist($name);
-        }
-
-        self::$datasets[$name] = $data;
-    }
-
-    /**
-     * @return Closure|iterable<int, mixed>
-     */
-    public static function get(string $name)
-    {
-        if (!array_key_exists($name, self::$datasets)) {
-            throw new DatasetDoesNotExist($name);
-        }
-
-        return self::$datasets[$name];
-    }
-
-    /**
-     * Resolves the current dataset to an array value.
-     *
-     * @param Traversable<int, mixed>|Closure|iterable<int, mixed>|string|null $data
-     *
-     * @return array<string, mixed>
-     */
-    public static function resolve(string $description, $data): array
-    {
-        /* @phpstan-ignore-next-line */
-        if (is_null($data) || empty($data)) {
-            return [$description => []];
-        }
-
-        if (is_string($data)) {
-            $data = self::get($data);
-        }
-
-        if (is_callable($data)) {
-            $data = call_user_func($data);
-        }
-
-        if ($data instanceof Traversable) {
-            $data = iterator_to_array($data);
-        }
-
-        $namedData = [];
-        foreach ($data as $values) {
-            $values = is_array($values) ? $values : [$values];
-
-            $name             = $description . self::getDataSetDescription($values);
-            $namedData[$name] = $values;
-        }
-
-        return $namedData;
-    }
-
-    /**
-     * @param array<int, mixed> $data
-     */
-    private static function getDataSetDescription(array $data): string
-    {
-        $exporter = new Exporter();
-
-        return \sprintf(' with (%s)', $exporter->shortenedRecursiveExport($data));
-    }
-}

src/Exceptions/AfterAllAlreadyExist.php

@@ -15,10 +15,10 @@ use Symfony\Component\Console\Exception\ExceptionInterface;
 final class AfterAllAlreadyExist extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
 {
     /**
-     * Creates a new instance of after all already exist exception.
+     * Creates a new Exception instance.
      */
     public function __construct(string $filename)
     {
-        parent::__construct(sprintf('The afterAll already exist in the filename `%s`.', $filename));
+        parent::__construct(sprintf('The afterAll already exists in the filename `%s`.', $filename));
     }
 }

src/Exceptions/AfterAllWithinDescribe.php

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

src/Exceptions/AttributeNotSupportedYet.php

@@ -1,24 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Exceptions;
-
-use InvalidArgumentException;
-use NunoMaduro\Collision\Contracts\RenderlessEditor;
-use NunoMaduro\Collision\Contracts\RenderlessTrace;
-use Symfony\Component\Console\Exception\ExceptionInterface;
-
-/**
- * @internal
- */
-final class AttributeNotSupportedYet extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
-{
-    /**
-     * Creates a new instance of attribute not supported yet.
-     */
-    public function __construct(string $attribute, string $value)
-    {
-        parent::__construct(sprintf('The PHPUnit attribute `%s` with value `%s` is not supported yet.', $attribute, $value));
-    }
-}

src/Exceptions/BeforeAllAlreadyExist.php

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

src/Exceptions/BeforeAllWithinDescribe.php

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

src/Exceptions/DatasetAlreadyExists.php

@@ -12,13 +12,13 @@ use Symfony\Component\Console\Exception\ExceptionInterface;
 /**
  * @internal
  */
-final class DatasetAlreadyExist extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
+final class DatasetAlreadyExists extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
 {
     /**
-     * Creates a new instance of dataset already exist.
+     * Creates a new Exception instance.
      */
-    public function __construct(string $name)
+    public function __construct(string $name, string $scope)
     {
-        parent::__construct(sprintf('A dataset with the name `%s` already exist.', $name));
+        parent::__construct(sprintf('A dataset with the name `%s` already exists in scope [%s].', $name, $scope));
     }
 }

src/Exceptions/DatasetArgsCountMismatch.php

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

src/Exceptions/DatasetDoesNotExist.php

@@ -15,7 +15,7 @@ use Symfony\Component\Console\Exception\ExceptionInterface;
 final class DatasetDoesNotExist extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
 {
     /**
-     * Creates a new instance of dataset does not exist.
+     * Creates a new Exception instance.
      */
     public function __construct(string $name)
     {

src/Exceptions/DatasetMissing.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use BadFunctionCallException;
+use NunoMaduro\Collision\Contracts\RenderlessEditor;
+use NunoMaduro\Collision\Contracts\RenderlessTrace;
+use Symfony\Component\Console\Exception\ExceptionInterface;
+
+/**
+ * @internal
+ */
+final class DatasetMissing extends BadFunctionCallException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
+{
+    /**
+     * Creates a new Exception instance.
+     *
+     * @param  array<string, string>  $arguments
+     */
+    public function __construct(string $file, string $name, array $arguments)
+    {
+        parent::__construct(sprintf(
+            "A test with the description '%s' has %d argument(s) ([%s]) and no dataset(s) provided in %s",
+            $name,
+            count($arguments),
+            implode(', ', array_map(static fn (string $arg, string $type): string => sprintf('%s $%s', $type, $arg), array_keys($arguments), $arguments)),
+            $file,
+        ));
+    }
+}

src/Exceptions/ExpectationNotFound.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use Exception;
+
+/**
+ * @internal
+ */
+final class ExpectationNotFound extends Exception
+{
+    /**
+     * Creates a new ExpectationNotFound instance from the given name.
+     */
+    public static function fromName(string $name): ExpectationNotFound
+    {
+        return new self("Expectation [$name] does not exist.");
+    }
+}

src/Exceptions/FileOrFolderNotFound.php

@@ -15,10 +15,10 @@ use Symfony\Component\Console\Exception\ExceptionInterface;
 final class FileOrFolderNotFound extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
 {
     /**
-     * Creates a new instance of file not found.
+     * Creates a new Exception instance.
      */
     public function __construct(string $filename)
     {
-        parent::__construct(sprintf('The file or folder with the name `%s` not found.', $filename));
+        parent::__construct(sprintf('The file or folder with the name `%s` could not be found.', $filename));
     }
 }

src/Exceptions/InvalidArgumentException.php

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

src/Exceptions/InvalidExpectation.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use LogicException;
+use NunoMaduro\Collision\Contracts\RenderlessEditor;
+use NunoMaduro\Collision\Contracts\RenderlessTrace;
+use Symfony\Component\Console\Exception\ExceptionInterface;
+
+/**
+ * @internal
+ */
+final class InvalidExpectation extends LogicException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
+{
+    /**
+     * @param  array<int, string>  $methods
+     *
+     * @throws self
+     */
+    public static function fromMethods(array $methods): never
+    {
+        throw new self(sprintf('Expectation [%s] is not valid.', implode('->', $methods)));
+    }
+}

src/Exceptions/InvalidExpectationValue.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use InvalidArgumentException;
+
+/**
+ * @internal
+ */
+final class InvalidExpectationValue extends InvalidArgumentException
+{
+    /**
+     * @throws self
+     */
+    public static function expected(string $type): never
+    {
+        throw new self(sprintf('Invalid expectation value type. Expected [%s].', $type));
+    }
+}

src/Exceptions/InvalidOption.php

@@ -12,10 +12,10 @@ use Symfony\Component\Console\Exception\ExceptionInterface;
 /**
  * @internal
  */
-final class InvalidConsoleArgument extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
+final class InvalidOption extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
 {
     /**
-     * Creates a new instance of should not happen.
+     * Creates a new Exception instance.
      */
     public function __construct(string $message)
     {

src/Exceptions/InvalidPestCommand.php

@@ -15,10 +15,10 @@ use Symfony\Component\Console\Exception\ExceptionInterface;
 final class InvalidPestCommand extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
 {
     /**
-     * Creates a new instance of invalid pest command exception.
+     * Creates a new Exception instance.
      */
     public function __construct()
     {
-        parent::__construct('Please run `./vendor/bin/pest` instead of `/vendor/bin/phpunit`.');
+        parent::__construct('Please run [./vendor/bin/pest] instead.');
     }
 }

src/Exceptions/InvalidUsesPath.php

@@ -1,24 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Exceptions;
-
-use InvalidArgumentException;
-use NunoMaduro\Collision\Contracts\RenderlessEditor;
-use NunoMaduro\Collision\Contracts\RenderlessTrace;
-use Symfony\Component\Console\Exception\ExceptionInterface;
-
-/**
- * @internal
- */
-final class InvalidUsesPath extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
-{
-    /**
-     * Creates a new instance of invalid uses path.
-     */
-    public function __construct(string $target)
-    {
-        parent::__construct(sprintf('The path `%s` is not valid.', $target));
-    }
-}

src/Exceptions/MissingDependency.php

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

src/Exceptions/NoDirtyTestsFound.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use InvalidArgumentException;
+use NunoMaduro\Collision\Contracts\RenderlessEditor;
+use NunoMaduro\Collision\Contracts\RenderlessTrace;
+use Pest\Contracts\Panicable;
+use Symfony\Component\Console\Exception\ExceptionInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * @internal
+ */
+final class NoDirtyTestsFound extends InvalidArgumentException implements ExceptionInterface, Panicable, RenderlessEditor, RenderlessTrace
+{
+    /**
+     * Renders the panic on the given output.
+     */
+    public function render(OutputInterface $output): void
+    {
+        $output->writeln([
+            '',
+            '  <fg=white;options=bold;bg=blue> INFO </> No "dirty" tests found.',
+            '',
+        ]);
+    }
+
+    /**
+     * The exit code to be used.
+     */
+    public function exitCode(): int
+    {
+        return 0;
+    }
+}

src/Exceptions/ShouldNotHappen.php

@@ -13,19 +13,18 @@ use RuntimeException;
 final class ShouldNotHappen extends RuntimeException
 {
     /**
-     * Creates a new instance of should not happen.
+     * Creates a new Exception instance.
      */
     public function __construct(Exception $exception)
     {
         $message = $exception->getMessage();
 
-        parent::__construct(sprintf(<<<EOF
-
+        parent::__construct(sprintf(<<<'EOF'
 This should not happen - please create an new issue here: https://github.com/pestphp/pest.
 
-- Issue: %s
-- PHP version: %s
-- Operating system: %s
+  Issue: %s
+  PHP version: %s
+  Operating system: %s
 EOF
             , $message, phpversion(), PHP_OS), 1, $exception);
     }

src/Exceptions/TestAlreadyExist.php

@@ -15,10 +15,10 @@ use Symfony\Component\Console\Exception\ExceptionInterface;
 final class TestAlreadyExist extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
 {
     /**
-     * Creates a new instance of test already exist.
+     * Creates a new Exception instance.
      */
     public function __construct(string $fileName, string $description)
     {
-        parent::__construct(sprintf('A test with the description `%s` already exist in the filename `%s`.', $description, $fileName));
+        parent::__construct(sprintf('A test with the description `%s` already exists in the filename `%s`.', $description, $fileName));
     }
 }

src/Exceptions/TestCaseAlreadyInUse.php

@@ -15,7 +15,7 @@ use Symfony\Component\Console\Exception\ExceptionInterface;
 final class TestCaseAlreadyInUse extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
 {
     /**
-     * Creates a new instance of test case already in use.
+     * Creates a new Exception instance.
      */
     public function __construct(string $inUse, string $newOne, string $folder)
     {

src/Exceptions/TestCaseClassOrTraitNotFound.php

@@ -15,7 +15,7 @@ use Symfony\Component\Console\Exception\ExceptionInterface;
 final class TestCaseClassOrTraitNotFound extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
 {
     /**
-     * Creates a new instance of after each already exist exception.
+     * Creates a new Exception instance.
      */
     public function __construct(string $testCaseClass)
     {

src/Exceptions/TestDescriptionMissing.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use InvalidArgumentException;
+use NunoMaduro\Collision\Contracts\RenderlessEditor;
+use NunoMaduro\Collision\Contracts\RenderlessTrace;
+use Symfony\Component\Console\Exception\ExceptionInterface;
+
+/**
+ * @internal
+ */
+final class TestDescriptionMissing extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
+{
+    /**
+     * Creates a new Exception instance.
+     */
+    public function __construct(string $fileName)
+    {
+        parent::__construct(sprintf('Test description is missing in the filename `%s`.', $fileName));
+    }
+}

src/Expectation.php

@@ -0,0 +1,865 @@
+<?php
+
+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;
+use Pest\Arch\Expectations\ToBeUsedInNothing;
+use Pest\Arch\Expectations\ToOnlyBeUsedIn;
+use Pest\Arch\Expectations\ToOnlyUse;
+use Pest\Arch\Expectations\ToUse;
+use Pest\Arch\Expectations\ToUseNothing;
+use Pest\Arch\PendingArchExpectation;
+use Pest\Arch\Support\FileLineFinder;
+use Pest\Concerns\Extendable;
+use Pest\Concerns\Pipeable;
+use Pest\Concerns\Retrievable;
+use Pest\Exceptions\ExpectationNotFound;
+use Pest\Exceptions\InvalidExpectation;
+use Pest\Exceptions\InvalidExpectationValue;
+use Pest\Expectations\EachExpectation;
+use Pest\Expectations\HigherOrderExpectation;
+use Pest\Expectations\OppositeExpectation;
+use Pest\Matchers\Any;
+use Pest\Support\ExpectationPipeline;
+use PHPUnit\Architecture\Elements\ObjectDescription;
+use PHPUnit\Framework\ExpectationFailedException;
+
+/**
+ * @internal
+ *
+ * @template TValue
+ *
+ * @property OppositeExpectation $not Creates the opposite expectation.
+ * @property EachExpectation $each Creates an expectation on each element on the traversable value.
+ * @property PendingArchExpectation $classes
+ * @property PendingArchExpectation $traits
+ * @property PendingArchExpectation $interfaces
+ * @property PendingArchExpectation $enums
+ *
+ * @mixin Mixins\Expectation<TValue>
+ * @mixin PendingArchExpectation
+ */
+final class Expectation
+{
+    use Extendable;
+    use Pipeable;
+    use Retrievable;
+
+    /**
+     * Creates a new expectation.
+     *
+     * @param  TValue  $value
+     */
+    public function __construct(
+        public mixed $value
+    ) {
+        // ..
+    }
+
+    /**
+     * Creates a new expectation.
+     *
+     * @template TAndValue
+     *
+     * @param  TAndValue  $value
+     * @return self<TAndValue>
+     */
+    public function and(mixed $value): Expectation
+    {
+        return $value instanceof self ? $value : new self($value);
+    }
+
+    /**
+     * Creates a new expectation with the decoded JSON value.
+     *
+     * @return self<array<int|string, mixed>|bool>
+     */
+    public function json(): Expectation
+    {
+        if (! is_string($this->value)) {
+            InvalidExpectationValue::expected('string');
+        }
+
+        $this->toBeJson();
+
+        /** @var array<int|string, mixed>|bool $value */
+        $value = json_decode($this->value, true, 512, JSON_THROW_ON_ERROR);
+
+        return $this->and($value);
+    }
+
+    /**
+     * Dump the expectation value.
+     *
+     * @return self<TValue>
+     */
+    public function dump(mixed ...$arguments): self
+    {
+        if (function_exists('dump')) {
+            dump($this->value, ...$arguments);
+        } else {
+            var_dump($this->value);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Dump the expectation value and end the script.
+     *
+     * @return never
+     */
+    public function dd(mixed ...$arguments): void
+    {
+        if (function_exists('dd')) {
+            dd($this->value, ...$arguments);
+        }
+
+        var_dump($this->value);
+
+        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.
+     *
+     * @return self<TValue>
+     */
+    public function ray(mixed ...$arguments): self
+    {
+        if (function_exists('ray')) {
+            ray($this->value, ...$arguments);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Creates the opposite expectation for the value.
+     *
+     * @return OppositeExpectation<TValue>
+     */
+    public function not(): OppositeExpectation
+    {
+        return new OppositeExpectation($this);
+    }
+
+    /**
+     * Creates an expectation on each item of the iterable "value".
+     *
+     * @return EachExpectation<TValue>
+     */
+    public function each(callable $callback = null): EachExpectation
+    {
+        if (! is_iterable($this->value)) {
+            throw new BadMethodCallException('Expectation value is not iterable.');
+        }
+
+        if (is_callable($callback)) {
+            foreach ($this->value as $key => $item) {
+                $callback(new self($item), $key);
+            }
+        }
+
+        return new EachExpectation($this);
+    }
+
+    /**
+     * Allows you to specify a sequential set of expectations for each item in a iterable "value".
+     *
+     * @template TSequenceValue
+     *
+     * @param  (callable(self<TValue>, self<string|int>): void)|TSequenceValue  ...$callbacks
+     * @return self<TValue>
+     */
+    public function sequence(mixed ...$callbacks): self
+    {
+        if (! is_iterable($this->value)) {
+            throw new BadMethodCallException('Expectation value is not iterable.');
+        }
+
+        if (count($callbacks) == 0) {
+            throw new InvalidArgumentException('No sequence expectations defined.');
+        }
+
+        $index = $valuesCount = 0;
+
+        foreach ($this->value as $key => $value) {
+            $valuesCount++;
+
+            if ($callbacks[$index] instanceof Closure) {
+                $callbacks[$index](new self($value), new self($key));
+            } else {
+                (new self($value))->toEqual($callbacks[$index]);
+            }
+
+            $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;
+    }
+
+    /**
+     * If the subject matches one of the given "expressions", the expression callback will run.
+     *
+     * @template TMatchSubject of array-key
+     *
+     * @param  (callable(): TMatchSubject)|TMatchSubject  $subject
+     * @param  array<TMatchSubject, (callable(self<TValue>): mixed)|TValue>  $expressions
+     * @return self<TValue>
+     */
+    public function match(mixed $subject, array $expressions): self
+    {
+        $subject = $subject instanceof Closure ? $subject() : $subject;
+
+        $matched = false;
+
+        foreach ($expressions as $key => $callback) {
+            if ($subject != $key) {
+                continue;
+            }
+
+            $matched = true;
+
+            if (is_callable($callback)) {
+                $callback(new self($this->value));
+
+                continue;
+            }
+
+            $this->and($this->value)->toEqual($callback);
+
+            break;
+        }
+
+        if ($matched === false) {
+            throw new ExpectationFailedException('Unhandled match value.');
+        }
+
+        return $this;
+    }
+
+    /**
+     * Apply the callback if the given "condition" is falsy.
+     *
+     * @param  (callable(): bool)|bool  $condition
+     * @param  callable(Expectation<TValue>): mixed  $callback
+     * @return self<TValue>
+     */
+    public function unless(callable|bool $condition, callable $callback): Expectation
+    {
+        $condition = is_callable($condition)
+            ? $condition
+            : static fn (): bool => $condition;
+
+        return $this->when(! $condition(), $callback);
+    }
+
+    /**
+     * Apply the callback if the given "condition" is truthy.
+     *
+     * @param  (callable(): bool)|bool  $condition
+     * @param  callable(self<TValue>): mixed  $callback
+     * @return self<TValue>
+     */
+    public function when(callable|bool $condition, callable $callback): self
+    {
+        $condition = is_callable($condition)
+            ? $condition
+            : static fn (): bool => $condition;
+
+        if ($condition()) {
+            $callback($this->and($this->value));
+        }
+
+        return $this;
+    }
+
+    /**
+     * Dynamically calls methods on the class or creates a new higher order expectation.
+     *
+     * @param  array<int, mixed>  $parameters
+     * @return Expectation<TValue>|HigherOrderExpectation<Expectation<TValue>, TValue>
+     */
+    public function __call(string $method, array $parameters): Expectation|HigherOrderExpectation|PendingArchExpectation
+    {
+        if (! self::hasMethod($method)) {
+            if (! is_object($this->value) && method_exists(PendingArchExpectation::class, $method)) {
+                $pendingArchExpectation = new PendingArchExpectation($this, []);
+
+                return $pendingArchExpectation->$method(...$parameters); // @phpstan-ignore-line
+            }
+
+            if (! is_object($this->value)) {
+                throw new BadMethodCallException(sprintf(
+                    'Method "%s" does not exist in %s.',
+                    $method,
+                    gettype($this->value)
+                ));
+            }
+
+            /* @phpstan-ignore-next-line */
+            return new HigherOrderExpectation($this, call_user_func_array($this->value->$method(...), $parameters));
+        }
+
+        ExpectationPipeline::for($this->getExpectationClosure($method))
+            ->send(...$parameters)
+            ->through($this->pipes($method, $this, Expectation::class))
+            ->run();
+
+        return $this;
+    }
+
+    /**
+     * Creates a new expectation closure from the given name.
+     *
+     * @throws ExpectationNotFound
+     */
+    private function getExpectationClosure(string $name): Closure
+    {
+        if (method_exists(Mixins\Expectation::class, $name)) {
+            // @phpstan-ignore-next-line
+            return Closure::fromCallable([new Mixins\Expectation($this->value), $name]);
+        }
+
+        if (self::hasExtend($name)) {
+            $extend = self::$extends[$name]->bindTo($this, Expectation::class);
+
+            if ($extend != false) {
+                return $extend;
+            }
+        }
+
+        throw ExpectationNotFound::fromName($name);
+    }
+
+    /**
+     * Dynamically calls methods on the class without any arguments or creates a new higher order expectation.
+     *
+     * @return Expectation<TValue>|OppositeExpectation<TValue>|EachExpectation<TValue>|HigherOrderExpectation<Expectation<TValue>, TValue|null>|TValue
+     */
+    public function __get(string $name)
+    {
+        if (! self::hasMethod($name)) {
+            if (! is_object($this->value) && method_exists(PendingArchExpectation::class, $name)) {
+                /* @phpstan-ignore-next-line */
+                return $this->{$name}();
+            }
+
+            /* @phpstan-ignore-next-line */
+            return new HigherOrderExpectation($this, $this->retrieve($name, $this->value));
+        }
+
+        /* @phpstan-ignore-next-line */
+        return $this->{$name}();
+    }
+
+    /**
+     * Checks if the given expectation method exists.
+     */
+    public static function hasMethod(string $name): bool
+    {
+        return method_exists(self::class, $name)
+            || method_exists(Mixins\Expectation::class, $name)
+            || self::hasExtend($name);
+    }
+
+    /**
+     * Matches any value.
+     */
+    public function any(): Any
+    {
+        return new Any();
+    }
+
+    /**
+     * Asserts that the given expectation target use the given dependencies.
+     *
+     * @param  array<int, string>|string  $targets
+     */
+    public function toUse(array|string $targets): ArchExpectation
+    {
+        return ToUse::make($this, $targets);
+    }
+
+    /**
+     * Asserts that the given expectation target use the "declare(strict_types=1)" declaration.
+     */
+    public function toUseStrictTypes(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => str_contains((string) file_get_contents($object->path), 'declare(strict_types=1);'),
+            'to use strict types',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, '<?php')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target is final.
+     */
+    public function toBeFinal(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && $object->reflectionClass->isFinal(),
+            'to be final',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target is readonly.
+     */
+    public function toBeReadonly(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && $object->reflectionClass->isReadOnly() && assert(true), // @phpstan-ignore-line
+            'to be readonly',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target is trait.
+     */
+    public function toBeTrait(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->isTrait(),
+            'to be trait',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are traits.
+     */
+    public function toBeTraits(): ArchExpectation
+    {
+        return $this->toBeTrait();
+    }
+
+    /**
+     * Asserts that the given expectation target is abstract.
+     */
+    public function toBeAbstract(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->isAbstract(),
+            'to be abstract',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target 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.
+     */
+    public function toBeEnum(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->isEnum(),
+            'to be enum',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are enums.
+     */
+    public function toBeEnums(): ArchExpectation
+    {
+        return $this->toBeEnum();
+    }
+
+    /**
+     * Asserts that the given expectation targets is an class.
+     */
+    public function toBeClass(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => class_exists($object->name) && ! enum_exists($object->name),
+            'to be class',
+            FileLineFinder::where(fn (string $line): bool => true),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are classes.
+     */
+    public function toBeClasses(): ArchExpectation
+    {
+        return $this->toBeClass();
+    }
+
+    /**
+     * Asserts that the given expectation target is interface.
+     */
+    public function toBeInterface(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->isInterface(),
+            'to be interface',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are interfaces.
+     */
+    public function toBeInterfaces(): ArchExpectation
+    {
+        return $this->toBeInterface();
+    }
+
+    /**
+     * Asserts that the given expectation target to be subclass of the given class.
+     *
+     * @param  class-string  $class
+     */
+    public function toExtend(string $class): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $class === $object->reflectionClass->getName() || $object->reflectionClass->isSubclassOf($class),
+            sprintf("to extend '%s'", $class),
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to be have a parent class.
+     */
+    public function toExtendNothing(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->getParentClass() === false,
+            'to extend nothing',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to not implement any interfaces.
+     */
+    public function toImplementNothing(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->getInterfaceNames() === [],
+            'to implement nothing',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to only implement the given interfaces.
+     *
+     * @param  array<int, class-string>|class-string  $interfaces
+     */
+    public function toOnlyImplement(array|string $interfaces): ArchExpectation
+    {
+        $interfaces = is_array($interfaces) ? $interfaces : [$interfaces];
+
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => count($interfaces) === count($object->reflectionClass->getInterfaceNames())
+                && array_diff($interfaces, $object->reflectionClass->getInterfaceNames()) === [],
+            "to only implement '".implode("', '", $interfaces)."'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to have the given prefix.
+     */
+    public function toHavePrefix(string $prefix): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => str_starts_with($object->reflectionClass->getShortName(), $prefix),
+            "to have prefix '{$prefix}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to have the given suffix.
+     */
+    public function toHaveSuffix(string $suffix): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => str_ends_with($object->reflectionClass->getName(), $suffix),
+            "to have suffix '{$suffix}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to implement the given interfaces.
+     *
+     * @param  array<int, class-string>|class-string  $interfaces
+     */
+    public function toImplement(array|string $interfaces): ArchExpectation
+    {
+        $interfaces = is_array($interfaces) ? $interfaces : [$interfaces];
+
+        return Targeted::make(
+            $this,
+            function (ObjectDescription $object) use ($interfaces): bool {
+                foreach ($interfaces as $interface) {
+                    if (! $object->reflectionClass->implementsInterface($interface)) {
+                        return false;
+                    }
+                }
+
+                return true;
+            },
+            "to implement '".implode("', '", $interfaces)."'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target "only" use on the given dependencies.
+     *
+     * @param  array<int, string>|string  $targets
+     */
+    public function toOnlyUse(array|string $targets): ArchExpectation
+    {
+        return ToOnlyUse::make($this, $targets);
+    }
+
+    /**
+     * Asserts that the given expectation target does not use any dependencies.
+     */
+    public function toUseNothing(): ArchExpectation
+    {
+        return ToUseNothing::make($this);
+    }
+
+    public function toBeUsed(): never
+    {
+        throw InvalidExpectation::fromMethods(['toBeUsed']);
+    }
+
+    /**
+     * Asserts that the given expectation dependency is used by the given targets.
+     *
+     * @param  array<int, string>|string  $targets
+     */
+    public function toBeUsedIn(array|string $targets): ArchExpectation
+    {
+        return ToBeUsedIn::make($this, $targets);
+    }
+
+    /**
+     * Asserts that the given expectation dependency is "only" used by the given targets.
+     *
+     * @param  array<int, string>|string  $targets
+     */
+    public function toOnlyBeUsedIn(array|string $targets): ArchExpectation
+    {
+        return ToOnlyBeUsedIn::make($this, $targets);
+    }
+
+    /**
+     * Asserts that the given expectation dependency is not used.
+     */
+    public function toBeUsedInNothing(): ArchExpectation
+    {
+        return ToBeUsedInNothing::make($this);
+    }
+
+    /**
+     * Asserts that the given expectation dependency is an invokable class.
+     */
+    public function toBeInvokable(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->hasMethod('__invoke'),
+            'to be invokable',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
+        );
+    }
+
+    /**
+     * Asserts that the given expectation is iterable and contains snake_case keys.
+     *
+     * @return self<TValue>
+     */
+    public function toHaveSnakeCaseKeys(string $message = ''): self
+    {
+        if (! is_iterable($this->value)) {
+            InvalidExpectationValue::expected('iterable');
+        }
+
+        foreach ($this->value as $k => $item) {
+            if (is_string($k)) {
+                $this->and($k)->toBeSnakeCase($message);
+            }
+
+            if (is_array($item)) {
+                $this->and($item)->toHaveSnakeCaseKeys($message);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the given expectation is iterable and contains kebab-case keys.
+     *
+     * @return self<TValue>
+     */
+    public function toHaveKebabCaseKeys(string $message = ''): self
+    {
+        if (! is_iterable($this->value)) {
+            InvalidExpectationValue::expected('iterable');
+        }
+
+        foreach ($this->value as $k => $item) {
+            if (is_string($k)) {
+                $this->and($k)->toBeKebabCase($message);
+            }
+
+            if (is_array($item)) {
+                $this->and($item)->toHaveKebabCaseKeys($message);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the given expectation is iterable and contains camelCase keys.
+     *
+     * @return self<TValue>
+     */
+    public function toHaveCamelCaseKeys(string $message = ''): self
+    {
+        if (! is_iterable($this->value)) {
+            InvalidExpectationValue::expected('iterable');
+        }
+
+        foreach ($this->value as $k => $item) {
+            if (is_string($k)) {
+                $this->and($k)->toBeCamelCase($message);
+            }
+
+            if (is_array($item)) {
+                $this->and($item)->toHaveCamelCaseKeys($message);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the given expectation is iterable and contains StudlyCase keys.
+     *
+     * @return self<TValue>
+     */
+    public function toHaveStudlyCaseKeys(string $message = ''): self
+    {
+        if (! is_iterable($this->value)) {
+            InvalidExpectationValue::expected('iterable');
+        }
+
+        foreach ($this->value as $k => $item) {
+            if (is_string($k)) {
+                $this->and($k)->toBeStudlyCase($message);
+            }
+
+            if (is_array($item)) {
+                $this->and($item)->toHaveStudlyCaseKeys($message);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the given expectation target to have the given attribute.
+     *
+     * @param  class-string<Attribute>  $attribute
+     */
+    public function toHaveAttribute(string $attribute): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->getAttributes($attribute) !== [],
+            "to have attribute '{$attribute}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+}

src/Expectations/EachExpectation.php

@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Expectations;
+
+use Pest\Expectation;
+
+use function expect;
+
+/**
+ * @internal
+ *
+ * @template TValue
+ *
+ * @mixin Expectation<TValue>
+ */
+final class EachExpectation
+{
+    private bool $opposite = false;
+
+    /**
+     * Creates an expectation on each item of the iterable "value".
+     *
+     * @param  Expectation<TValue>  $original
+     */
+    public function __construct(private readonly Expectation $original)
+    {
+    }
+
+    /**
+     * Creates a new expectation.
+     *
+     * @template TAndValue
+     *
+     * @param  TAndValue  $value
+     * @return Expectation<TAndValue>
+     */
+    public function and(mixed $value): Expectation
+    {
+        return $this->original->and($value);
+    }
+
+    /**
+     * Creates the opposite expectation for the value.
+     *
+     * @return self<TValue>
+     */
+    public function not(): self
+    {
+        $this->opposite = true;
+
+        return $this;
+    }
+
+    /**
+     * Dynamically calls methods on the class with the given arguments on each item.
+     *
+     * @param  array<int|string, mixed>  $arguments
+     * @return self<TValue>
+     */
+    public function __call(string $name, array $arguments): self
+    {
+        foreach ($this->original->value as $item) {
+            /* @phpstan-ignore-next-line */
+            $this->opposite ? expect($item)->not()->$name(...$arguments) : expect($item)->$name(...$arguments);
+        }
+
+        $this->opposite = false;
+
+        return $this;
+    }
+
+    /**
+     * Dynamically calls methods on the class without any arguments on each item.
+     *
+     * @return self<TValue>
+     */
+    public function __get(string $name): self
+    {
+        /* @phpstan-ignore-next-line */
+        return $this->$name();
+    }
+}