chore: version

[Fix] Pass test dir to worker

.github/ISSUE_TEMPLATE/bug_report.yml

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

.github/PULL_REQUEST_TEMPLATE.md

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

.github/workflows/integration-tests.yml

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

.github/workflows/static.yml

@@ -2,10 +2,15 @@ name: Static Analysis
 
 on:
   push:
+    branches: [5.x]
   pull_request:
   schedule:
     - cron: '0 0 * * *'
 
+concurrency:
+  group: static-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 jobs:
   static:
     if: github.event_name != 'schedule' || github.repository == 'pestphp/pest'
@@ -13,25 +18,47 @@ jobs:
 
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: true
       matrix:
         dependency-version: [prefer-lowest, prefer-stable]
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v6
 
     - name: Setup PHP
       uses: shivammathur/setup-php@v2
       with:
-        php-version: 8.1
+        php-version: 8.4
         tools: composer:v2
         coverage: none
+        extensions: sockets
+
+    - name: Get Composer cache directory
+      id: composer-cache
+      shell: bash
+      run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
+
+    - name: Cache Composer dependencies
+      uses: actions/cache@v4
+      with:
+        path: ${{ steps.composer-cache.outputs.dir }}
+        key: static-php-8.4-${{ matrix.dependency-version }}-composer-${{ hashFiles('**/composer.json') }}
+        restore-keys: |
+          static-php-8.4-${{ matrix.dependency-version }}-composer-
+          static-php-8.4-composer-
 
     - name: Install Dependencies
-      run: composer update --prefer-stable --no-interaction --no-progress --ansi
+      run: composer update --${{ matrix.dependency-version }} --no-interaction --no-progress --ansi
 
-    - name: Types
-      run: composer test:types
+    - name: Profanity Check
+      run: composer test:profanity
+
+    - name: Type Check
+      run: composer test:type:check
+
+    - name: Type Coverage
+      run: composer test:type:coverage
 
     - name: Refacto
       run: composer test:refacto

.github/workflows/tests.yml

@@ -2,26 +2,31 @@ name: Tests
 
 on:
   push:
+    branches: [5.x]
   pull_request:
-  schedule:
-    - cron: '0 0 * * *'
 
+concurrency:
+  group: tests-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
 
 jobs:
-  ci:
+  tests:
     if: github.event_name != 'schedule' || github.repository == 'pestphp/pest'
+
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: true
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-        php: ['8.1', '8.2']
-        dependency-version: [prefer-lowest, prefer-stable]
+        os: [ubuntu-latest, macos-latest] # windows-latest
+        symfony: ['8.0']
+        php: ['8.4', '8.5']
+        dependency_version: [prefer-stable]
 
-    name: PHP ${{ matrix.php }} - ${{ matrix.os }} - ${{ matrix.dependency-version }}
+    name: PHP ${{ matrix.php }} - Symfony ^${{ matrix.symfony }} - ${{ matrix.os }} - ${{ matrix.dependency_version }}
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v6
 
     - name: Setup PHP
       uses: shivammathur/setup-php@v2
@@ -29,6 +34,21 @@ jobs:
         php-version: ${{ matrix.php }}
         tools: composer:v2
         coverage: none
+        extensions: sockets
+
+    - name: Get Composer cache directory
+      id: composer-cache
+      shell: bash
+      run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
+
+    - name: Cache Composer dependencies
+      uses: actions/cache@v4
+      with:
+        path: ${{ steps.composer-cache.outputs.dir }}
+        key: ${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-${{ hashFiles('**/composer.json') }}
+        restore-keys: |
+          ${{ matrix.os }}-php-${{ matrix.php }}-symfony-${{ matrix.symfony }}-composer-
+          ${{ matrix.os }}-php-${{ matrix.php }}-composer-
 
     - name: Setup Problem Matches
       run: |
@@ -36,11 +56,14 @@ jobs:
         echo "::add-matcher::${{ runner.tool_cache }}/phpunit.json"
 
     - name: Install PHP dependencies
-      run: composer update --${{ matrix.dependency-version }} --no-interaction --no-progress --ansi
+      shell: bash
+      run: composer update --${{ matrix.dependency_version }} --no-interaction --no-progress --ansi --with="symfony/console:^${{ matrix.symfony }}"
 
     - name: Unit Tests
       run: composer test:unit
 
-    - name: Unit Tests in Parallel
+    - name: Parallel Tests
       run: composer test:parallel
 
+    - name: Integration Tests
+      run: composer test:integration

.gitignore

@@ -12,3 +12,5 @@ coverage.xml
 *.swp
 *.swo
 .vscode/
+.STREAM.md
+

CHANGELOG.md

@@ -1,113 +0,0 @@
-# Release Notes for 2.x
-
-## Unreleased
-
-## [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

@@ -42,7 +42,7 @@ composer test
 
 Check types:
 ```bash
-composer test:types
+composer test:type:check
 ```
 
 Unit tests:
@@ -69,7 +69,7 @@ If you want to check things work against a specific version of PHP, you may incl
 the `PHP` build argument when building the image:
 
 ```bash
-make build ARGS="--build-arg PHP=8.2"
+make build ARGS="--build-arg PHP=8.3"
 ```
 
 The default PHP version will always be the lowest version of PHP supported by Pest.

Makefile

@@ -1,14 +0,0 @@
-# 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,40 +1,53 @@
 <p align="center">
-    <img src="https://raw.githubusercontent.com/pestphp/art/master/v2/banner.png" width="600" alt="PEST">
+    <img src="https://raw.githubusercontent.com/pestphp/art/master/v4/social.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/actions/workflow/status/pestphp/pest/tests.yml?branch=2.x&label=Tests%202.x"></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=4.x&label=Tests%204.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>
+        <a href="https://whyphp.dev"><img src="https://img.shields.io/badge/Why_PHP-in_2026-7A86E8?style=flat-square&labelColor=18181b" alt="Why PHP in 2026"></a>
     </p>
 </p>
 
 ------
+
+> Pest v4 Now Available: **[Read the announcement »](https://pestphp.com/docs/pest-v4-is-here-now-with-browser-testing)**.
+
 **Pest** is an elegant PHP testing Framework with a focus on simplicity, meticulously designed to bring back the joy of testing in PHP.
 
 - 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)**
+- Follow the creator Nuno Maduro:
+    - YouTube: **[youtube.com/@nunomaduro](https://youtube.com/@nunomaduro)** — Videos every week
+    - Twitch: **[twitch.tv/nunomaduro](https://twitch.tv/nunomaduro)** — Live coding on Mondays, Wednesdays, and Fridays at 9PM UTC
+    - Twitter / X: **[x.com/enunomaduro](https://x.com/enunomaduro)**
+    - LinkedIn: **[linkedin.com/in/nunomaduro](https://www.linkedin.com/in/nunomaduro)**
+    - Instagram: **[instagram.com/enunomaduro](https://www.instagram.com/enunomaduro)**
+    - Tiktok: **[tiktok.com/@enunomaduro](https://www.tiktok.com/@enunomaduro)**
 
 ## 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/)**
+- **[CodeRabbit](https://coderabbit.ai/?ref=pestphp)**
+- **[Devin](https://devin.ai/?ref=nunomaduro)**
+- **[Mailtrap](https://l.rw.rw/pestphp)**
+- **[Tighten](https://tighten.com/?ref=nunomaduro)**
+- **[Redberry](https://redberry.international/laravel-development/?utm_source=pest&utm_medium=banner&utm_campaign=pest_sponsorship)**
+
+### Gold Sponsors
+
+- **[CMS Max](https://cmsmax.com/?ref=pestphp)**
 
 ### Premium Sponsors
 
-- [Akaunting](https://akaunting.com)
-- [Codecourse](https://codecourse.com/)
-- [Laracasts](https://laracasts.com/)
-- [Localazy](https://localazy.com)
-- [Hyvor](https://hyvor.com/)
-- [Fathom Analytics](https://usefathom.com/)
-- [Meema](https://meema.io)
-- [Zapiet](https://www.zapiet.com)
+- [Zapiet](https://zapiet.com/?ref=pestphp)
+- [Load Forge](https://loadforge.com/?ref=pestphp)
+- [Route4Me](https://route4me.com/pt?ref=pestphp)
+- [Nerdify](https://getnerdify.com/?ref=pestphp)
+- [Akaunting](https://akaunting.com/?ref=pestphp)
+- [TestMu AI](https://www.testmuai.com/?utm_medium=sponsor&utm_source=pest)
 
 Pest is an open-sourced software licensed under the **[MIT license](https://opensource.org/licenses/MIT)**.

RELEASE.md

@@ -2,13 +2,13 @@
 
 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.**
+> **For Pest v3 you should use the `3.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
+- Clear your local repository with: `git add . && git reset --hard && git checkout 4.x`
+- On the GitHub repository, check the contents of [github.com/pestphp/pest/compare/{latest_version}...4.x](https://github.com/pestphp/pest/compare/{latest_version}...4.x)
 - Update the version number in [src/Pest.php](src/Pest.php)
 - Run the tests locally using: `composer test`
-- Commit the CHANGELOG and Pest file with the message: `git commit -m "release: vX.X.X"`
+- Commit the Pest file with the message: `git commit -m "release: vX.X.X"`
 - Push the changes to GitHub
 - Check that the CI is passing as expected: [github.com/pestphp/pest/actions](https://github.com/pestphp/pest/actions)
 - Tag and push the tag with `git tag vX.X.X && git push --tags`

bin/pest

@@ -1,9 +1,15 @@
 #!/usr/bin/env php
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 use Pest\Kernel;
 use Pest\Panic;
 use Pest\TestCaseFilters\GitDirtyTestCaseFilter;
+use Pest\TestCaseMethodFilters\AssigneeTestCaseFilter;
+use Pest\TestCaseMethodFilters\IssueTestCaseFilter;
+use Pest\TestCaseMethodFilters\NotesTestCaseFilter;
+use Pest\TestCaseMethodFilters\PrTestCaseFilter;
 use Pest\TestCaseMethodFilters\TodoTestCaseFilter;
 use Pest\TestSuite;
 use Symfony\Component\Console\Input\ArgvInput;
@@ -13,39 +19,102 @@ use Symfony\Component\Console\Output\ConsoleOutput;
     // Ensures Collision's Printer is registered.
     $_SERVER['COLLISION_PRINTER'] = 'DefaultPrinter';
 
-    $args = $_SERVER['argv'];
+    $arguments = $originalArguments = $_SERVER['argv'];
 
     $dirty = false;
     $todo = false;
+    $notes = false;
+
+    foreach ($arguments as $key => $value) {
 
-    foreach ($args as $key => $value) {
         if ($value === '--compact') {
             $_SERVER['COLLISION_PRINTER_COMPACT'] = 'true';
-            unset($args[$key]);
+            unset($arguments[$key]);
         }
 
         if ($value === '--profile') {
             $_SERVER['COLLISION_PRINTER_PROFILE'] = 'true';
-            unset($args[$key]);
+            unset($arguments[$key]);
         }
 
-        if (str_contains($value, '--test-directory')) {
-            unset($args[$key]);
+        if (str_contains($value, '--test-directory=')) {
+            unset($arguments[$key]);
+        } elseif ($value === '--test-directory') {
+            unset($arguments[$key]);
+
+            if (isset($arguments[$key + 1])) {
+                unset($arguments[$key + 1]);
+            }
         }
 
         if ($value === '--dirty') {
             $dirty = true;
-            unset($args[$key]);
+            unset($arguments[$key]);
         }
 
-        if ($value === '--todos') {
+        if (in_array($value, ['--todo', '--todos'], true)) {
             $todo = true;
-            unset($args[$key]);
+            unset($arguments[$key]);
+        }
+
+        if ($value === '--notes') {
+            $notes = true;
+            unset($arguments[$key]);
+        }
+
+        if (str_contains($value, '--assignee=')) {
+            unset($arguments[$key]);
+        } elseif ($value === '--assignee') {
+            unset($arguments[$key]);
+
+            if (isset($arguments[$key + 1])) {
+                unset($arguments[$key + 1]);
+            }
+        }
+
+        if (str_contains($value, '--issue=')) {
+            unset($arguments[$key]);
+        } elseif ($value === '--issue') {
+            unset($arguments[$key]);
+
+            if (isset($arguments[$key + 1])) {
+                unset($arguments[$key + 1]);
+            }
+        }
+
+        if (str_contains($value, '--ticket=')) {
+            unset($arguments[$key]);
+        } elseif ($value === '--ticket') {
+            unset($arguments[$key]);
+
+            if (isset($arguments[$key + 1])) {
+                unset($arguments[$key + 1]);
+            }
+        }
+
+        if (str_contains($value, '--pr=')) {
+            unset($arguments[$key]);
+        } elseif ($value === '--pr') {
+            unset($arguments[$key]);
+
+            if (isset($arguments[$key + 1])) {
+                unset($arguments[$key + 1]);
+            }
+        }
+
+        if (str_contains($value, '--pull-request=')) {
+            unset($arguments[$key]);
+        } elseif ($value === '--pull-request') {
+            unset($arguments[$key]);
+
+            if (isset($arguments[$key + 1])) {
+                unset($arguments[$key + 1]);
+            }
         }
 
         if (str_contains($value, '--teamcity')) {
-            unset($args[$key]);
-            $args[] = '--no-output';
+            unset($arguments[$key]);
+            $arguments[] = '--no-output';
             unset($_SERVER['COLLISION_PRINTER']);
         }
     }
@@ -66,7 +135,7 @@ use Symfony\Component\Console\Output\ConsoleOutput;
 
     // Get $rootPath based on $autoloadPath
     $rootPath = dirname($autoloadPath, 2);
-    $input = new ArgvInput();
+    $input = new ArgvInput;
 
     $testSuite = TestSuite::getInstance(
         $rootPath,
@@ -78,7 +147,31 @@ use Symfony\Component\Console\Output\ConsoleOutput;
     }
 
     if ($todo) {
-        $testSuite->tests->addTestCaseMethodFilter(new TodoTestCaseFilter());
+        $testSuite->tests->addTestCaseMethodFilter(new TodoTestCaseFilter);
+    }
+
+    if ($notes) {
+        $testSuite->tests->addTestCaseMethodFilter(new NotesTestCaseFilter);
+    }
+
+    if ($assignee = $input->getParameterOption('--assignee')) {
+        $testSuite->tests->addTestCaseMethodFilter(new AssigneeTestCaseFilter((string) $assignee));
+    }
+
+    if ($issue = $input->getParameterOption('--issue')) {
+        $testSuite->tests->addTestCaseMethodFilter(new IssueTestCaseFilter((int) $issue));
+    }
+
+    if ($issue = $input->getParameterOption('--ticket')) {
+        $testSuite->tests->addTestCaseMethodFilter(new IssueTestCaseFilter((int) $issue));
+    }
+
+    if ($pr = $input->getParameterOption('--pr')) {
+        $testSuite->tests->addTestCaseMethodFilter(new PrTestCaseFilter((int) $pr));
+    }
+
+    if ($pr = $input->getParameterOption('--pull-request')) {
+        $testSuite->tests->addTestCaseMethodFilter(new PrTestCaseFilter((int) $pr));
     }
 
     $isDecorated = $input->getParameterOption('--colors', 'always') !== 'never';
@@ -88,9 +181,9 @@ use Symfony\Component\Console\Output\ConsoleOutput;
     try {
         $kernel = Kernel::boot($testSuite, $input, $output);
 
-        $result = $kernel->handle($args);
+        $result = $kernel->handle($originalArguments, $arguments);
 
-        $kernel->shutdown();
+        $kernel->terminate();
     } catch (Throwable|Error $e) {
         Panic::with($e);
     }

bin/worker.php

@@ -12,7 +12,7 @@ use Symfony\Component\Console\Output\ConsoleOutput;
 use Symfony\Component\Console\Output\OutputInterface;
 
 $bootPest = (static function (): void {
-    $workerArgv = new ArgvInput();
+    $workerArgv = new ArgvInput;
 
     $rootPath = dirname(PHPUNIT_COMPOSER_INSTALL, 2);
     $testSuite = TestSuite::getInstance($rootPath, $workerArgv->getParameterOption(
@@ -20,7 +20,7 @@ $bootPest = (static function (): void {
         'tests'
     ));
 
-    $input = new ArgvInput();
+    $input = new ArgvInput;
 
     $output = new ConsoleOutput(OutputInterface::VERBOSITY_NORMAL, true);
 
@@ -31,10 +31,14 @@ $bootPest = (static function (): void {
     $getopt = getopt('', [
         'status-file:',
         'progress-file:',
-        'testresult-file:',
+        'unexpected-output-file:',
+        'test-result-file:',
+        'result-cache-file:',
         'teamcity-file:',
         'testdox-file:',
         'testdox-color',
+        'testdox-columns:',
+        'testdox-summary',
         'phpunit-argv:',
     ]);
 
@@ -45,6 +49,7 @@ $bootPest = (static function (): void {
     ];
 
     foreach ($composerAutoloadFiles as $file) {
+
         if (file_exists($file)) {
             require_once $file;
             define('PHPUNIT_COMPOSER_INSTALL', $file);
@@ -58,7 +63,9 @@ $bootPest = (static function (): void {
     assert(is_resource($statusFile));
 
     assert(isset($getopt['progress-file']) && is_string($getopt['progress-file']));
-    assert(isset($getopt['testresult-file']) && is_string($getopt['testresult-file']));
+    assert(isset($getopt['unexpected-output-file']) && is_string($getopt['unexpected-output-file']));
+    assert(isset($getopt['test-result-file']) && is_string($getopt['test-result-file']));
+    assert(! isset($getopt['result-cache-file']) || is_string($getopt['result-cache-file']));
     assert(! isset($getopt['teamcity-file']) || is_string($getopt['teamcity-file']));
     assert(! isset($getopt['testdox-file']) || is_string($getopt['testdox-file']));
 
@@ -73,10 +80,13 @@ $bootPest = (static function (): void {
     $application = new ApplicationForWrapperWorker(
         $phpunitArgv,
         $getopt['progress-file'],
-        $getopt['testresult-file'],
+        $getopt['unexpected-output-file'],
+        $getopt['test-result-file'],
+        $getopt['result-cache-file'] ?? null,
         $getopt['teamcity-file'] ?? null,
         $getopt['testdox-file'] ?? null,
         isset($getopt['testdox-color']),
+        (int) ($getopt['testdox-columns'] ?? null),
     );
 
     while (true) {
@@ -88,10 +98,10 @@ $bootPest = (static function (): void {
         $testPath = fgets(STDIN);
         if ($testPath === false || $testPath === WrapperWorker::COMMAND_EXIT) {
             $application->end();
-
             exit;
         }
 
+        // It must be a 1 byte string to ensure filesize() is equal to the number of tests executed
         $exitCode = $application->runTest(realpath(trim($testPath)));
 
         fwrite($statusFile, (string) $exitCode);

composer.json

@@ -1,6 +1,6 @@
 {
     "name": "pestphp/pest",
-    "description": "An elegant PHP Testing Framework.",
+    "description": "The elegant PHP Testing Framework.",
     "keywords": [
         "php",
         "framework",
@@ -17,17 +17,22 @@
         }
     ],
     "require": {
-        "php": "^8.1.0",
-        "brianium/paratest": "^7.1.4",
-        "nunomaduro/collision": "^7.5.2",
-        "nunomaduro/termwind": "^1.15.1",
-        "pestphp/pest-plugin": "^2.0.1",
-        "pestphp/pest-plugin-arch": "^2.1.2",
-        "phpunit/phpunit": "^10.2.0"
+        "php": "^8.4",
+        "brianium/paratest": "^7.19.0",
+        "nunomaduro/collision": "^8.9.1",
+        "nunomaduro/termwind": "^2.4.0",
+        "pestphp/pest-plugin": "^5.0.0",
+        "pestphp/pest-plugin-arch": "^5.0.0",
+        "pestphp/pest-plugin-mutate": "^5.0.0",
+        "pestphp/pest-plugin-profanity": "^5.0.0",
+        "phpunit/phpunit": "^13.0.3",
+        "symfony/process": "^8.0.5"
     },
     "conflict": {
-        "webmozart/assert": "<1.11.0",
-        "phpunit/phpunit": ">10.2.0"
+        "filp/whoops": "<2.18.3",
+        "phpunit/phpunit": ">13.0.3",
+        "sebastian/exporter": "<7.0.0",
+        "webmozart/assert": "<1.11.0"
     },
     "autoload": {
         "psr-4": {
@@ -42,6 +47,7 @@
         "psr-4": {
             "Tests\\Fixtures\\Covers\\": "tests/Fixtures/Covers",
             "Tests\\Fixtures\\Inheritance\\": "tests/Fixtures/Inheritance",
+            "Tests\\Fixtures\\Arch\\": "tests/Fixtures/Arch",
             "Tests\\": "tests/PHPUnit/"
         },
         "files": [
@@ -49,10 +55,13 @@
         ]
     },
     "require-dev": {
-        "pestphp/pest-dev-tools": "^2.9.0",
-        "symfony/process": "^6.3.0"
+        "pestphp/pest-dev-tools": "^5.0.0",
+        "pestphp/pest-plugin-browser": "^5.0.0",
+        "pestphp/pest-plugin-type-coverage": "^5.0.0",
+        "psy/psysh": "^0.12.20"
     },
-    "minimum-stability": "stable",
+    "minimum-stability": "dev",
+    "prefer-stable": true,
     "config": {
         "sort-packages": true,
         "preferred-install": "dist",
@@ -65,19 +74,22 @@
     ],
     "scripts": {
         "refacto": "rector",
-        "lint": "pint",
+        "lint": "pint --parallel",
         "test:refacto": "rector --dry-run",
-        "test:lint": "pint --test",
-        "test:types": "phpstan analyse --ansi --memory-limit=-1 --debug",
-        "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",
+        "test:lint": "pint --parallel --test",
+        "test:profanity": "php bin/pest --profanity --compact",
+        "test:type:check": "phpstan analyse --ansi --memory-limit=-1 --debug",
+        "test:type:coverage": "php -d memory_limit=-1  bin/pest --type-coverage --min=100",
+        "test:unit": "php bin/pest --exclude-group=integration --compact",
+        "test:inline": "php bin/pest --configuration=phpunit.inline.xml",
+        "test:parallel": "php bin/pest --exclude-group=integration --parallel --processes=3",
+        "test:integration": "php bin/pest --group=integration -v",
+        "update:snapshots": "REBUILD_SNAPSHOTS=true php bin/pest --update-snapshots",
         "test": [
             "@test:refacto",
             "@test:lint",
-            "@test:types",
+            "@test:type:check",
+            "@test:type:coverage",
             "@test:unit",
             "@test:parallel",
             "@test:integration"
@@ -86,6 +98,8 @@
     "extra": {
         "pest": {
             "plugins": [
+                "Pest\\Mutate\\Plugins\\Mutate",
+                "Pest\\Plugins\\Configuration",
                 "Pest\\Plugins\\Bail",
                 "Pest\\Plugins\\Cache",
                 "Pest\\Plugins\\Coverage",
@@ -98,9 +112,17 @@
                 "Pest\\Plugins\\ProcessIsolation",
                 "Pest\\Plugins\\Profile",
                 "Pest\\Plugins\\Retry",
+                "Pest\\Plugins\\Snapshot",
+                "Pest\\Plugins\\Verbose",
                 "Pest\\Plugins\\Version",
+                "Pest\\Plugins\\Shard",
                 "Pest\\Plugins\\Parallel"
             ]
+        },
+        "phpstan": {
+            "includes": [
+                "extension.neon"
+            ]
         }
     }
 }

docker-compose.yml

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

docker/Dockerfile

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

extension.neon

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

overrides/Event/Value/ThrowableBuilder.php

@@ -1,5 +1,37 @@
 <?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);
 
 /*
@@ -20,9 +52,11 @@ use PHPUnit\Util\Filter;
 use PHPUnit\Util\ThrowableToStringMapper;
 
 /**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ *
  * @internal This class is not covered by the backward compatibility promise for PHPUnit
  */
-final class ThrowableBuilder
+final readonly class ThrowableBuilder
 {
     /**
      * @throws Exception
@@ -36,7 +70,7 @@ final class ThrowableBuilder
             $previous = self::from($previous);
         }
 
-        $trace = Filter::getFilteredStacktrace($t);
+        $trace = Filter::stackTraceFromThrowableAsString($t);
 
         if ($t instanceof RenderableOnCollisionEditor && $frame = $t->toCollisionEditor()) {
             $file = $frame->getFile();
@@ -50,7 +84,7 @@ final class ThrowableBuilder
             $t->getMessage(),
             ThrowableToStringMapper::map($t),
             $trace,
-            $previous
+            $previous,
         );
     }
 }

overrides/Logging/JUnit/JunitXmlLogger.php

@@ -0,0 +1,469 @@
+<?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\Logging\JUnit;
+
+use DOMDocument;
+use DOMElement;
+use PHPUnit\Event\Code\Test;
+use PHPUnit\Event\Code\TestMethod;
+use PHPUnit\Event\EventFacadeIsSealedException;
+use PHPUnit\Event\Facade;
+use PHPUnit\Event\InvalidArgumentException;
+use PHPUnit\Event\Telemetry\HRTime;
+use PHPUnit\Event\Telemetry\Info;
+use PHPUnit\Event\Test\Errored;
+use PHPUnit\Event\Test\Failed;
+use PHPUnit\Event\Test\Finished;
+use PHPUnit\Event\Test\MarkedIncomplete;
+use PHPUnit\Event\Test\PreparationStarted;
+use PHPUnit\Event\Test\Prepared;
+use PHPUnit\Event\Test\PrintedUnexpectedOutput;
+use PHPUnit\Event\Test\Skipped;
+use PHPUnit\Event\TestSuite\Started;
+use PHPUnit\Event\UnknownSubscriberTypeException;
+use PHPUnit\TextUI\Output\Printer;
+use PHPUnit\Util\Xml;
+
+use function assert;
+use function basename;
+use function is_int;
+use function sprintf;
+use function str_replace;
+use function trim;
+
+/**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ *
+ * @internal This class is not covered by the backward compatibility promise for PHPUnit
+ */
+final class JunitXmlLogger
+{
+    private readonly Printer $printer;
+
+    private readonly \Pest\Logging\Converter $converter; // pest-added
+
+    private DOMDocument $document;
+
+    private DOMElement $root;
+
+    /**
+     * @var DOMElement[]
+     */
+    private array $testSuites = [];
+
+    /**
+     * @var array<int,int>
+     */
+    private array $testSuiteTests = [0];
+
+    /**
+     * @var array<int,int>
+     */
+    private array $testSuiteAssertions = [0];
+
+    /**
+     * @var array<int,int>
+     */
+    private array $testSuiteErrors = [0];
+
+    /**
+     * @var array<int,int>
+     */
+    private array $testSuiteFailures = [0];
+
+    /**
+     * @var array<int,int>
+     */
+    private array $testSuiteSkipped = [0];
+
+    /**
+     * @var array<int,int>
+     */
+    private array $testSuiteTimes = [0];
+
+    private int $testSuiteLevel = 0;
+
+    private ?DOMElement $currentTestCase = null;
+
+    private ?HRTime $time = null;
+
+    private bool $prepared = false;
+
+    private bool $preparationFailed = false;
+
+    /**
+     * @throws EventFacadeIsSealedException
+     * @throws UnknownSubscriberTypeException
+     */
+    public function __construct(Printer $printer, Facade $facade)
+    {
+        $this->printer = $printer;
+        $this->converter = new \Pest\Logging\Converter(\Pest\Support\Container::getInstance()->get(\Pest\TestSuite::class)->rootPath); // pest-added
+
+        $this->registerSubscribers($facade);
+        $this->createDocument();
+    }
+
+    public function flush(): void
+    {
+        $this->printer->print($this->document->saveXML() ?: '');
+
+        $this->printer->flush();
+    }
+
+    public function testSuiteStarted(Started $event): void
+    {
+        $testSuite = $this->document->createElement('testsuite');
+        $testSuite->setAttribute('name', $this->converter->getTestSuiteName($event->testSuite())); // pest-changed
+
+        if ($event->testSuite()->isForTestClass()) {
+            $testSuite->setAttribute('file', $this->converter->getTestSuiteLocation($event->testSuite()) ?? ''); // pest-changed
+        }
+
+        if ($this->testSuiteLevel > 0) {
+            $this->testSuites[$this->testSuiteLevel]->appendChild($testSuite);
+        } else {
+            $this->root->appendChild($testSuite);
+        }
+
+        $this->testSuiteLevel++;
+        $this->testSuites[$this->testSuiteLevel] = $testSuite;
+        $this->testSuiteTests[$this->testSuiteLevel] = 0;
+        $this->testSuiteAssertions[$this->testSuiteLevel] = 0;
+        $this->testSuiteErrors[$this->testSuiteLevel] = 0;
+        $this->testSuiteFailures[$this->testSuiteLevel] = 0;
+        $this->testSuiteSkipped[$this->testSuiteLevel] = 0;
+        $this->testSuiteTimes[$this->testSuiteLevel] = 0;
+    }
+
+    public function testSuiteFinished(): void
+    {
+        $this->testSuites[$this->testSuiteLevel]->setAttribute(
+            'tests',
+            (string) $this->testSuiteTests[$this->testSuiteLevel],
+        );
+
+        $this->testSuites[$this->testSuiteLevel]->setAttribute(
+            'assertions',
+            (string) $this->testSuiteAssertions[$this->testSuiteLevel],
+        );
+
+        $this->testSuites[$this->testSuiteLevel]->setAttribute(
+            'errors',
+            (string) $this->testSuiteErrors[$this->testSuiteLevel],
+        );
+
+        $this->testSuites[$this->testSuiteLevel]->setAttribute(
+            'failures',
+            (string) $this->testSuiteFailures[$this->testSuiteLevel],
+        );
+
+        $this->testSuites[$this->testSuiteLevel]->setAttribute(
+            'skipped',
+            (string) $this->testSuiteSkipped[$this->testSuiteLevel],
+        );
+
+        $this->testSuites[$this->testSuiteLevel]->setAttribute(
+            'time',
+            sprintf('%F', $this->testSuiteTimes[$this->testSuiteLevel]),
+        );
+
+        if ($this->testSuiteLevel > 1) {
+            $this->testSuiteTests[$this->testSuiteLevel - 1] += $this->testSuiteTests[$this->testSuiteLevel];
+            $this->testSuiteAssertions[$this->testSuiteLevel - 1] += $this->testSuiteAssertions[$this->testSuiteLevel];
+            $this->testSuiteErrors[$this->testSuiteLevel - 1] += $this->testSuiteErrors[$this->testSuiteLevel];
+            $this->testSuiteFailures[$this->testSuiteLevel - 1] += $this->testSuiteFailures[$this->testSuiteLevel];
+            $this->testSuiteSkipped[$this->testSuiteLevel - 1] += $this->testSuiteSkipped[$this->testSuiteLevel];
+            $this->testSuiteTimes[$this->testSuiteLevel - 1] += $this->testSuiteTimes[$this->testSuiteLevel];
+        }
+
+        $this->testSuiteLevel--;
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public function testPreparationStarted(PreparationStarted $event): void
+    {
+        $this->createTestCase($event);
+    }
+
+    public function testPreparationFailed(): void
+    {
+        $this->preparationFailed = true;
+    }
+
+    public function testPrepared(): void
+    {
+        $this->prepared = true;
+    }
+
+    public function testPrintedUnexpectedOutput(PrintedUnexpectedOutput $event): void
+    {
+        assert($this->currentTestCase !== null);
+
+        $systemOut = $this->document->createElement(
+            'system-out',
+            Xml::prepareString($event->output()),
+        );
+
+        $this->currentTestCase->appendChild($systemOut);
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public function testFinished(Finished $event): void
+    {
+        if (! $this->prepared || $this->preparationFailed) {
+            return;
+        }
+
+        $this->handleFinish($event->telemetryInfo(), $event->numberOfAssertionsPerformed());
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public function testMarkedIncomplete(MarkedIncomplete $event): void
+    {
+        $this->handleIncompleteOrSkipped($event);
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public function testSkipped(Skipped $event): void
+    {
+        $this->handleIncompleteOrSkipped($event);
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public function testErrored(Errored $event): void
+    {
+        $this->handleFault($event, 'error');
+
+        $this->testSuiteErrors[$this->testSuiteLevel]++;
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public function testFailed(Failed $event): void
+    {
+        $this->handleFault($event, 'failure');
+
+        $this->testSuiteFailures[$this->testSuiteLevel]++;
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    private function handleFinish(Info $telemetryInfo, int $numberOfAssertionsPerformed): void
+    {
+        assert($this->currentTestCase !== null);
+        assert($this->time !== null);
+
+        $time = $telemetryInfo->time()->duration($this->time)->asFloat();
+
+        $this->testSuiteAssertions[$this->testSuiteLevel] += $numberOfAssertionsPerformed;
+
+        $this->currentTestCase->setAttribute(
+            'assertions',
+            (string) $numberOfAssertionsPerformed,
+        );
+
+        $this->currentTestCase->setAttribute(
+            'time',
+            sprintf('%F', $time),
+        );
+
+        $this->testSuites[$this->testSuiteLevel]->appendChild(
+            $this->currentTestCase,
+        );
+
+        $this->testSuiteTests[$this->testSuiteLevel]++;
+        $this->testSuiteTimes[$this->testSuiteLevel] += $time;
+
+        $this->currentTestCase = null;
+        $this->time = null;
+        $this->prepared = false;
+    }
+
+    /**
+     * @throws EventFacadeIsSealedException
+     * @throws UnknownSubscriberTypeException
+     */
+    private function registerSubscribers(Facade $facade): void
+    {
+        $facade->registerSubscribers(
+            new TestSuiteStartedSubscriber($this),
+            new TestSuiteFinishedSubscriber($this),
+            new TestPreparationStartedSubscriber($this),
+            new TestPreparationFailedSubscriber($this),
+            new TestPreparedSubscriber($this),
+            new TestPrintedUnexpectedOutputSubscriber($this),
+            new TestFinishedSubscriber($this),
+            new TestErroredSubscriber($this),
+            new TestFailedSubscriber($this),
+            new TestMarkedIncompleteSubscriber($this),
+            new TestSkippedSubscriber($this),
+            new TestRunnerExecutionFinishedSubscriber($this),
+        );
+    }
+
+    private function createDocument(): void
+    {
+        $this->document = new DOMDocument('1.0', 'UTF-8');
+        $this->document->formatOutput = true;
+
+        $this->root = $this->document->createElement('testsuites');
+        $this->document->appendChild($this->root);
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    private function handleFault(Errored|Failed $event, string $type): void
+    {
+        if (! $this->prepared) {
+            $this->createTestCase($event);
+        }
+
+        assert($this->currentTestCase !== null);
+
+        $buffer = $this->converter->getTestCaseMethodName($event->test()); // pest-changed
+
+        $throwable = $event->throwable();
+        $buffer .= trim(
+            $this->converter->getExceptionMessage($throwable).PHP_EOL. // pest-changed
+            $this->converter->getExceptionDetails($throwable), // pest-changed
+        );
+
+        $fault = $this->document->createElement(
+            $type,
+            Xml::prepareString($buffer),
+        );
+
+        $fault->setAttribute('type', $throwable->className());
+
+        $this->currentTestCase->appendChild($fault);
+
+        if (! $this->prepared) {
+            $this->handleFinish($event->telemetryInfo(), 0);
+        }
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    private function handleIncompleteOrSkipped(MarkedIncomplete|Skipped $event): void
+    {
+        if (! $this->prepared) {
+            $this->createTestCase($event);
+        }
+
+        assert($this->currentTestCase !== null);
+
+        $skipped = $this->document->createElement('skipped');
+
+        $this->currentTestCase->appendChild($skipped);
+
+        $this->testSuiteSkipped[$this->testSuiteLevel]++;
+
+        if (! $this->prepared) {
+            $this->handleFinish($event->telemetryInfo(), 0);
+        }
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    private function testAsString(Test $test): string
+    {
+        if ($test->isPhpt()) {
+            return basename($test->file());
+        }
+
+        assert($test instanceof TestMethod);
+
+        return sprintf(
+            '%s::%s%s',
+            $test->className(),
+            $this->name($test),
+            PHP_EOL,
+        );
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    private function name(Test $test): string
+    {
+        if ($test->isPhpt()) {
+            return basename($test->file());
+        }
+
+        assert($test instanceof TestMethod);
+
+        if (! $test->testData()->hasDataFromDataProvider()) {
+            return $test->methodName();
+        }
+
+        $dataSetName = $test->testData()->dataFromDataProvider()->dataSetName();
+
+        if (is_int($dataSetName)) {
+            return sprintf(
+                '%s with data set #%d',
+                $test->methodName(),
+                $dataSetName,
+            );
+        }
+
+        return sprintf(
+            '%s with data set "%s"',
+            $test->methodName(),
+            $dataSetName,
+        );
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     *
+     * @phpstan-assert !null $this->currentTestCase
+     */
+    private function createTestCase(Errored|Failed|MarkedIncomplete|PreparationStarted|Prepared|Skipped $event): void
+    {
+        $testCase = $this->document->createElement('testcase');
+
+        $test = $event->test();
+        $file = $this->converter->getTestCaseLocation($test); // pest-added
+
+        $testCase->setAttribute('name', $this->converter->getTestCaseMethodName($test)); // pest-changed
+        $testCase->setAttribute('file', $file); // pest-changed
+
+        if ($test->isTestMethod()) {
+            assert($test instanceof TestMethod);
+
+            // $testCase->setAttribute('line', (string) $test->line()); // pest-removed
+            $className = $this->converter->getTrimmedTestClassName($test); // pest-added
+            $testCase->setAttribute('class', $className); // pest-changed
+            $testCase->setAttribute('classname', str_replace('\\', '.', $className)); // pest-changed
+        }
+
+        $this->currentTestCase = $testCase;
+        $this->time = $event->telemetryInfo()->time();
+    }
+}

overrides/Runner/Filter/NameFilterIterator.php

@@ -32,41 +32,58 @@
  * 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\Filter;
 
-use function end;
-use Exception;
-use function implode;
 use Pest\Contracts\HasPrintableTestCaseName;
-use PHPUnit\Framework\SelfDescribing;
 use PHPUnit\Framework\Test;
-use PHPUnit\Framework\TestCase;
 use PHPUnit\Framework\TestSuite;
-use function preg_match;
+use PHPUnit\Runner\PhptTestCase;
 use RecursiveFilterIterator;
 use RecursiveIterator;
+
+use function end;
+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
+abstract class NameFilterIterator extends RecursiveFilterIterator
 {
-    private ?string $filter = null;
+    /**
+     * @psalm-var non-empty-string
+     */
+    private readonly string $regularExpression;
 
-    private ?int $filterMin = null;
+    private readonly ?int $dataSetMinimum;
 
-    private ?int $filterMax = null;
+    private readonly ?int $dataSetMaximum;
 
     /**
-     * @throws Exception
+     * @psalm-param RecursiveIterator<int, Test> $iterator
+     * @psalm-param non-empty-string $filter
      */
     public function __construct(RecursiveIterator $iterator, string $filter)
     {
         parent::__construct($iterator);
 
-        $this->setFilter($filter);
+        $preparedFilter = $this->prepareFilter($filter);
+
+        $this->regularExpression = $preparedFilter['regularExpression'];
+        $this->dataSetMinimum = $preparedFilter['dataSetMinimum'];
+        $this->dataSetMaximum = $preparedFilter['dataSetMaximum'];
     }
 
     public function accept(): bool
@@ -77,29 +94,40 @@ final class NameFilterIterator extends RecursiveFilterIterator
             return true;
         }
 
-        $tmp = $this->describe($test);
+        if ($test instanceof PhptTestCase) {
+            return false;
+        }
 
-        if ($tmp[0] !== '') {
-            $name = implode('::', $tmp);
+        if ($test instanceof HasPrintableTestCaseName) {
+            $name = trim(
+                $test::getPrintableTestCaseName().'::'.$test->getPrintableTestCaseMethodName().$test->dataSetAsString()
+            );
         } else {
-            $name = $tmp[1];
+            $name = $test::class.'::'.$test->nameWithDataSet();
         }
 
-        $accepted = @preg_match($this->filter, $name, $matches);
+        $accepted = @preg_match($this->regularExpression, $name, $matches) === 1;
 
-        if ($accepted && isset($this->filterMax)) {
+        if ($accepted && isset($this->dataSetMaximum)) {
             $set = end($matches);
-            $accepted = $set >= $this->filterMin && $set <= $this->filterMax;
+            $accepted = $set >= $this->dataSetMinimum && $set <= $this->dataSetMaximum;
         }
 
-        return (bool) $accepted;
+        return $this->doAccept($accepted);
     }
 
+    abstract protected function doAccept(bool $result): bool;
+
     /**
-     * @throws Exception
+     * @psalm-param non-empty-string $filter
+     *
+     * @psalm-return array{regularExpression: non-empty-string, dataSetMinimum: ?int, dataSetMaximum: ?int}
      */
-    private function setFilter(string $filter): void
+    private function prepareFilter(string $filter): array
     {
+        $dataSetMinimum = null;
+        $dataSetMaximum = null;
+
         if (@preg_match($filter, '') === false) {
             // Handles:
             //  * testAssertEqualsSucceeds#4
@@ -107,17 +135,17 @@ final class NameFilterIterator extends RecursiveFilterIterator
             if (preg_match('/^(.*?)#(\d+)(?:-(\d+))?$/', $filter, $matches)) {
                 if (isset($matches[3]) && $matches[2] < $matches[3]) {
                     $filter = sprintf(
-                        '%s.*with dataset #(\d+)$',
-                        $matches[1]
+                        '%s.*with data set #(\d+)$',
+                        $matches[1],
                     );
 
-                    $this->filterMin = (int) $matches[2];
-                    $this->filterMax = (int) $matches[3];
+                    $dataSetMinimum = (int) $matches[2];
+                    $dataSetMaximum = (int) $matches[3];
                 } else {
                     $filter = sprintf(
-                        '%s.*with dataset #%s$',
+                        '%s.*with data set #%s$',
                         $matches[1],
-                        $matches[2]
+                        $matches[2],
                     );
                 }
             } // Handles:
@@ -125,9 +153,9 @@ final class NameFilterIterator extends RecursiveFilterIterator
             //  * testDetermineJsonError@JSON.*
             elseif (preg_match('/^(.*?)@(.+)$/', $filter, $matches)) {
                 $filter = sprintf(
-                    '%s.*with dataset "%s"$',
+                    '%s.*with data set "%s"$',
                     $matches[1],
-                    $matches[2]
+                    $matches[2],
                 );
             }
 
@@ -138,34 +166,15 @@ final class NameFilterIterator extends RecursiveFilterIterator
                 str_replace(
                     '/',
                     '\\/',
-                    $filter
-                )
+                    $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];
+        return [
+            'regularExpression' => $filter,
+            'dataSetMinimum' => $dataSetMinimum,
+            'dataSetMaximum' => $dataSetMaximum,
+        ];
     }
 }

overrides/Runner/ResultCache/DefaultResultCache.php

@@ -45,9 +45,16 @@ declare(strict_types=1);
 
 namespace PHPUnit\Runner\ResultCache;
 
+use const DIRECTORY_SEPARATOR;
+use const LOCK_EX;
+
+use PHPUnit\Framework\TestStatus\TestStatus;
+use PHPUnit\Runner\DirectoryDoesNotExistException;
+use PHPUnit\Runner\Exception;
+use PHPUnit\Util\Filesystem;
+
 use function array_keys;
 use function assert;
-use const DIRECTORY_SEPARATOR;
 use function dirname;
 use function file_get_contents;
 use function file_put_contents;
@@ -57,35 +64,25 @@ use function is_file;
 use function json_decode;
 use function json_encode;
 use function Pest\version;
-use PHPUnit\Framework\TestStatus\TestStatus;
-use PHPUnit\Runner\DirectoryCannotBeCreatedException;
-use PHPUnit\Runner\Exception;
-use PHPUnit\Util\Filesystem;
 
 /**
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ *
  * @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 const string DEFAULT_RESULT_CACHE_FILENAME = '.phpunit.result.cache';
 
     private readonly string $cacheFilename;
 
     /**
-     * @psalm-var array<string, TestStatus>
+     * @var array<string, TestStatus>
      */
     private array $defects = [];
 
     /**
-     * @psalm-var array<string, TestStatus>
-     */
-    private array $currentDefects = [];
-
-    /**
-     * @psalm-var array<string, float>
+     * @var array<string, float>
      */
     private array $times = [];
 
@@ -98,31 +95,39 @@ final class DefaultResultCache implements ResultCache
         $this->cacheFilename = $filepath ?? $_ENV['PHPUNIT_RESULT_CACHE'] ?? self::DEFAULT_RESULT_CACHE_FILENAME;
     }
 
-    public function setStatus(string $id, TestStatus $status): void
+    public function setStatus(ResultCacheId $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]);
+        if ($status->isSuccess()) {
+            return;
         }
 
-        $this->times[$id] = $time;
+        $this->defects[$id->asString()] = $status;
     }
 
-    public function time(string $id): float
+    public function status(ResultCacheId $id): TestStatus
     {
-        return $this->times[$id] ?? 0.0;
+        return $this->defects[$id->asString()] ?? TestStatus::unknown();
+    }
+
+    public function setTime(ResultCacheId $id, float $time): void
+    {
+        $this->times[$id->asString()] = $time;
+    }
+
+    public function time(ResultCacheId $id): float
+    {
+        return $this->times[$id->asString()] ?? 0.0;
+    }
+
+    public function mergeWith(self $other): void
+    {
+        foreach ($other->defects as $id => $defect) {
+            $this->defects[$id] = $defect;
+        }
+
+        foreach ($other->times as $id => $time) {
+            $this->times[$id] = $time;
+        }
     }
 
     public function load(): void
@@ -131,9 +136,15 @@ final class DefaultResultCache implements ResultCache
             return;
         }
 
+        $contents = file_get_contents($this->cacheFilename);
+
+        if ($contents === false) {
+            return;
+        }
+
         $data = json_decode(
-            file_get_contents($this->cacheFilename),
-            true
+            $contents,
+            true,
         );
 
         if ($data === null) {
@@ -165,7 +176,7 @@ final class DefaultResultCache implements ResultCache
     public function persist(): void
     {
         if (! Filesystem::createDirectory(dirname($this->cacheFilename))) {
-            throw new DirectoryCannotBeCreatedException($this->cacheFilename);
+            throw new DirectoryDoesNotExistException(dirname($this->cacheFilename));
         }
 
         $data = [
@@ -181,7 +192,7 @@ final class DefaultResultCache implements ResultCache
         file_put_contents(
             $this->cacheFilename,
             json_encode($data),
-            LOCK_EX
+            LOCK_EX,
         );
     }
 

overrides/Runner/TestSuiteLoader.php

@@ -36,18 +36,21 @@ declare(strict_types=1);
 
 namespace PHPUnit\Runner;
 
-use function array_diff;
-use function array_values;
-use function basename;
-use function class_exists;
 use Exception;
-use function get_declared_classes;
 use Pest\Contracts\HasPrintableTestCaseName;
+use Pest\Panic;
 use Pest\TestCases\IgnorableTestCase;
 use Pest\TestSuite;
 use PHPUnit\Framework\TestCase;
 use ReflectionClass;
 use ReflectionException;
+use Throwable;
+
+use function array_diff;
+use function array_values;
+use function basename;
+use function class_exists;
+use function get_declared_classes;
 use function substr;
 
 /**
@@ -60,6 +63,11 @@ final class TestSuiteLoader
      */
     private static array $loadedClasses = [];
 
+    /**
+     * @psalm-var array<string, array<class-string>>
+     */
+    private static array $loadedClassesByFilename = [];
+
     /**
      * @psalm-var list<class-string>
      */
@@ -80,7 +88,11 @@ final class TestSuiteLoader
         $suiteClassName = $this->classNameFromFileName($suiteClassFile);
 
         (static function () use ($suiteClassFile) {
-            include_once $suiteClassFile;
+            try {
+                include_once $suiteClassFile;
+            } catch (Throwable $e) {
+                Panic::with($e);
+            }
 
             TestSuite::getInstance()->tests->makeIfNeeded($suiteClassFile);
         })();
@@ -97,6 +109,17 @@ final class TestSuiteLoader
 
         self::$loadedClasses = array_merge($loadedClasses, self::$loadedClasses);
 
+        foreach ($loadedClasses as $loadedClass) {
+            $reflection = new ReflectionClass($loadedClass);
+            $filename = $reflection->getFileName();
+            self::$loadedClassesByFilename[$filename] = [
+                $loadedClass,
+                ...self::$loadedClassesByFilename[$filename] ?? [],
+            ];
+        }
+
+        $loadedClasses = array_merge(self::$loadedClassesByFilename[$suiteClassFile] ?? [], $loadedClasses);
+
         if (empty($loadedClasses)) {
             return $this->exceptionFor($suiteClassName, $suiteClassFile);
         }
@@ -115,7 +138,7 @@ final class TestSuiteLoader
                     continue;
                 }
 
-                if ($class->isAbstract() || ($class->getFileName() !== $suiteClassFile)) {
+                if ($class->isAbstract() || ($suiteClassFile !== $class->getFileName())) {
                     if (! str_contains($class->getFileName(), 'TestCaseFactory.php')) {
                         continue;
                     }

overrides/TextUI/Command/Commands/WarmCodeCoverageCacheCommand.php

@@ -45,6 +45,8 @@ declare(strict_types=1);
 
 namespace PHPUnit\TextUI\Command;
 
+use const PHP_EOL;
+
 use PHPUnit\TextUI\Configuration\CodeCoverageFilterRegistry;
 use PHPUnit\TextUI\Configuration\Configuration;
 use PHPUnit\TextUI\Configuration\NoCoverageCacheDirectoryException;
@@ -55,11 +57,11 @@ use SebastianBergmann\Timer\Timer;
 /**
  * @internal This class is not covered by the backward compatibility promise for PHPUnit
  */
-final class WarmCodeCoverageCacheCommand implements Command
+final readonly class WarmCodeCoverageCacheCommand implements Command
 {
-    private readonly Configuration $configuration;
+    private Configuration $configuration;
 
-    private readonly CodeCoverageFilterRegistry $codeCoverageFilterRegistry;
+    private CodeCoverageFilterRegistry $codeCoverageFilterRegistry;
 
     public function __construct(Configuration $configuration, CodeCoverageFilterRegistry $codeCoverageFilterRegistry)
     {
@@ -76,16 +78,16 @@ final class WarmCodeCoverageCacheCommand implements Command
         if (! $this->configuration->hasCoverageCacheDirectory()) {
             return Result::from(
                 'Cache for static analysis has not been configured'.PHP_EOL,
-                Result::FAILURE
+                Result::FAILURE,
             );
         }
 
-        $this->codeCoverageFilterRegistry->init($this->configuration);
+        $this->codeCoverageFilterRegistry->init($this->configuration, true);
 
         if (! $this->codeCoverageFilterRegistry->configured()) {
             return Result::from(
                 'Filter for code coverage has not been configured'.PHP_EOL,
-                Result::FAILURE
+                Result::FAILURE,
             );
         }
 
@@ -96,7 +98,7 @@ final class WarmCodeCoverageCacheCommand implements Command
             $this->configuration->coverageCacheDirectory(),
             ! $this->configuration->disableCodeCoverageIgnore(),
             $this->configuration->ignoreDeprecatedCodeUnitsFromCodeCoverage(),
-            $this->codeCoverageFilterRegistry->get()
+            $this->codeCoverageFilterRegistry->get(),
         );
 
         return Result::from();

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

@@ -43,7 +43,7 @@ declare(strict_types=1);
  * file that was distributed with this source code.
  */
 
-namespace PHPUnit\TextUI\Output\Default\ProgressPrinter;
+namespace Pest\Logging\TeamCity\Subscriber;
 
 use PHPUnit\Event\Test\Skipped;
 use PHPUnit\Event\Test\SkippedSubscriber;
@@ -51,21 +51,16 @@ 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();
+        $this->logger()->testSkipped($event);
     }
 
     /**

overrides/TextUI/TestSuiteFilterProcessor.php

@@ -33,7 +33,6 @@
  */
 
 declare(strict_types=1);
-
 /*
  * This file is part of PHPUnit.
  *
@@ -45,84 +44,95 @@ declare(strict_types=1);
 
 namespace PHPUnit\TextUI;
 
-use function array_map;
 use Pest\Plugins\Only;
+use Pest\Runner\Filter\EnsureTestCaseIsInitiatedFilter;
 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
+final readonly 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
     {
+        $factory = new Factory;
+
+        // @phpstan-ignore-next-line
+        (fn () => $this->filters[] = [
+            'className' => EnsureTestCaseIsInitiatedFilter::class,
+            'argument' => '',
+        ])->call($factory);
+
         if (! $configuration->hasFilter() &&
             ! $configuration->hasGroups() &&
             ! $configuration->hasExcludeGroups() &&
+            ! $configuration->hasExcludeFilter() &&
             ! $configuration->hasTestsCovering() &&
             ! $configuration->hasTestsUsing() &&
-            ! Only::isEnabled()
-        ) {
+            ! Only::isEnabled()) {
+            $suite->injectFilter($factory);
+
             return;
         }
 
         if ($configuration->hasExcludeGroups()) {
-            $this->filterFactory->addExcludeGroupFilter(
-                $configuration->excludeGroups()
+            $factory->addExcludeGroupFilter(
+                $configuration->excludeGroups(),
             );
         }
 
         if (Only::isEnabled()) {
-            $this->filterFactory->addIncludeGroupFilter(['__pest_only']);
+            $factory->addIncludeGroupFilter([Only::group()]);
         } elseif ($configuration->hasGroups()) {
-            $this->filterFactory->addIncludeGroupFilter(
-                $configuration->groups()
+            $factory->addIncludeGroupFilter(
+                $configuration->groups(),
             );
         }
 
         if ($configuration->hasTestsCovering()) {
-            $this->filterFactory->addIncludeGroupFilter(
+            $factory->addIncludeGroupFilter(
                 array_map(
                     static fn (string $name): string => '__phpunit_covers_'.$name,
-                    $configuration->testsCovering()
-                )
+                    $configuration->testsCovering(),
+                ),
             );
         }
 
         if ($configuration->hasTestsUsing()) {
-            $this->filterFactory->addIncludeGroupFilter(
+            $factory->addIncludeGroupFilter(
                 array_map(
                     static fn (string $name): string => '__phpunit_uses_'.$name,
-                    $configuration->testsUsing()
-                )
+                    $configuration->testsUsing(),
+                ),
+            );
+        }
+
+        if ($configuration->hasExcludeFilter()) {
+            $factory->addExcludeNameFilter(
+                $configuration->excludeFilter(),
             );
         }
 
         if ($configuration->hasFilter()) {
-            $this->filterFactory->addNameFilter(
-                $configuration->filter()
+            $factory->addIncludeNameFilter(
+                $configuration->filter(),
             );
         }
 
-        $suite->injectFilter($this->filterFactory);
+        $suite->injectFilter($factory);
 
         Event\Facade::emitter()->testSuiteFiltered(
-            Event\TestSuite\TestSuiteBuilder::from($suite)
+            Event\TestSuite\TestSuiteBuilder::from($suite),
         );
     }
 }

phpstan-baseline.neon

@@ -0,0 +1,199 @@
+parameters:
+	ignoreErrors:
+		-
+			message: '#^Parameter \#1 of callable callable\(Pest\\Expectation\<string\|null\>\)\: Pest\\Arch\\Contracts\\ArchExpectation expects Pest\\Expectation\<string\|null\>, Pest\\Expectation\<string\|null\> given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/ArchPresets/AbstractPreset.php
+
+		-
+			message: '#^Trait Pest\\Concerns\\Expectable is used zero times and is not analysed\.$#'
+			identifier: trait.unused
+			count: 1
+			path: src/Concerns/Expectable.php
+
+		-
+			message: '#^Trait Pest\\Concerns\\Logging\\WritesToConsole is used zero times and is not analysed\.$#'
+			identifier: trait.unused
+			count: 1
+			path: src/Concerns/Logging/WritesToConsole.php
+
+		-
+			message: '#^Trait Pest\\Concerns\\Testable is used zero times and is not analysed\.$#'
+			identifier: trait.unused
+			count: 1
+			path: src/Concerns/Testable.php
+
+		-
+			message: '#^Loose comparison using \!\= between \(Closure\|null\) and false will always evaluate to false\.$#'
+			identifier: notEqual.alwaysFalse
+			count: 1
+			path: src/Expectation.php
+
+		-
+			message: '#^Method Pest\\Expectation\:\:and\(\) should return Pest\\Expectation\<TAndValue\> but returns \(Pest\\Expectation&TAndValue\)\|Pest\\Expectation\<TAndValue of mixed\>\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Expectation.php
+
+		-
+			message: '#^PHPDoc tag @property for property Pest\\Expectation\:\:\$each contains generic class Pest\\Expectations\\EachExpectation but does not specify its types\: TValue$#'
+			identifier: missingType.generics
+			count: 1
+			path: src/Expectation.php
+
+		-
+			message: '#^PHPDoc tag @property for property Pest\\Expectation\:\:\$not contains generic class Pest\\Expectations\\OppositeExpectation but does not specify its types\: TValue$#'
+			identifier: missingType.generics
+			count: 1
+			path: src/Expectation.php
+
+		-
+			message: '#^Parameter \#2 \$newScope of method Closure\:\:bindTo\(\) expects ''static''\|class\-string\|object\|null, string given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Expectation.php
+
+		-
+			message: '#^Function expect\(\) should return Pest\\Expectation\<TValue\|null\> but returns Pest\\Expectation\<TValue\|null\>\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Functions.php
+
+		-
+			message: '#^Parameter \#1 \$argv of method PHPUnit\\TextUI\\Application\:\:run\(\) expects list\<string\>, array\<int, string\> given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Kernel.php
+
+		-
+			message: '#^Call to an undefined method object&TValue of mixed\:\:__toString\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Mixins/Expectation.php
+
+		-
+			message: '#^Call to an undefined method object&TValue of mixed\:\:toArray\(\)\.$#'
+			identifier: method.notFound
+			count: 4
+			path: src/Mixins/Expectation.php
+
+		-
+			message: '#^Call to an undefined method object&TValue of mixed\:\:toSnapshot\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Mixins/Expectation.php
+
+		-
+			message: '#^Call to an undefined method object&TValue of mixed\:\:toString\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Mixins/Expectation.php
+
+		-
+			message: '#^Call to static method PHPUnit\\Framework\\Assert\:\:assertTrue\(\) with true will always evaluate to true\.$#'
+			identifier: staticMethod.alreadyNarrowedType
+			count: 2
+			path: src/Mixins/Expectation.php
+
+		-
+			message: '#^PHPDoc tag @var with type callable\(\)\: bool is not subtype of native type Closure\|null\.$#'
+			identifier: varTag.nativeType
+			count: 1
+			path: src/PendingCalls/TestCall.php
+
+		-
+			message: '#^Parameter \#1 \$argv of class Symfony\\Component\\Console\\Input\\ArgvInput constructor expects list\<string\>\|null, array\<int, string\> given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel.php
+
+		-
+			message: '#^Parameter \#13 \$testRunnerTriggeredDeprecationEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\TestRunner\\DeprecationTriggered\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Parameter \#14 \$testRunnerTriggeredWarningEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\TestRunner\\WarningTriggered\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Parameter \#15 \$errors of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Parameter \#16 \$deprecations of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Parameter \#17 \$notices of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Parameter \#18 \$warnings of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Parameter \#19 \$phpDeprecations of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Parameter \#20 \$phpNotices of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Parameter \#21 \$phpWarnings of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\TestRunner\\TestResult\\Issues\\Issue\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Parameter \#4 \$testErroredEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\Test\\AfterLastTestMethodErrored\|PHPUnit\\Event\\Test\\BeforeFirstTestMethodErrored\|PHPUnit\\Event\\Test\\Errored\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Parameter \#5 \$testFailedEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\Test\\Failed\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Parameter \#7 \$testSuiteSkippedEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\TestSuite\\Skipped\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Parameter \#8 \$testSkippedEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\Test\\Skipped\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Parameter \#9 \$testMarkedIncompleteEvents of class PHPUnit\\TestRunner\\TestResult\\TestResult constructor expects list\<PHPUnit\\Event\\Test\\MarkedIncomplete\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php
+
+		-
+			message: '#^Property Pest\\Plugins\\Parallel\\Paratest\\WrapperRunner\:\:\$pending \(list\<non\-empty\-string\>\) does not accept array\<int, non\-empty\-string\>\.$#'
+			identifier: assign.propertyType
+			count: 1
+			path: src/Plugins/Parallel/Paratest/WrapperRunner.php

phpstan.neon

@@ -1,23 +1,12 @@
 includes:
-    - vendor/phpstan/phpstan-strict-rules/rules.neon
-    - vendor/ergebnis/phpstan-rules/rules.neon
-    - vendor/thecodingmachine/phpstan-strict-rules/phpstan-strict-rules.neon
+    - phpstan-baseline.neon
 
 parameters:
-    level: max
+    level: 7
     paths:
         - src
 
-    checkMissingIterableValueType: true
-    reportUnmatchedIgnoredErrors: true
+    reportUnmatchedIgnoredErrors: false
 
     ignoreErrors:
-        - "#has a nullable return type declaration.#"
-        - "#Language construct isset\\(\\) should not be used.#"
-        - "#is not allowed to extend#"
-        - "#is concrete, but does not have a Test suffix#"
-        - "#with a nullable type declaration#"
         - "#type mixed is not subtype of native#"
-        - "# with null as default value#"
-        - "#has parameter \\$closure with default value.#"
-        - "#has parameter \\$description with default value.#"

phpunit.xml

@@ -16,6 +16,7 @@
   <testsuites>
     <testsuite name="default">
       <directory suffix=".php">./tests</directory>
+      <directory suffix=".php">./tests-external</directory>
       <exclude>./tests/.snapshots</exclude>
       <exclude>./tests/.tests</exclude>
       <exclude>./tests/Fixtures/Inheritance</exclude>

rector.php

@@ -2,30 +2,28 @@
 
 declare(strict_types=1);
 
-use Rector\CodeQuality\Rector\Class_\InlineConstructorDefaultToPropertyRector;
+use Rector\CodingStyle\Rector\ArrowFunction\ArrowFunctionDelegatingCallToFirstClassCallableRector;
 use Rector\Config\RectorConfig;
-use Rector\Set\ValueObject\LevelSetList;
-use Rector\Set\ValueObject\SetList;
+use Rector\DeadCode\Rector\ClassMethod\RemoveParentDelegatingConstructorRector;
+use Rector\TypeDeclaration\Rector\ClassMethod\NarrowObjectReturnTypeRector;
+use Rector\TypeDeclaration\Rector\ClassMethod\ReturnNeverTypeRector;
 
-return static function (RectorConfig $rectorConfig): void {
-    $rectorConfig->paths([
+return RectorConfig::configure()
+    ->withPaths([
         __DIR__.'/src',
-    ]);
-
-    $rectorConfig->rules([
-        InlineConstructorDefaultToPropertyRector::class,
-    ]);
-
-    $rectorConfig->skip([
+    ])
+    ->withSkip([
         __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,
-    ]);
-};
+        ReturnNeverTypeRector::class,
+        ArrowFunctionDelegatingCallToFirstClassCallableRector::class,
+        NarrowObjectReturnTypeRector::class,
+        RemoveParentDelegatingConstructorRector::class,
+    ])
+    ->withPreparedSets(
+        deadCode: true,
+        codeQuality: true,
+        typeDeclarations: true,
+        privatization: true,
+        earlyReturn: true,
+    )
+    ->withPhpSets();

resources/base-phpunit.xml

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
+         bootstrap="vendor/autoload.php"
+         colors="true"
+>
+    <testsuites>
+        <testsuite name="Default">
+            <directory>tests/</directory>
+        </testsuite>
+    </testsuites>
+    <source>
+        <include>
+            <directory>app</directory>
+            <directory>src</directory>
+        </include>
+    </source>
+    <php>
+        <env name="APP_ENV" value="testing"/>
+        <env name="APP_MAINTENANCE_DRIVER" value="file"/>
+        <env name="BCRYPT_ROUNDS" value="4"/>
+        <env name="CACHE_STORE" value="array"/>
+        <!-- <env name="DB_CONNECTION" value="sqlite"/> -->
+        <!-- <env name="DB_DATABASE" value=":memory:"/> -->
+        <env name="MAIL_MAILER" value="array"/>
+        <env name="PULSE_ENABLED" value="false"/>
+        <env name="QUEUE_CONNECTION" value="sync"/>
+        <env name="SESSION_DRIVER" value="array"/>
+        <env name="TELESCOPE_ENABLED" value="false"/>
+    </php>
+</phpunit>

resources/views/components/badge.php

@@ -10,7 +10,7 @@
 ?>
 
 <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-2 px-1 bg-<?php echo $bgBadgeColor ?> font-bold"><?php echo htmlspecialchars($bgBadgeText) ?></span>
     <span class="ml-1">
         <?php echo htmlspecialchars($content) ?>
     </span>

resources/views/installers/plugin-browser.php

@@ -0,0 +1,22 @@
+<div class="mx-2 mb-1">
+    <p>
+        <span>Using the <span class="text-yellow font-bold">visit()</span> function requires the Pest Plugin Browser to be installed.</span>
+
+        <span class="ml-1 text-yellow font-bold">Run:</span>
+    </p>
+
+    <div>
+        <span class="text-gray mr-1">- </span>
+        <span>composer require pestphp/pest-plugin-browser:^4.0 --dev</span>
+    </div>
+
+    <div>
+        <span class="text-gray mr-1">- </span>
+        <span>npm install playwright@latest</span>
+    </div>
+
+    <div>
+        <span class="text-gray mr-1">- </span>
+        <span>npx playwright install</span>
+    </div>
+</div>

src/ArchPresets/AbstractPreset.php

@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\ArchPresets;
+
+use Pest\Arch\Contracts\ArchExpectation;
+use Pest\Expectation;
+
+/**
+ * @internal
+ */
+abstract class AbstractPreset // @pest-arch-ignore-line
+{
+    /**
+     * The expectations.
+     *
+     * @var array<int, Expectation<mixed>|ArchExpectation>
+     */
+    protected array $expectations = [];
+
+    /**
+     * Creates a new preset instance.
+     *
+     * @param  array<int, string>  $userNamespaces
+     */
+    public function __construct(
+        private readonly array $userNamespaces,
+    ) {
+        //
+    }
+
+    /**
+     * Executes the arch preset.
+     *
+     * @internal
+     */
+    abstract public function execute(): void;
+
+    /**
+     * Ignores the given "targets" or "dependencies".
+     *
+     * @param  array<int, string>|string  $targetsOrDependencies
+     */
+    final public function ignoring(array|string $targetsOrDependencies): void
+    {
+        $this->expectations = array_map(
+            fn (ArchExpectation|Expectation $expectation): Expectation|ArchExpectation => $expectation instanceof ArchExpectation ? $expectation->ignoring($targetsOrDependencies) : $expectation,
+            $this->expectations,
+        );
+    }
+
+    /**
+     * Runs the given callback for each namespace.
+     *
+     * @param  callable(Expectation<string|null>): ArchExpectation  ...$callbacks
+     */
+    final public function eachUserNamespace(callable ...$callbacks): void
+    {
+        foreach ($this->userNamespaces as $namespace) {
+            foreach ($callbacks as $callback) {
+                $this->expectations[] = $callback(expect($namespace));
+            }
+        }
+    }
+
+    /**
+     * Flushes the expectations.
+     */
+    final public function flush(): void
+    {
+        $this->expectations = [];
+    }
+}

src/ArchPresets/Custom.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\ArchPresets;
+
+use Closure;
+use Pest\Arch\Contracts\ArchExpectation;
+use Pest\Expectation;
+
+/**
+ * @internal
+ */
+final class Custom extends AbstractPreset
+{
+    /**
+     * Creates a new preset instance.
+     *
+     * @param  array<int, string>  $userNamespaces
+     * @param  Closure(array<int, string>): array<Expectation<mixed>|ArchExpectation>  $execute
+     */
+    public function __construct(
+        private readonly array $userNamespaces,
+        private readonly string $name,
+        private readonly Closure $execute,
+    ) {
+        parent::__construct($userNamespaces);
+    }
+
+    /**
+     * Returns the name of the preset.
+     */
+    public function name(): string
+    {
+        return $this->name;
+    }
+
+    /**
+     * Executes the arch preset.
+     */
+    public function execute(): void
+    {
+        $this->expectations = ($this->execute)($this->userNamespaces);
+    }
+}

src/ArchPresets/Laravel.php

@@ -0,0 +1,177 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\ArchPresets;
+
+use Throwable;
+
+/**
+ * @internal
+ */
+final class Laravel extends AbstractPreset
+{
+    /**
+     * Executes the arch preset.
+     */
+    public function execute(): void
+    {
+        $this->expectations[] = expect('App\Traits')
+            ->toBeTraits();
+
+        $this->expectations[] = expect('App\Concerns')
+            ->toBeTraits();
+
+        $this->expectations[] = expect('App')
+            ->not->toBeEnums()
+            ->ignoring('App\Enums');
+
+        $this->expectations[] = expect('App\Enums')
+            ->toBeEnums()
+            ->ignoring('App\Enums\Concerns');
+
+        $this->expectations[] = expect('App\Features')
+            ->toBeClasses()
+            ->ignoring('App\Features\Concerns');
+
+        $this->expectations[] = expect('App\Features')
+            ->toHaveMethod('resolve')
+            ->ignoring('App\Features\Concerns');
+
+        $this->expectations[] = expect('App\Exceptions')
+            ->classes()
+            ->toImplement('Throwable')
+            ->ignoring('App\Exceptions\Handler');
+
+        $this->expectations[] = expect('App')
+            ->not->toImplement(Throwable::class)
+            ->ignoring('App\Exceptions');
+
+        $this->expectations[] = expect('App\Http\Middleware')
+            ->classes()
+            ->toHaveMethod('handle');
+
+        $this->expectations[] = expect('App\Models')
+            ->classes()
+            ->toExtend('Illuminate\Database\Eloquent\Model')
+            ->ignoring('App\Models\Scopes');
+
+        $this->expectations[] = expect('App\Models')
+            ->classes()
+            ->not->toHaveSuffix('Model');
+
+        $this->expectations[] = expect('App')
+            ->not->toExtend('Illuminate\Database\Eloquent\Model')
+            ->ignoring('App\Models');
+
+        $this->expectations[] = expect('App\Http\Requests')
+            ->classes()
+            ->toHaveSuffix('Request');
+
+        $this->expectations[] = expect('App\Http\Requests')
+            ->toExtend('Illuminate\Foundation\Http\FormRequest');
+
+        $this->expectations[] = expect('App\Http\Requests')
+            ->toHaveMethod('rules');
+
+        $this->expectations[] = expect('App')
+            ->not->toExtend('Illuminate\Foundation\Http\FormRequest')
+            ->ignoring('App\Http\Requests');
+
+        $this->expectations[] = expect('App\Console\Commands')
+            ->classes()
+            ->toHaveSuffix('Command');
+
+        $this->expectations[] = expect('App\Console\Commands')
+            ->classes()
+            ->toExtend('Illuminate\Console\Command');
+
+        $this->expectations[] = expect('App\Console\Commands')
+            ->classes()
+            ->toHaveMethod('handle');
+
+        $this->expectations[] = expect('App')
+            ->not->toExtend('Illuminate\Console\Command')
+            ->ignoring('App\Console\Commands');
+
+        $this->expectations[] = expect('App\Mail')
+            ->classes()
+            ->toExtend('Illuminate\Mail\Mailable');
+
+        $this->expectations[] = expect('App\Mail')
+            ->classes()
+            ->toImplement('Illuminate\Contracts\Queue\ShouldQueue');
+
+        $this->expectations[] = expect('App')
+            ->not->toExtend('Illuminate\Mail\Mailable')
+            ->ignoring('App\Mail');
+
+        $this->expectations[] = expect('App\Jobs')
+            ->classes()
+            ->toImplement('Illuminate\Contracts\Queue\ShouldQueue');
+
+        $this->expectations[] = expect('App\Jobs')
+            ->classes()
+            ->toHaveMethod('handle');
+
+        $this->expectations[] = expect('App\Listeners')
+            ->toHaveMethod('handle');
+
+        $this->expectations[] = expect('App\Notifications')
+            ->toExtend('Illuminate\Notifications\Notification');
+
+        $this->expectations[] = expect('App')
+            ->not->toExtend('Illuminate\Notifications\Notification')
+            ->ignoring('App\Notifications');
+
+        $this->expectations[] = expect('App\Providers')
+            ->toHaveSuffix('ServiceProvider');
+
+        $this->expectations[] = expect('App\Providers')
+            ->toExtend('Illuminate\Support\ServiceProvider');
+
+        $this->expectations[] = expect('App\Providers')
+            ->not->toBeUsed();
+
+        $this->expectations[] = expect('App')
+            ->not->toExtend('Illuminate\Support\ServiceProvider')
+            ->ignoring('App\Providers');
+
+        $this->expectations[] = expect('App')
+            ->not->toHaveSuffix('ServiceProvider')
+            ->ignoring('App\Providers');
+
+        $this->expectations[] = expect('App')
+            ->not->toHaveSuffix('Controller')
+            ->ignoring('App\Http\Controllers');
+
+        $this->expectations[] = expect('App\Http\Controllers')
+            ->classes()
+            ->toHaveSuffix('Controller');
+
+        $this->expectations[] = expect('App\Http')
+            ->toOnlyBeUsedIn(['App\Http', 'App\Providers']);
+
+        $this->expectations[] = expect('App\Http\Controllers')
+            ->not->toHavePublicMethodsBesides(['__construct', '__invoke', 'index', 'show', 'create', 'store', 'edit', 'update', 'destroy', 'middleware']);
+
+        $this->expectations[] = expect([
+            'dd',
+            'ddd',
+            'dump',
+            'env',
+            'exit',
+            'ray',
+        ])->not->toBeUsed();
+
+        $this->expectations[] = expect('App\Policies')
+            ->classes()
+            ->toHaveSuffix('Policy');
+
+        $this->expectations[] = expect('App\Attributes')
+            ->classes()
+            ->toImplement('Illuminate\Contracts\Container\ContextualAttribute')
+            ->toHaveAttribute('Attribute')
+            ->toHaveMethod('resolve');
+    }
+}

src/ArchPresets/Php.php

@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\ArchPresets;
+
+/**
+ * @internal
+ */
+final class Php extends AbstractPreset
+{
+    /**
+     * Executes the arch preset.
+     */
+    public function execute(): void
+    {
+        $this->expectations[] = expect([
+            'debug_zval_dump',
+            'debug_backtrace',
+            'debug_print_backtrace',
+            'dump',
+            'ray',
+            'ds',
+            'die',
+            'goto',
+            'global',
+            'var_dump',
+            'phpinfo',
+            'echo',
+            'ereg',
+            'eregi',
+            'mysql_connect',
+            'mysql_pconnect',
+            'mysql_query',
+            'mysql_select_db',
+            'mysql_fetch_array',
+            'mysql_fetch_assoc',
+            'mysql_fetch_object',
+            'mysql_fetch_row',
+            'mysql_num_rows',
+            'mysql_affected_rows',
+            'mysql_free_result',
+            'mysql_insert_id',
+            'mysql_error',
+            'mysql_real_escape_string',
+            'print',
+            'print_r',
+            'var_export',
+            'xdebug_break',
+            'xdebug_call_class',
+            'xdebug_call_file',
+            'xdebug_call_int',
+            'xdebug_call_line',
+            'xdebug_code_coverage_started',
+            'xdebug_connect_to_client',
+            'xdebug_debug_zval',
+            'xdebug_debug_zval_stdout',
+            'xdebug_dump_superglobals',
+            'xdebug_get_code_coverage',
+            'xdebug_get_collected_errors',
+            'xdebug_get_function_count',
+            'xdebug_get_function_stack',
+            'xdebug_get_gc_run_count',
+            'xdebug_get_gc_total_collected_roots',
+            'xdebug_get_gcstats_filename',
+            'xdebug_get_headers',
+            'xdebug_get_monitored_functions',
+            'xdebug_get_profiler_filename',
+            'xdebug_get_stack_depth',
+            'xdebug_get_tracefile_name',
+            'xdebug_info',
+            'xdebug_is_debugger_active',
+            'xdebug_memory_usage',
+            'xdebug_notify',
+            'xdebug_peak_memory_usage',
+            'xdebug_print_function_stack',
+            'xdebug_set_filter',
+            'xdebug_start_code_coverage',
+            'xdebug_start_error_collection',
+            'xdebug_start_function_monitor',
+            'xdebug_start_gcstats',
+            'xdebug_start_trace',
+            'xdebug_stop_code_coverage',
+            'xdebug_stop_error_collection',
+            'xdebug_stop_function_monitor',
+            'xdebug_stop_gcstats',
+            'xdebug_stop_trace',
+            'xdebug_time_index',
+            'xdebug_var_dump',
+            'trap',
+        ])->not->toBeUsed();
+    }
+}

src/ArchPresets/Relaxed.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\ArchPresets;
+
+use Pest\Arch\Contracts\ArchExpectation;
+use Pest\Expectation;
+
+/**
+ * @internal
+ */
+final class Relaxed extends AbstractPreset
+{
+    /**
+     * Executes the arch preset.
+     */
+    public function execute(): void
+    {
+        $this->eachUserNamespace(
+            fn (Expectation $namespace): ArchExpectation => $namespace->not->toUseStrictTypes(),
+            fn (Expectation $namespace): ArchExpectation => $namespace->classes()->not->toBeFinal(),
+            fn (Expectation $namespace): ArchExpectation => $namespace->classes()->not->toHavePrivateMethods(),
+        );
+    }
+}

src/ArchPresets/Security.php

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\ArchPresets;
+
+/**
+ * @internal
+ */
+final class Security extends AbstractPreset
+{
+    /**
+     * Executes the arch preset.
+     */
+    public function execute(): void
+    {
+        $this->expectations[] = expect([
+            'md5',
+            'sha1',
+            'uniqid',
+            'rand',
+            'mt_rand',
+            'tempnam',
+            'str_shuffle',
+            'shuffle',
+            'array_rand',
+            'eval',
+            'exec',
+            'shell_exec',
+            'system',
+            'passthru',
+            'create_function',
+            'unserialize',
+            'extract',
+            'mb_parse_str',
+            'dl',
+            'assert',
+        ])->not->toBeUsed();
+    }
+}

src/ArchPresets/Strict.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\ArchPresets;
+
+use Pest\Arch\Contracts\ArchExpectation;
+use Pest\Expectation;
+
+/**
+ * @internal
+ */
+final class Strict extends AbstractPreset
+{
+    /**
+     * Executes the arch preset.
+     */
+    public function execute(): void
+    {
+        $this->eachUserNamespace(
+            fn (Expectation $namespace): ArchExpectation => $namespace->classes()->not->toHaveProtectedMethods(),
+            fn (Expectation $namespace): ArchExpectation => $namespace->classes()->not->toBeAbstract(),
+            fn (Expectation $namespace): ArchExpectation => $namespace->toUseStrictTypes(),
+            fn (Expectation $namespace): ArchExpectation => $namespace->toUseStrictEquality(),
+            fn (Expectation $namespace): ArchExpectation => $namespace->classes()->toBeFinal(),
+        );
+
+        $this->expectations[] = expect([
+            'sleep',
+            'usleep',
+        ])->not->toBeUsed();
+    }
+}

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

@@ -5,14 +5,16 @@ declare(strict_types=1);
 namespace Pest\Bootstrappers;
 
 use Pest\Contracts\Bootstrapper;
+use Pest\Exceptions\FatalException;
 use Pest\Support\DatasetInfo;
 use Pest\Support\Str;
-use function Pest\testDirectory;
 use Pest\TestSuite;
 use RecursiveDirectoryIterator;
 use RecursiveIteratorIterator;
 use SebastianBergmann\FileIterator\Facade as PhpUnitFileIterator;
 
+use function Pest\testDirectory;
+
 /**
  * @internal
  */
@@ -23,7 +25,7 @@ final class BootFiles implements Bootstrapper
      *
      * @var array<int, string>
      */
-    private const STRUCTURE = [
+    private const array STRUCTURE = [
         'Expectations',
         'Expectations.php',
         'Helpers',
@@ -39,6 +41,10 @@ final class BootFiles implements Bootstrapper
         $rootPath = TestSuite::getInstance()->rootPath;
         $testsPath = $rootPath.DIRECTORY_SEPARATOR.testDirectory();
 
+        if (! is_dir($testsPath)) {
+            throw new FatalException(sprintf('The test directory [%s] does not exist.', $testsPath));
+        }
+
         foreach (self::STRUCTURE as $filename) {
             $filename = sprintf('%s%s%s', $testsPath, DIRECTORY_SEPARATOR, $filename);
 
@@ -77,6 +83,8 @@ final class BootFiles implements Bootstrapper
 
     private function bootDatasets(string $testsPath): void
     {
+        assert($testsPath !== '');
+
         $files = (new PhpUnitFileIterator)->getFilesAsArray($testsPath, '.php');
 
         foreach ($files as $file) {

src/Bootstrappers/BootKernelDump.php

@@ -12,13 +12,13 @@ use Symfony\Component\Console\Output\OutputInterface;
 /**
  * @internal
  */
-final class BootKernelDump implements Bootstrapper
+final readonly class BootKernelDump implements Bootstrapper
 {
     /**
      * Creates a new Boot Kernel Dump instance.
      */
     public function __construct(
-        private readonly OutputInterface $output,
+        private OutputInterface $output,
     ) {
         // ...
     }

src/Bootstrappers/BootOverrides.php

@@ -17,14 +17,15 @@ final class BootOverrides implements Bootstrapper
      *
      * @var array<int, string>
      */
-    private const FILES = [
+    public const array FILES = [
         'Runner/Filter/NameFilterIterator.php',
         'Runner/ResultCache/DefaultResultCache.php',
         'Runner/TestSuiteLoader.php',
-        'TextUI/Command/WarmCodeCoverageCacheCommand.php',
-        'TextUI/Output/Default/ProgressPrinter/TestSkippedSubscriber.php',
+        'TextUI/Command/Commands/WarmCodeCoverageCacheCommand.php',
+        'TextUI/Output/Default/ProgressPrinter/Subscriber/TestSkippedSubscriber.php',
         'TextUI/TestSuiteFilterProcessor.php',
         'Event/Value/ThrowableBuilder.php',
+        'Logging/JUnit/JunitXmlLogger.php',
     ];
 
     /**

src/Bootstrappers/BootSubscribers.php

@@ -13,14 +13,14 @@ use PHPUnit\Event\Subscriber;
 /**
  * @internal
  */
-final class BootSubscribers implements Bootstrapper
+final readonly class BootSubscribers implements Bootstrapper
 {
     /**
      * The list of Subscribers.
      *
      * @var array<int, class-string<Subscriber>>
      */
-    private const SUBSCRIBERS = [
+    private const array SUBSCRIBERS = [
         Subscribers\EnsureConfigurationIsAvailable::class,
         Subscribers\EnsureIgnorableTestCasesAreIgnored::class,
         Subscribers\EnsureKernelDumpIsFlushed::class,
@@ -31,9 +31,8 @@ final class BootSubscribers implements Bootstrapper
      * Creates a new instance of the Boot Subscribers.
      */
     public function __construct(
-        private readonly Container $container,
-    ) {
-    }
+        private Container $container,
+    ) {}
 
     /**
      * Boots the list of Subscribers.

src/Bootstrappers/BootView.php

@@ -11,13 +11,13 @@ use Symfony\Component\Console\Output\OutputInterface;
 /**
  * @internal
  */
-final class BootView implements Bootstrapper
+final readonly class BootView implements Bootstrapper
 {
     /**
      * Creates a new instance of the Boot View.
      */
     public function __construct(
-        private readonly OutputInterface $output
+        private OutputInterface $output
     ) {
         // ..
     }

src/Collision/Events.php

@@ -0,0 +1,100 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Collision;
+
+use NunoMaduro\Collision\Adapters\Phpunit\TestResult;
+use Pest\Configuration\Project;
+use Symfony\Component\Console\Output\OutputInterface;
+
+use function Termwind\render;
+use function Termwind\renderUsing;
+
+/**
+ * @internal
+ */
+final class Events
+{
+    /**
+     * Sets the output.
+     */
+    private static ?OutputInterface $output = null;
+
+    /**
+     * Sets the output.
+     */
+    public static function setOutput(OutputInterface $output): void
+    {
+        self::$output = $output;
+    }
+
+    /**
+     * Fires before the test method description is printed.
+     */
+    public static function beforeTestMethodDescription(TestResult $result, string $description): string
+    {
+        if (($context = $result->context) === []) {
+            return $description;
+        }
+
+        renderUsing(self::$output);
+
+        [
+            'assignees' => $assignees,
+            'issues' => $issues,
+            'prs' => $prs,
+        ] = $context;
+
+        if (($link = Project::getInstance()->issues) !== '') {
+            $issuesDescription = array_map(fn (int $issue): string => sprintf('<a href="%s">#%s</a>', sprintf($link, $issue), $issue), $issues);
+        }
+
+        if (($link = Project::getInstance()->prs) !== '') {
+            $prsDescription = array_map(fn (int $pr): string => sprintf('<a href="%s">#%s</a>', sprintf($link, $pr), $pr), $prs);
+        }
+
+        if (($link = Project::getInstance()->assignees) !== '' && count($assignees) > 0) {
+            $assigneesDescription = array_map(fn (string $assignee): string => sprintf(
+                '<a href="%s">@%s</a>',
+                sprintf($link, $assignee),
+                $assignee,
+            ), $assignees);
+        }
+
+        if (count($assignees) > 0 || count($issues) > 0 || count($prs) > 0) {
+            $description .= ' '.implode(', ', array_merge(
+                $issuesDescription ?? [],
+                $prsDescription ?? [],
+                isset($assigneesDescription) ? ['['.implode(', ', $assigneesDescription).']'] : [],
+            ));
+        }
+
+        return $description;
+    }
+
+    /**
+     * Fires after the test method description is printed.
+     */
+    public static function afterTestMethodDescription(TestResult $result): void
+    {
+        if (($context = $result->context) === []) {
+            return;
+        }
+
+        renderUsing(self::$output);
+
+        [
+            'notes' => $notes,
+        ] = $context;
+
+        foreach ($notes as $note) {
+            render(sprintf(<<<'HTML'
+                <div class="ml-2">
+                    <span class="text-gray"> // %s</span>
+                </div>
+                HTML, $note,
+            ));
+        }
+    }
+}

src/Concerns/Extendable.php

@@ -8,6 +8,8 @@ use Closure;
 
 /**
  * @internal
+ *
+ * @template T of object
  */
 trait Extendable
 {
@@ -20,6 +22,8 @@ trait Extendable
 
     /**
      * Register a new extend.
+     *
+     * @param-closure-this T $extend
      */
     public function extend(string $name, Closure $extend): void
     {

src/Concerns/Pipeable.php

@@ -5,7 +5,6 @@ declare(strict_types=1);
 namespace Pest\Concerns;
 
 use Closure;
-use Pest\Expectation;
 
 /**
  * @internal
@@ -37,7 +36,7 @@ trait Pipeable
     /**
      * Register an interceptor that should replace an existing expectation.
      *
-     * @param string|Closure(mixed $value, mixed ...$arguments):bool $filter
+     * @param  string|Closure(mixed $value, mixed ...$arguments):bool  $filter
      */
     public function intercept(string $name, string|Closure $filter, Closure $handler): void
     {
@@ -61,7 +60,7 @@ trait Pipeable
     }
 
     /**
-     * Get th list of pipes by the given name.
+     * Get the list of pipes by the given name.
      *
      * @return array<int, Closure>
      */

src/Concerns/Testable.php

@@ -5,14 +5,19 @@ declare(strict_types=1);
 namespace Pest\Concerns;
 
 use Closure;
-use Pest\Exceptions\DatasetArgsCountMismatch;
+use Pest\Exceptions\DatasetArgumentsMismatch;
+use Pest\Panic;
+use Pest\Preset;
 use Pest\Support\ChainableClosure;
 use Pest\Support\ExceptionTrace;
 use Pest\Support\Reflection;
+use Pest\Support\Shell;
 use Pest\TestSuite;
+use PHPUnit\Framework\Attributes\PostCondition;
 use PHPUnit\Framework\TestCase;
 use ReflectionException;
 use ReflectionFunction;
+use ReflectionParameter;
 use Throwable;
 
 /**
@@ -23,40 +28,81 @@ use Throwable;
 trait Testable
 {
     /**
-     * Test method description.
+     * The test's description.
      */
     private string $__description;
 
     /**
-     * Test "latest" method description.
+     * The test's latest description.
      */
     private static string $__latestDescription;
 
     /**
-     * The Test Case "test" closure.
+     * The test's assignees.
+     */
+    private static array $__latestAssignees = [];
+
+    /**
+     * The test's notes.
+     */
+    private static array $__latestNotes = [];
+
+    /**
+     * The test's issues.
+     *
+     * @var array<int, int>
+     */
+    private static array $__latestIssues = [];
+
+    /**
+     * The test's PRs.
+     *
+     * @var array<int, int>
+     */
+    private static array $__latestPrs = [];
+
+    /**
+     * The test's describing, if any.
+     *
+     * @var array<int, string>
+     */
+    public array $__describing = [];
+
+    /**
+     * Whether the test has ran or not.
+     */
+    public bool $__ran = false;
+
+    /**
+     * The test's test closure.
      */
     private Closure $__test;
 
     /**
-     * The Test Case "setUp" closure.
+     * The test's before each closure.
      */
     private ?Closure $__beforeEach = null;
 
     /**
-     * The Test Case "tearDown" closure.
+     * The test's after each closure.
      */
     private ?Closure $__afterEach = null;
 
     /**
-     * The Test Case "setUpBeforeClass" closure.
+     * The test's before all closure.
      */
     private static ?Closure $__beforeAll = null;
 
     /**
-     * The test "tearDownAfterClass" closure.
+     * The test's after all closure.
      */
     private static ?Closure $__afterAll = null;
 
+    /**
+     * The list of snapshot changes, if any.
+     */
+    private array $__snapshotChanges = [];
+
     /**
      * Resets the test case static properties.
      */
@@ -67,19 +113,15 @@ trait Testable
     }
 
     /**
-     * Creates a new Test Case instance.
+     * Adds a new "note" to the Test Case.
      */
-    public function __construct(string $name)
+    public function note(array|string $note): self
     {
-        parent::__construct($name);
+        $note = is_array($note) ? $note : [$note];
 
-        $test = TestSuite::getInstance()->tests->get(self::$__filename);
+        self::$__latestNotes = array_merge(self::$__latestNotes, $note);
 
-        if ($test->hasMethod($name)) {
-            $method = $test->getMethod($name);
-            $this->__description = self::$__latestDescription = $method->description;
-            $this->__test = $method->getClosure($this);
-        }
+        return $this;
     }
 
     /**
@@ -92,7 +134,7 @@ trait Testable
         }
 
         self::$__beforeAll = (self::$__beforeAll instanceof Closure)
-            ? ChainableClosure::fromStatic(self::$__beforeAll, $hook)
+            ? ChainableClosure::boundStatically(self::$__beforeAll, $hook)
             : $hook;
     }
 
@@ -106,7 +148,7 @@ trait Testable
         }
 
         self::$__afterAll = (self::$__afterAll instanceof Closure)
-            ? ChainableClosure::fromStatic(self::$__afterAll, $hook)
+            ? ChainableClosure::boundStatically(self::$__afterAll, $hook)
             : $hook;
     }
 
@@ -136,7 +178,7 @@ trait Testable
         }
 
         $this->{$property} = ($this->{$property} instanceof Closure)
-            ? ChainableClosure::from($this->{$property}, $hook)
+            ? ChainableClosure::bound($this->{$property}, $hook)
             : $hook;
     }
 
@@ -150,10 +192,14 @@ trait Testable
         $beforeAll = TestSuite::getInstance()->beforeAll->get(self::$__filename);
 
         if (self::$__beforeAll instanceof Closure) {
-            $beforeAll = ChainableClosure::fromStatic(self::$__beforeAll, $beforeAll);
+            $beforeAll = ChainableClosure::boundStatically(self::$__beforeAll, $beforeAll);
         }
 
-        call_user_func(Closure::bind($beforeAll, null, self::class));
+        try {
+            call_user_func(Closure::bind($beforeAll, null, self::class));
+        } catch (Throwable $e) {
+            Panic::with($e);
+        }
     }
 
     /**
@@ -164,7 +210,7 @@ trait Testable
         $afterAll = TestSuite::getInstance()->afterAll->get(self::$__filename);
 
         if (self::$__afterAll instanceof Closure) {
-            $afterAll = ChainableClosure::fromStatic(self::$__afterAll, $afterAll);
+            $afterAll = ChainableClosure::boundStatically(self::$__afterAll, $afterAll);
         }
 
         call_user_func(Closure::bind($afterAll, null, self::class));
@@ -175,37 +221,101 @@ trait Testable
     /**
      * Gets executed before the Test Case.
      */
-    protected function setUp(): void
+    protected function setUp(...$arguments): void
     {
         TestSuite::getInstance()->test = $this;
 
+        $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
+
+        $description = $method->description;
+        if ($this->dataName()) {
+            $description = str_contains((string) $description, ':dataset')
+                ? str_replace(':dataset', str_replace('dataset ', '', $this->dataName()), (string) $description)
+                : $description.' with '.$this->dataName();
+        }
+
+        $description = htmlspecialchars(html_entity_decode((string) $description), ENT_NOQUOTES);
+
+        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;
+        self::$__latestAssignees = $method->assignees;
+        self::$__latestNotes = $method->notes;
+        self::$__latestIssues = $method->issues;
+        self::$__latestPrs = $method->prs;
+
         parent::setUp();
 
         $beforeEach = TestSuite::getInstance()->beforeEach->get(self::$__filename)[1];
 
         if ($this->__beforeEach instanceof Closure) {
-            $beforeEach = ChainableClosure::from($this->__beforeEach, $beforeEach);
+            $beforeEach = ChainableClosure::bound($this->__beforeEach, $beforeEach);
         }
 
-        $this->__callClosure($beforeEach, func_get_args());
+        $this->__callClosure($beforeEach, $arguments);
+    }
+
+    /**
+     * Initialize test case properties from TestSuite.
+     */
+    public function __initializeTestCase(): void
+    {
+        // Return if the test case has already been initialized
+        if (isset($this->__test)) {
+            return;
+        }
+
+        $name = $this->name();
+        $test = TestSuite::getInstance()->tests->get(self::$__filename);
+
+        if ($test->hasMethod($name)) {
+            $method = $test->getMethod($name);
+            $this->__description = self::$__latestDescription = $method->description;
+            self::$__latestAssignees = $method->assignees;
+            self::$__latestNotes = $method->notes;
+            self::$__latestIssues = $method->issues;
+            self::$__latestPrs = $method->prs;
+            $this->__describing = $method->describing;
+            $this->__test = $method->getClosure();
+
+            $method->setUp($this);
+        }
     }
 
     /**
      * Gets executed after the Test Case.
      */
-    protected function tearDown(): void
+    protected function tearDown(...$arguments): void
     {
         $afterEach = TestSuite::getInstance()->afterEach->get(self::$__filename);
 
         if ($this->__afterEach instanceof Closure) {
-            $afterEach = ChainableClosure::from($this->__afterEach, $afterEach);
+            $afterEach = ChainableClosure::bound($this->__afterEach, $afterEach);
         }
 
-        $this->__callClosure($afterEach, func_get_args());
+        try {
+            $this->__callClosure($afterEach, func_get_args());
+        } finally {
+            parent::tearDown();
 
-        parent::tearDown();
+            TestSuite::getInstance()->test = null;
 
-        TestSuite::getInstance()->test = null;
+            $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
+            $method->tearDown($this);
+        }
     }
 
     /**
@@ -216,7 +326,7 @@ trait Testable
     private function __runTest(Closure $closure, ...$args): mixed
     {
         $arguments = $this->__resolveTestArguments($args);
-        $this->__ensureDatasetArgumentNumberMatches($arguments);
+        $this->__ensureDatasetArgumentNameAndNumberMatches($arguments);
 
         return $this->__callClosure($closure, $arguments);
     }
@@ -230,7 +340,14 @@ trait Testable
     {
         $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
 
-        $this->__description = self::$__latestDescription = $this->dataName() ? $method->description.' with '.$this->dataName() : $method->description;
+        if ($method->repetitions > 1) {
+            // If the test is repeated, the first argument is the iteration number
+            // we need to move it to the end of the arguments list
+            // so that the datasets are the first n arguments
+            // and the iteration number is the last argument
+            $firstArgument = array_shift($arguments);
+            $arguments[] = $firstArgument;
+        }
 
         $underlyingTest = Reflection::getFunctionVariable($this->__test, 'closure');
         $testParameterTypes = array_values(Reflection::getFunctionArguments($underlyingTest));
@@ -251,11 +368,11 @@ trait Testable
             return $arguments;
         }
 
-        if (! $arguments[0] instanceof Closure) {
+        if (! isset($arguments[0]) || ! $arguments[0] instanceof Closure) {
             return $arguments;
         }
 
-        if (in_array($testParameterTypes[0], [Closure::class, 'callable'])) {
+        if (isset($testParameterTypes[0]) && in_array($testParameterTypes[0], [Closure::class, 'callable'])) {
             return $arguments;
         }
 
@@ -274,9 +391,9 @@ trait Testable
      * Ensures dataset items count matches underlying test case required parameters
      *
      * @throws ReflectionException
-     * @throws DatasetArgsCountMismatch
+     * @throws DatasetArgumentsMismatch
      */
-    private function __ensureDatasetArgumentNumberMatches(array $arguments): void
+    private function __ensureDatasetArgumentNameAndNumberMatches(array $arguments): void
     {
         if ($arguments === []) {
             return;
@@ -287,11 +404,21 @@ trait Testable
         $requiredParametersCount = $testReflection->getNumberOfRequiredParameters();
         $suppliedParametersCount = count($arguments);
 
-        if ($suppliedParametersCount >= $requiredParametersCount) {
+        $datasetParameterNames = array_keys($arguments);
+        $testParameterNames = array_map(
+            fn (ReflectionParameter $reflectionParameter): string => $reflectionParameter->getName(),
+            array_filter($testReflection->getParameters(), fn (ReflectionParameter $reflectionParameter): bool => ! $reflectionParameter->isOptional()),
+        );
+
+        if (array_diff($testParameterNames, $datasetParameterNames) === []) {
             return;
         }
 
-        throw new DatasetArgsCountMismatch($requiredParametersCount, $suppliedParametersCount);
+        if (isset($testParameterNames[0]) && $suppliedParametersCount >= $requiredParametersCount) {
+            return;
+        }
+
+        throw new DatasetArgumentsMismatch($requiredParametersCount, $suppliedParametersCount);
     }
 
     /**
@@ -302,6 +429,24 @@ trait Testable
         return ExceptionTrace::ensure(fn (): mixed => call_user_func_array(Closure::bind($closure, $this, $this::class), $arguments));
     }
 
+    /**
+     * Uses the given preset on the test.
+     */
+    public function preset(): Preset
+    {
+        return new Preset;
+    }
+
+    #[PostCondition]
+    protected function __MarkTestIncompleteIfSnapshotHaveChanged(): void
+    {
+        if (count($this->__snapshotChanges) === 0) {
+            return;
+        }
+
+        $this->markTestIncomplete(implode('. ', $this->__snapshotChanges));
+    }
+
     /**
      * The printable test case name.
      */
@@ -323,6 +468,27 @@ trait Testable
      */
     public static function getLatestPrintableTestCaseMethodName(): string
     {
-        return self::$__latestDescription;
+        return self::$__latestDescription ?? '';
+    }
+
+    /**
+     * The printable test case method context.
+     */
+    public static function getPrintableContext(): array
+    {
+        return [
+            'assignees' => self::$__latestAssignees,
+            'issues' => self::$__latestIssues,
+            'prs' => self::$__latestPrs,
+            'notes' => self::$__latestNotes,
+        ];
+    }
+
+    /**
+     * Opens a shell for the test case.
+     */
+    public function shell(): void
+    {
+        Shell::open();
     }
 }

src/Configuration.php

@@ -0,0 +1,131 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest;
+
+use Pest\PendingCalls\BeforeEachCall;
+use Pest\PendingCalls\UsesCall;
+
+/**
+ * @internal
+ *
+ * @mixin UsesCall
+ */
+final readonly class Configuration
+{
+    /**
+     * The filename of the configuration.
+     */
+    private string $filename;
+
+    /**
+     * Creates a new configuration instance.
+     */
+    public function __construct(
+        string $filename,
+    ) {
+        $this->filename = str_ends_with($filename, DIRECTORY_SEPARATOR.'Pest.php') ? dirname($filename) : $filename;
+    }
+
+    /**
+     * Use the given classes and traits in the given targets.
+     */
+    public function in(string ...$targets): UsesCall
+    {
+        return new UsesCall($this->filename, [])->in(...$targets);
+    }
+
+    /**
+     * Depending on where is called, it will extend the given classes and traits globally or locally.
+     */
+    public function extend(string ...$classAndTraits): UsesCall
+    {
+        return new UsesCall(
+            $this->filename,
+            array_values($classAndTraits)
+        );
+    }
+
+    /**
+     * Depending on where is called, it will extend the given classes and traits globally or locally.
+     */
+    public function extends(string ...$classAndTraits): UsesCall
+    {
+        return $this->extend(...$classAndTraits);
+    }
+
+    /**
+     * Depending on where is called, it will add the given groups globally or locally.
+     */
+    public function group(string ...$groups): UsesCall
+    {
+        return new UsesCall($this->filename, [])->group(...$groups);
+    }
+
+    /**
+     * Marks all tests in the current file to be run exclusively.
+     */
+    public function only(): void
+    {
+        new BeforeEachCall(TestSuite::getInstance(), $this->filename)->only();
+    }
+
+    /**
+     * Depending on where is called, it will extend the given classes and traits globally or locally.
+     */
+    public function use(string ...$classAndTraits): UsesCall
+    {
+        return $this->extend(...$classAndTraits);
+    }
+
+    /**
+     * Depending on where is called, it will extend the given classes and traits globally or locally.
+     */
+    public function uses(string ...$classAndTraits): UsesCall
+    {
+        return $this->extends(...$classAndTraits);
+    }
+
+    /**
+     * Gets the printer configuration.
+     */
+    public function printer(): Configuration\Printer
+    {
+        return new Configuration\Printer;
+    }
+
+    /**
+     * Gets the presets configuration.
+     */
+    public function presets(): Configuration\Presets
+    {
+        return new Configuration\Presets;
+    }
+
+    /**
+     * Gets the project configuration.
+     */
+    public function project(): Configuration\Project
+    {
+        return Configuration\Project::getInstance();
+    }
+
+    /**
+     * Gets the browser configuration.
+     */
+    public function browser(): Browser\Configuration
+    {
+        return new Browser\Configuration;
+    }
+
+    /**
+     * Proxies calls to the uses method.
+     *
+     * @param  array<array-key, mixed>  $arguments
+     */
+    public function __call(string $name, array $arguments): mixed
+    {
+        return $this->uses()->$name(...$arguments); // @phpstan-ignore-line
+    }
+}

src/Configuration/Presets.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Configuration;
+
+use Closure;
+use Pest\Preset;
+
+final class Presets
+{
+    /**
+     * Creates a custom preset instance, and adds it to the list of presets.
+     */
+    public function custom(string $name, Closure $execute): void
+    {
+        Preset::custom($name, $execute);
+    }
+}

src/Configuration/Printer.php

@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Configuration;
+
+use NunoMaduro\Collision\Adapters\Phpunit\Printers\DefaultPrinter;
+
+/**
+ * @internal
+ */
+final readonly class Printer
+{
+    /**
+     * Sets the theme to compact.
+     */
+    public function compact(): self
+    {
+        DefaultPrinter::compact(true);
+
+        return $this;
+    }
+}

src/Configuration/Project.php

@@ -0,0 +1,109 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Configuration;
+
+/**
+ * @internal
+ */
+final class Project
+{
+    /**
+     * The assignees link.
+     *
+     * @internal
+     */
+    public string $assignees = '';
+
+    /**
+     * The issues link.
+     *
+     * @internal
+     */
+    public string $issues = '';
+
+    /**
+     * The PRs link.
+     *
+     * @internal
+     */
+    public string $prs = '';
+
+    /**
+     * The singleton instance.
+     */
+    private static ?self $instance = null;
+
+    /**
+     * Creates a new instance of the project.
+     */
+    public static function getInstance(): self
+    {
+        return self::$instance ??= new self;
+    }
+
+    /**
+     * Sets the test project to GitHub.
+     */
+    public function github(string $project): self
+    {
+        $this->issues = "https://github.com/{$project}/issues/%s";
+        $this->prs = "https://github.com/{$project}/pull/%s";
+
+        $this->assignees = 'https://github.com/%s';
+
+        return $this;
+    }
+
+    /**
+     * Sets the test project to GitLab.
+     */
+    public function gitlab(string $project): self
+    {
+        $this->issues = "https://gitlab.com/{$project}/issues/%s";
+        $this->prs = "https://gitlab.com/{$project}/merge_requests/%s";
+
+        $this->assignees = 'https://gitlab.com/%s';
+
+        return $this;
+    }
+
+    /**
+     * Sets the test project to Bitbucket.
+     */
+    public function bitbucket(string $project): self
+    {
+        $this->issues = "https://bitbucket.org/{$project}/issues/%s";
+        $this->prs = "https://bitbucket.org/{$project}/pull-requests/%s";
+
+        $this->assignees = 'https://bitbucket.org/%s';
+
+        return $this;
+    }
+
+    /**
+     * Sets the test project to Jira.
+     */
+    public function jira(string $namespace, string $project): self
+    {
+        $this->issues = "https://{$namespace}.atlassian.net/browse/{$project}-%s";
+
+        $this->assignees = "https://{$namespace}.atlassian.net/secure/ViewProfile.jspa?name=%s";
+
+        return $this;
+    }
+
+    /**
+     * Sets the test project to custom.
+     */
+    public function custom(string $issues, string $prs, string $assignees): self
+    {
+        $this->issues = $issues;
+        $this->prs = $prs;
+
+        $this->assignees = $assignees;
+
+        return $this;
+    }
+}

src/Console/Help.php

@@ -9,14 +9,14 @@ use Symfony\Component\Console\Output\OutputInterface;
 /**
  * @internal
  */
-final class Help
+final readonly class Help
 {
     /**
      * The Command messages.
      *
      * @var array<int, string>
      */
-    private const HELP_MESSAGES = [
+    private const array HELP_MESSAGES = [
         '<comment>Pest Options:</comment>',
         '  <info>--init</info>                      Initialise a standard Pest configuration',
         '  <info>--coverage</info>                  Enable coverage and output to standard output',
@@ -27,7 +27,7 @@ final class Help
     /**
      * Creates a new Console Command instance.
      */
-    public function __construct(private readonly OutputInterface $output)
+    public function __construct(private OutputInterface $output)
     {
         // ..
     }

src/Console/Thanks.php

@@ -15,25 +15,30 @@ use Symfony\Component\Console\Question\ConfirmationQuestion;
 /**
  * @internal
  */
-final class Thanks
+final readonly 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',
+    private const array FUNDING_MESSAGES = [
+        'Star' => 'https://github.com/pestphp/pest',
+        'YouTube' => 'https://youtube.com/@nunomaduro',
+        'TikTok' => 'https://tiktok.com/@enunomaduro',
+        'Twitch' => 'https://twitch.tv/nunomaduro',
+        'LinkedIn' => 'https://linkedin.com/in/nunomaduro',
+        'Instagram' => 'https://instagram.com/enunomaduro',
+        'X' => 'https://x.com/enunomaduro',
+        'Sponsor' => 'https://github.com/sponsors/nunomaduro',
     ];
 
     /**
      * Creates a new Console Command instance.
      */
     public function __construct(
-        private readonly InputInterface $input,
-        private readonly OutputInterface $output
+        private InputInterface $input,
+        private OutputInterface $output
     ) {
         // ..
     }
@@ -49,7 +54,7 @@ final class Thanks
         $wantsToSupport = false;
 
         if (getenv('PEST_NO_SUPPORT') !== 'true' && $this->input->isInteractive()) {
-            $wantsToSupport = (new SymfonyQuestionHelper())->ask(
+            $wantsToSupport = (new SymfonyQuestionHelper)->ask(
                 new ArrayInput([]),
                 $this->output,
                 new ConfirmationQuestion(
@@ -71,13 +76,13 @@ final class Thanks
         }
 
         if ($wantsToSupport === true) {
-            if (PHP_OS_FAMILY == 'Darwin') {
+            if (PHP_OS_FAMILY === 'Darwin') {
                 exec('open https://github.com/pestphp/pest');
             }
-            if (PHP_OS_FAMILY == 'Windows') {
+            if (PHP_OS_FAMILY === 'Windows') {
                 exec('start https://github.com/pestphp/pest');
             }
-            if (PHP_OS_FAMILY == 'Linux') {
+            if (PHP_OS_FAMILY === 'Linux') {
                 exec('xdg-open https://github.com/pestphp/pest');
             }
         }

src/Contracts/AddsAnnotations.php

@@ -1,21 +0,0 @@
-<?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/ArchPreset.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Contracts;
+
+/**
+ * @internal
+ */
+interface ArchPreset {}

src/Contracts/Plugins/HandlesOriginalArguments.php

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

src/Contracts/Plugins/Terminable.php

@@ -7,10 +7,10 @@ namespace Pest\Contracts\Plugins;
 /**
  * @internal
  */
-interface Shutdownable
+interface Terminable
 {
     /**
-     * Shutdowns the plugin.
+     * Terminates the plugin.
      */
-    public function shutdown(): void;
+    public function terminate(): void;
 }

src/Evaluators/Attributes.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Evaluators;
+
+use Pest\Factories\Attribute;
+
+/**
+ * @internal
+ */
+final class Attributes
+{
+    /**
+     * Evaluates the given attributes and returns the code.
+     *
+     * @param  iterable<int, Attribute>  $attributes
+     */
+    public static function code(iterable $attributes): string
+    {
+        return implode(PHP_EOL, array_map(function (Attribute $attribute): string {
+            $name = $attribute->name;
+
+            if ($attribute->arguments === []) {
+                return "    #[\\{$name}]";
+            }
+
+            $arguments = array_map(fn (string $argument): string => var_export($argument, true), iterator_to_array($attribute->arguments));
+
+            return sprintf('    #[\\%s(%s)]', $name, implode(', ', $arguments));
+        }, iterator_to_array($attributes)));
+    }
+}

src/Exceptions/AfterAllWithinDescribe.php

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

src/Exceptions/AfterBeforeTestFunction.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 AfterBeforeTestFunction extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
+{
+    /**
+     * Creates a new Exception instance.
+     */
+    public function __construct(string $filename)
+    {
+        parent::__construct('After method cannot be used with before the [test|it] functions in the filename `['.$filename.']`.');
+    }
+}

src/Exceptions/BeforeAllAlreadyExist.php

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

src/Exceptions/BeforeAllWithinDescribe.php

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

src/Exceptions/DatasetArgsCountMismatch.php

@@ -1,15 +0,0 @@
-<?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/DatasetArgumentsMismatch.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use Exception;
+
+final class DatasetArgumentsMismatch extends Exception
+{
+    public function __construct(int $requiredCount, int $suppliedCount)
+    {
+        if ($requiredCount <= $suppliedCount) {
+            parent::__construct('Test argument names and dataset keys do not match');
+        } else {
+            parent::__construct(sprintf('Test expects %d arguments but dataset only provides %d', $requiredCount, $suppliedCount));
+        }
+    }
+
+    //
+}

src/Exceptions/DatasetMissing.php

@@ -22,7 +22,7 @@ final class DatasetMissing extends BadFunctionCallException implements Exception
     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",
+            '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)),

src/Exceptions/FatalException.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use NunoMaduro\Collision\Contracts\RenderlessTrace;
+use RuntimeException;
+
+/**
+ * @internal
+ */
+final class FatalException extends RuntimeException implements RenderlessTrace
+{
+    //
+}

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

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

src/Exceptions/ShouldNotHappen.php

@@ -20,7 +20,7 @@ final class ShouldNotHappen extends RuntimeException
         $message = $exception->getMessage();
 
         parent::__construct(sprintf(<<<'EOF'
-This should not happen - please create an new issue here: https://github.com/pestphp/pest.
+This should not happen - please create an new issue here: https://github.com/pestphp/pest/issues
 
   Issue: %s
   PHP version: %s

src/Exceptions/TestCaseAlreadyInUse.php

@@ -19,7 +19,11 @@ final class TestCaseAlreadyInUse extends InvalidArgumentException implements Exc
      */
     public function __construct(string $inUse, string $newOne, string $folder)
     {
-        parent::__construct(sprintf('Test case `%s` can not be used. The folder `%s` already uses the test case `%s`',
-            $newOne, $folder, $inUse));
+        parent::__construct(sprintf(
+            'Test case [%s] can not be used. The folder [%s] already uses the test case [%s].',
+            $newOne,
+            $folder,
+            $inUse,
+        ));
     }
 }

src/Exceptions/TestClosureMustNotBeStatic.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use InvalidArgumentException;
+use NunoMaduro\Collision\Contracts\RenderlessEditor;
+use NunoMaduro\Collision\Contracts\RenderlessTrace;
+use Pest\Factories\TestCaseMethodFactory;
+use Symfony\Component\Console\Exception\ExceptionInterface;
+
+/**
+ * @internal
+ */
+final class TestClosureMustNotBeStatic extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
+{
+    /**
+     * Creates a new Exception instance.
+     */
+    public function __construct(TestCaseMethodFactory $method)
+    {
+        parent::__construct(
+            sprintf(
+                'Test closure must not be static. Please remove the [static] keyword from the [%s] method in [%s].',
+                $method->description,
+                $method->filename
+            )
+        );
+    }
+}

src/Expectation.php

@@ -4,15 +4,21 @@ 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;
@@ -24,22 +30,31 @@ use Pest\Expectations\HigherOrderExpectation;
 use Pest\Expectations\OppositeExpectation;
 use Pest\Matchers\Any;
 use Pest\Support\ExpectationPipeline;
-use PHPUnit\Framework\Assert;
+use Pest\Support\Reflection;
+use PHPUnit\Architecture\Elements\ObjectDescription;
 use PHPUnit\Framework\ExpectationFailedException;
+use ReflectionEnum;
+use ReflectionMethod;
+use ReflectionProperty;
 
 /**
- * @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<self<TValue>> */
     use Extendable;
+
     use Pipeable;
     use Retrievable;
 
@@ -118,6 +133,40 @@ final class Expectation
         exit(1);
     }
 
+    /**
+     * Dump the expectation value when the result of the condition is truthy.
+     *
+     * @param  (\Closure(TValue): bool)|bool  $condition
+     * @return self<TValue>
+     */
+    public function ddWhen(Closure|bool $condition, mixed ...$arguments): Expectation
+    {
+        $condition = $condition instanceof Closure ? $condition($this->value) : $condition;
+
+        if (! $condition) {
+            return $this;
+        }
+
+        $this->dd(...$arguments);
+    }
+
+    /**
+     * Dump the expectation value when the result of the condition is falsy.
+     *
+     * @param  (\Closure(TValue): bool)|bool  $condition
+     * @return self<TValue>
+     */
+    public function ddUnless(Closure|bool $condition, mixed ...$arguments): Expectation
+    {
+        $condition = $condition instanceof Closure ? $condition($this->value) : $condition;
+
+        if ($condition) {
+            return $this;
+        }
+
+        $this->dd(...$arguments);
+    }
+
     /**
      * Send the expectation value to Ray along with all given arguments.
      *
@@ -147,7 +196,7 @@ final class Expectation
      *
      * @return EachExpectation<TValue>
      */
-    public function each(callable $callback = null): EachExpectation
+    public function each(?callable $callback = null): EachExpectation
     {
         if (! is_iterable($this->value)) {
             throw new BadMethodCallException('Expectation value is not iterable.');
@@ -167,7 +216,7 @@ final class Expectation
      *
      * @template TSequenceValue
      *
-     * @param (callable(self<TValue>, self<string|int>): void)|TSequenceValue ...$callbacks
+     * @param  (callable(self<TValue>, self<string|int>): void)|TSequenceValue  ...$callbacks
      * @return self<TValue>
      */
     public function sequence(mixed ...$callbacks): self
@@ -176,30 +225,26 @@ final class Expectation
             throw new BadMethodCallException('Expectation value is not iterable.');
         }
 
-        $value = is_array($this->value) ? $this->value : iterator_to_array($this->value);
-        $keys = array_keys($value);
-        $values = array_values($value);
-        $callbacksCount = count($callbacks);
-
-        $index = 0;
-
-        while (count($callbacks) < count($values)) {
-            $callbacks[] = $callbacks[$index];
-            $index = $index < count($values) - 1 ? $index + 1 : 0;
+        if ($callbacks === []) {
+            throw new InvalidArgumentException('No sequence expectations defined.');
         }
 
-        if ($callbacksCount > count($values)) {
-            Assert::assertLessThanOrEqual(count($value), count($callbacks));
-        }
+        $index = $valuesCount = 0;
 
-        foreach ($values as $key => $item) {
-            if ($callbacks[$key] instanceof Closure) {
-                call_user_func($callbacks[$key], new self($item), new self($keys[$key]));
+        foreach ($this->value as $key => $value) {
+            $valuesCount++;
 
-                continue;
+            if ($callbacks[$index] instanceof Closure) {
+                $callbacks[$index](new self($value), new self($key));
+            } else {
+                new self($value)->toEqual($callbacks[$index]);
             }
 
-            (new self($item))->toEqual($callbacks[$key]);
+            $index = isset($callbacks[$index + 1]) ? $index + 1 : 0;
+        }
+
+        if ($valuesCount < count($callbacks)) {
+            throw new OutOfRangeException('Sequence expectations are more than the iterable items.');
         }
 
         return $this;
@@ -210,8 +255,8 @@ final class Expectation
      *
      * @template TMatchSubject of array-key
      *
-     * @param (callable(): TMatchSubject)|TMatchSubject $subject
-     * @param array<TMatchSubject, (callable(self<TValue>): mixed)|TValue> $expressions
+     * @param  (callable(): TMatchSubject)|TMatchSubject  $subject
+     * @param  array<TMatchSubject, (callable(self<TValue>): mixed)|TValue>  $expressions
      * @return self<TValue>
      */
     public function match(mixed $subject, array $expressions): self
@@ -221,7 +266,7 @@ final class Expectation
         $matched = false;
 
         foreach ($expressions as $key => $callback) {
-            if ($subject != $key) {
+            if ($subject != $key) { // @pest-arch-ignore-line
                 continue;
             }
 
@@ -248,7 +293,7 @@ final class Expectation
     /**
      * Apply the callback if the given "condition" is falsy.
      *
-     * @param (callable(): bool)|bool $condition
+     * @param  (callable(): bool)|bool  $condition
      * @param  callable(Expectation<TValue>): mixed  $callback
      * @return self<TValue>
      */
@@ -264,7 +309,7 @@ final class Expectation
     /**
      * Apply the callback if the given "condition" is truthy.
      *
-     * @param (callable(): bool)|bool $condition
+     * @param  (callable(): bool)|bool  $condition
      * @param  callable(self<TValue>): mixed  $callback
      * @return self<TValue>
      */
@@ -287,16 +332,40 @@ final class Expectation
      * @param  array<int, mixed>  $parameters
      * @return Expectation<TValue>|HigherOrderExpectation<Expectation<TValue>, TValue>
      */
-    public function __call(string $method, array $parameters): Expectation|HigherOrderExpectation
+    public function __call(string $method, array $parameters): Expectation|HigherOrderExpectation|PendingArchExpectation|ArchExpectation
     {
         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))
+        $closure = $this->getExpectationClosure($method);
+        $reflectionClosure = new \ReflectionFunction($closure);
+        $expectation = $reflectionClosure->getClosureThis();
+
+        if ($reflectionClosure->getReturnType()?->__toString() === ArchExpectation::class) {
+            return $closure(...$parameters);
+        }
+
+        assert(is_object($expectation));
+
+        ExpectationPipeline::for($closure)
             ->send(...$parameters)
-            ->through($this->pipes($method, $this, Expectation::class))
+            ->through($this->pipes($method, $expectation, Expectation::class))
             ->run();
 
         return $this;
@@ -317,7 +386,7 @@ final class Expectation
         if (self::hasExtend($name)) {
             $extend = self::$extends[$name]->bindTo($this, Expectation::class);
 
-            if ($extend != false) {
+            if ($extend != false) { // @pest-arch-ignore-line
                 return $extend;
             }
         }
@@ -330,9 +399,14 @@ final class Expectation
      *
      * @return Expectation<TValue>|OppositeExpectation<TValue>|EachExpectation<TValue>|HigherOrderExpectation<Expectation<TValue>, TValue|null>|TValue
      */
-    public function __get(string $name)
+    public function __get(string $name): mixed
     {
         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));
         }
@@ -356,7 +430,7 @@ final class Expectation
      */
     public function any(): Any
     {
-        return new Any();
+        return new Any;
     }
 
     /**
@@ -369,6 +443,433 @@ final class Expectation
         return ToUse::make($this, $targets);
     }
 
+    /**
+     * Asserts that the given expectation target does have the given permissions
+     */
+    public function toHaveFileSystemPermissions(string $permissions): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => substr(sprintf('%o', fileperms($object->path)), -4) === $permissions,
+            sprintf('permissions to be [%s]', $permissions),
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, '<?php')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to have line count less than the given number.
+     */
+    public function toHaveLineCountLessThan(int $lines): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => count(file($object->path)) < $lines, // @phpstan-ignore-line
+            sprintf('to have less than %d lines of code', $lines),
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, '<?php')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target have all methods documented.
+     */
+    public function toHaveMethodsDocumented(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false
+                || array_filter(
+                    Reflection::getMethodsFromReflectionClass($object->reflectionClass),
+                    fn (ReflectionMethod $method): bool => (enum_exists($object->name) === false || in_array($method->name, ['from', 'tryFrom', 'cases'], true) === false)
+                        && realpath($method->getFileName() ?: '/') === realpath($object->path) // @phpstan-ignore-line
+                        && $method->getDocComment() === false,
+                ) === [],
+            'to have methods with documentation / annotations',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target have all properties documented.
+     */
+    public function toHavePropertiesDocumented(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false
+                || array_filter(
+                    Reflection::getPropertiesFromReflectionClass($object->reflectionClass),
+                    fn (ReflectionProperty $property): bool => (enum_exists($object->name) === false || in_array($property->name, ['value', 'name'], true) === false)
+                        && realpath($property->getDeclaringClass()->getFileName() ?: '/') === realpath($object->path) // @phpstan-ignore-line
+                        && $property->isPromoted() === false
+                        && $property->getDocComment() === false,
+                ) === [],
+            'to have properties with documentation / annotations',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
+        );
+    }
+
+    /**
+     * 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 => (bool) preg_match('/^<\?php\s*(\/\*[\s\S]*?\*\/|\/\/[^\r\n]*(?:\r?\n|$)|\s)*declare\s*\(\s*strict_types\s*=\s*1\s*\)\s*;/m', (string) file_get_contents($object->path)),
+            'to use strict types',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, '<?php')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target uses strict equality.
+     */
+    public function toUseStrictEquality(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => ! str_contains((string) file_get_contents($object->path), ' == ') && ! str_contains((string) file_get_contents($object->path), ' != '),
+            'to use strict equality',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, ' == ') || str_contains($line, ' != ')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target is final.
+     */
+    public function toBeFinal(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && isset($object->reflectionClass) && $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) && isset($object->reflectionClass) && $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 => isset($object->reflectionClass) && $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 => isset($object->reflectionClass) && $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.
+     *
+     * @param  array<int, string>|string  $method
+     */
+    public function toHaveMethod(array|string $method): ArchExpectation
+    {
+        $methods = is_array($method) ? $method : [$method];
+
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => count(array_filter($methods, fn (string $method): bool => isset($object->reflectionClass) && $object->reflectionClass->hasMethod($method))) === count($methods),
+            sprintf("to have method '%s'", implode("', '", $methods)),
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target has a specific methods.
+     *
+     * @param  array<int, string>  $methods
+     */
+    public function toHaveMethods(array $methods): ArchExpectation
+    {
+        return $this->toHaveMethod($methods);
+    }
+
+    /**
+     * Not supported.
+     */
+    public function toHavePublicMethodsBesides(): void
+    {
+        throw InvalidExpectation::fromMethods(['toHavePublicMethodsBesides']);
+    }
+
+    /**
+     * Not supported.
+     */
+    public function toHavePublicMethods(): void
+    {
+        throw InvalidExpectation::fromMethods(['toHavePublicMethods']);
+    }
+
+    /**
+     * Not supported.
+     */
+    public function toHaveProtectedMethodsBesides(): void
+    {
+        throw InvalidExpectation::fromMethods(['toHaveProtectedMethodsBesides']);
+    }
+
+    /**
+     * Not supported.
+     */
+    public function toHaveProtectedMethods(): void
+    {
+        throw InvalidExpectation::fromMethods(['toHaveProtectedMethods']);
+    }
+
+    /**
+     * Not supported.
+     */
+    public function toHavePrivateMethodsBesides(): void
+    {
+        throw InvalidExpectation::fromMethods(['toHavePrivateMethodsBesides']);
+    }
+
+    /**
+     * Not supported.
+     */
+    public function toHavePrivateMethods(): void
+    {
+        throw InvalidExpectation::fromMethods(['toHavePrivateMethods']);
+    }
+
+    /**
+     * Asserts that the given expectation target is enum.
+     */
+    public function toBeEnum(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && $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 target is a 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 => isset($object->reflectionClass) && $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.
+     */
+    public function toExtend(string $class): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && ($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 use the given trait.
+     */
+    public function toUseTrait(string $trait): ArchExpectation
+    {
+        return $this->toUseTraits($trait);
+    }
+
+    /**
+     * Asserts that the given expectation target to use the given traits.
+     *
+     * @param  array<int, string>|string  $traits
+     */
+    public function toUseTraits(array|string $traits): ArchExpectation
+    {
+        $traits = is_array($traits) ? $traits : [$traits];
+
+        return Targeted::make(
+            $this,
+            function (ObjectDescription $object) use ($traits): bool {
+                foreach ($traits as $trait) {
+                    if (isset($object->reflectionClass) === false) {
+                        return false;
+                    }
+
+                    if (! in_array($trait, $object->reflectionClass->getTraitNames(), true)) {
+                        return false;
+                    }
+                }
+
+                return true;
+            },
+            "to use traits '".implode("', '", $traits)."'",
+            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 => isset($object->reflectionClass) && $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, string>|string  $interfaces
+     */
+    public function toOnlyImplement(array|string $interfaces): ArchExpectation
+    {
+        $interfaces = is_array($interfaces) ? $interfaces : [$interfaces];
+
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass)
+                && (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 => isset($object->reflectionClass) && 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 => isset($object->reflectionClass) && 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, string>|string  $interfaces
+     */
+    public function toImplement(array|string $interfaces): ArchExpectation
+    {
+        $interfaces = is_array($interfaces) ? $interfaces : [$interfaces];
+
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => array_all($interfaces, fn (string $interface): bool => isset($object->reflectionClass) && $object->reflectionClass->implementsInterface($interface)),
+            "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.
      *
@@ -387,7 +888,18 @@ final class Expectation
         return ToUseNothing::make($this);
     }
 
-    public function toBeUsed(): never
+    /**
+     * Asserts that the source code of the given expectation target does not include suspicious characters.
+     */
+    public function toHaveSuspiciousCharacters(): ArchExpectation
+    {
+        throw InvalidExpectation::fromMethods(['toHaveSuspiciousCharacters']);
+    }
+
+    /**
+     * Not supported.
+     */
+    public function toBeUsed(): void
     {
         throw InvalidExpectation::fromMethods(['toBeUsed']);
     }
@@ -419,4 +931,190 @@ final class Expectation
     {
         return ToBeUsedInNothing::make($this);
     }
+
+    /**
+     * Asserts that the given expectation dependency is an invokable class.
+     */
+    public function toBeInvokable(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && $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.
+     */
+    public function toHaveAttribute(string $attribute): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && $object->reflectionClass->getAttributes($attribute) !== [],
+            "to have attribute '{$attribute}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target has a constructor method.
+     */
+    public function toHaveConstructor(): ArchExpectation
+    {
+        return $this->toHaveMethod('__construct');
+    }
+
+    /**
+     * Asserts that the given expectation target has a destructor method.
+     */
+    public function toHaveDestructor(): ArchExpectation
+    {
+        return $this->toHaveMethod('__destruct');
+    }
+
+    /**
+     * Asserts that the given expectation target is a backed enum of given type.
+     */
+    private function toBeBackedEnum(string $backingType): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass)
+                && $object->reflectionClass->isEnum()
+                && new ReflectionEnum($object->name)->isBacked() // @phpstan-ignore-line
+                && (string) new ReflectionEnum($object->name)->getBackingType() === $backingType, // @phpstan-ignore-line
+            'to be '.$backingType.' backed enum',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are string backed enums.
+     */
+    public function toBeStringBackedEnums(): ArchExpectation
+    {
+        return $this->toBeStringBackedEnum();
+    }
+
+    /**
+     * Asserts that the given expectation targets are int backed enums.
+     */
+    public function toBeIntBackedEnums(): ArchExpectation
+    {
+        return $this->toBeIntBackedEnum();
+    }
+
+    /**
+     * Asserts that the given expectation target is a string backed enum.
+     */
+    public function toBeStringBackedEnum(): ArchExpectation
+    {
+        return $this->toBeBackedEnum('string');
+    }
+
+    /**
+     * Asserts that the given expectation target is an int backed enum.
+     */
+    public function toBeIntBackedEnum(): ArchExpectation
+    {
+        return $this->toBeBackedEnum('int');
+    }
 }

src/Expectations/EachExpectation.php

@@ -4,9 +4,10 @@ declare(strict_types=1);
 
 namespace Pest\Expectations;
 
-use function expect;
 use Pest\Expectation;
 
+use function expect;
+
 /**
  * @internal
  *
@@ -16,6 +17,9 @@ use Pest\Expectation;
  */
 final class EachExpectation
 {
+    /**
+     * Indicates if the expectation is the opposite.
+     */
     private bool $opposite = false;
 
     /**
@@ -23,9 +27,7 @@ final class EachExpectation
      *
      * @param  Expectation<TValue>  $original
      */
-    public function __construct(private readonly Expectation $original)
-    {
-    }
+    public function __construct(private readonly Expectation $original) {}
 
     /**
      * Creates a new expectation.

src/Expectations/HigherOrderExpectation.php

@@ -25,8 +25,14 @@ final class HigherOrderExpectation
      */
     private Expectation|EachExpectation $expectation;
 
+    /**
+     * Indicates if the expectation is the opposite.
+     */
     private bool $opposite = false;
 
+    /**
+     * Indicates if the expectation should reset the value.
+     */
     private bool $shouldReset = false;
 
     /**

src/Expectations/OppositeExpectation.php

@@ -4,17 +4,29 @@ declare(strict_types=1);
 
 namespace Pest\Expectations;
 
+use Attribute;
 use Pest\Arch\Contracts\ArchExpectation;
+use Pest\Arch\Expectations\Targeted;
 use Pest\Arch\Expectations\ToBeUsedIn;
 use Pest\Arch\Expectations\ToBeUsedInNothing;
 use Pest\Arch\Expectations\ToUse;
 use Pest\Arch\GroupArchExpectation;
+use Pest\Arch\PendingArchExpectation;
 use Pest\Arch\SingleArchExpectation;
+use Pest\Arch\Support\FileLineFinder;
 use Pest\Exceptions\InvalidExpectation;
+use Pest\Exceptions\MissingDependency;
 use Pest\Expectation;
 use Pest\Support\Arr;
 use Pest\Support\Exporter;
+use Pest\Support\Reflection;
+use PHPUnit\Architecture\Elements\ObjectDescription;
+use PHPUnit\Framework\AssertionFailedError;
 use PHPUnit\Framework\ExpectationFailedException;
+use ReflectionMethod;
+use ReflectionProperty;
+use Spoofchecker;
+use stdClass;
 
 /**
  * @internal
@@ -23,16 +35,14 @@ use PHPUnit\Framework\ExpectationFailedException;
  *
  * @mixin Expectation<TValue>
  */
-final class OppositeExpectation
+final readonly class OppositeExpectation
 {
     /**
      * Creates a new opposite expectation.
      *
      * @param  Expectation<TValue>  $original
      */
-    public function __construct(private readonly Expectation $original)
-    {
-    }
+    public function __construct(private Expectation $original) {}
 
     /**
      * Asserts that the value array not has the provided $keys.
@@ -66,20 +76,600 @@ final class OppositeExpectation
      */
     public function toUse(array|string $targets): ArchExpectation
     {
-        return GroupArchExpectation::fromExpectations($this->original, array_map(fn (string $target): SingleArchExpectation => ToUse::make($this->original, $target)->opposite(
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return GroupArchExpectation::fromExpectations($original, array_map(fn (string $target): SingleArchExpectation => ToUse::make($original, $target)->opposite(
             fn () => $this->throwExpectationFailedException('toUse', $target),
         ), is_string($targets) ? [$targets] : $targets));
     }
 
     /**
-     * @param  array<int, string>|string  $targets
+     * Asserts that the given expectation target does not have the given permissions
      */
-    public function toOnlyUse(array|string $targets): never
+    public function toHaveFileSystemPermissions(string $permissions): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => substr(sprintf('%o', fileperms($object->path)), -4) !== $permissions,
+            sprintf('permissions not to be [%s]', $permissions),
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, '<?php')),
+        );
+    }
+
+    /**
+     * Not supported.
+     */
+    public function toHaveLineCountLessThan(): ArchExpectation
+    {
+        throw InvalidExpectation::fromMethods(['not', 'toHaveLineCountLessThan']);
+    }
+
+    /**
+     * Not supported.
+     */
+    public function toHaveMethodsDocumented(): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false
+                || array_filter(
+                    Reflection::getMethodsFromReflectionClass($object->reflectionClass),
+                    fn (ReflectionMethod $method): bool => (enum_exists($object->name) === false || in_array($method->name, ['from', 'tryFrom', 'cases'], true) === false)
+                        && realpath($method->getFileName() ?: '/') === realpath($object->path) // @phpstan-ignore-line
+                        && $method->getDocComment() !== false,
+                ) === [],
+            'to have methods without documentation / annotations',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
+        );
+    }
+
+    /**
+     * Not supported.
+     */
+    public function toHavePropertiesDocumented(): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false
+                || array_filter(
+                    Reflection::getPropertiesFromReflectionClass($object->reflectionClass),
+                    fn (ReflectionProperty $property): bool => (enum_exists($object->name) === false || in_array($property->name, ['value', 'name'], true) === false)
+                        && realpath($property->getDeclaringClass()->getFileName() ?: '/') === realpath($object->path) // @phpstan-ignore-line
+                        && $property->isPromoted() === false
+                        && $property->getDocComment() !== false,
+                ) === [],
+            'to have properties without documentation / annotations',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target does not use the "declare(strict_types=1)" declaration.
+     */
+    public function toUseStrictTypes(): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => ! (bool) preg_match('/^<\?php\s+declare\(.*?strict_types\s?=\s?1.*?\);/', (string) file_get_contents($object->path)),
+            'not to use strict types',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, '<?php')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target does not use the strict equality operator.
+     */
+    public function toUseStrictEquality(): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => ! str_contains((string) file_get_contents($object->path), ' === ') && ! str_contains((string) file_get_contents($object->path), ' !== '),
+            'to use strict equality',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, ' === ') || str_contains($line, ' !== ')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target is not final.
+     */
+    public function toBeFinal(): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && (isset($object->reflectionClass) === false || ! $object->reflectionClass->isFinal()),
+            'not to be final',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target is not readonly.
+     */
+    public function toBeReadonly(): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && (isset($object->reflectionClass) === false || ! $object->reflectionClass->isReadOnly()) && assert(true), // @phpstan-ignore-line
+            'not to be readonly',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target is not trait.
+     */
+    public function toBeTrait(): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || ! $object->reflectionClass->isTrait(),
+            'not to be trait',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are not traits.
+     */
+    public function toBeTraits(): ArchExpectation
+    {
+        return $this->toBeTrait();
+    }
+
+    /**
+     * Asserts that the given expectation target is not abstract.
+     */
+    public function toBeAbstract(): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || ! $object->reflectionClass->isAbstract(),
+            'not to be abstract',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target does not have a specific method.
+     *
+     * @param  array<int, string>|string  $method
+     */
+    public function toHaveMethod(array|string $method): ArchExpectation
+    {
+        $methods = is_array($method) ? $method : [$method];
+
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => array_filter(
+                $methods,
+                fn (string $method): bool => isset($object->reflectionClass) === false || $object->reflectionClass->hasMethod($method),
+            ) === [],
+            'to not have methods: '.implode(', ', $methods),
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target does not have suspicious characters.
+     */
+    public function toHaveSuspiciousCharacters(): ArchExpectation
+    {
+        if (! class_exists(Spoofchecker::class)) {
+            throw new MissingDependency(__FUNCTION__, 'ext-intl >= 2.0');
+        }
+
+        $checker = new Spoofchecker;
+
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => ! $checker->isSuspicious((string) file_get_contents($object->path)),
+            'to not include suspicious characters',
+            FileLineFinder::where(fn (string $line): bool => $checker->isSuspicious($line)),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target does not have the given methods.
+     *
+     * @param  array<int, string>  $methods
+     */
+    public function toHaveMethods(array $methods): ArchExpectation
+    {
+        return $this->toHaveMethod($methods);
+    }
+
+    /**
+     * Asserts that the given expectation target not to have the public methods besides the given methods.
+     *
+     * @param  array<int, string>|string  $methods
+     */
+    public function toHavePublicMethodsBesides(array|string $methods): ArchExpectation
+    {
+        $methods = is_array($methods) ? $methods : [$methods];
+
+        $state = new stdClass;
+
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            function (ObjectDescription $object) use ($methods, &$state): bool {
+                $reflectionMethods = isset($object->reflectionClass)
+                    ? Reflection::getMethodsFromReflectionClass($object->reflectionClass, ReflectionMethod::IS_PUBLIC)
+                    : [];
+
+                foreach ($reflectionMethods as $reflectionMethod) {
+                    if (! in_array($reflectionMethod->name, $methods, true)) {
+                        $state->contains = 'public function '.$reflectionMethod->name;
+
+                        return false;
+                    }
+                }
+
+                return true;
+            },
+            $methods === []
+                ? 'not to have public methods'
+                : sprintf("not to have public methods besides '%s'", implode("', '", $methods)),
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, (string) $state->contains)),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target not to have the public methods.
+     */
+    public function toHavePublicMethods(): ArchExpectation
+    {
+        return $this->toHavePublicMethodsBesides([]);
+    }
+
+    /**
+     * Asserts that the given expectation target not to have the protected methods besides the given methods.
+     *
+     * @param  array<int, string>|string  $methods
+     */
+    public function toHaveProtectedMethodsBesides(array|string $methods): ArchExpectation
+    {
+        $methods = is_array($methods) ? $methods : [$methods];
+
+        $state = new stdClass;
+
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            function (ObjectDescription $object) use ($methods, &$state): bool {
+                $reflectionMethods = isset($object->reflectionClass)
+                    ? Reflection::getMethodsFromReflectionClass($object->reflectionClass, ReflectionMethod::IS_PROTECTED)
+                    : [];
+
+                foreach ($reflectionMethods as $reflectionMethod) {
+                    if (! in_array($reflectionMethod->name, $methods, true)) {
+                        $state->contains = 'protected function '.$reflectionMethod->name;
+
+                        return false;
+                    }
+                }
+
+                return true;
+            },
+            $methods === []
+                ? 'not to have protected methods'
+                : sprintf("not to have protected methods besides '%s'", implode("', '", $methods)),
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, (string) $state->contains)),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target not to have the protected methods.
+     */
+    public function toHaveProtectedMethods(): ArchExpectation
+    {
+        return $this->toHaveProtectedMethodsBesides([]);
+    }
+
+    /**
+     * Asserts that the given expectation target not to have the private methods besides the given methods.
+     *
+     * @param  array<int, string>|string  $methods
+     */
+    public function toHavePrivateMethodsBesides(array|string $methods): ArchExpectation
+    {
+        $methods = is_array($methods) ? $methods : [$methods];
+
+        $state = new stdClass;
+
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            function (ObjectDescription $object) use ($methods, &$state): bool {
+                $reflectionMethods = isset($object->reflectionClass)
+                    ? Reflection::getMethodsFromReflectionClass($object->reflectionClass, ReflectionMethod::IS_PRIVATE)
+                    : [];
+
+                foreach ($reflectionMethods as $reflectionMethod) {
+                    if (! in_array($reflectionMethod->name, $methods, true)) {
+                        $state->contains = 'private function '.$reflectionMethod->name;
+
+                        return false;
+                    }
+                }
+
+                return true;
+            },
+            $methods === []
+                ? 'not to have private methods'
+                : sprintf("not to have private methods besides '%s'", implode("', '", $methods)),
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, (string) $state->contains)),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target not to have the private methods.
+     */
+    public function toHavePrivateMethods(): ArchExpectation
+    {
+        return $this->toHavePrivateMethodsBesides([]);
+    }
+
+    /**
+     * Asserts that the given expectation target is not enum.
+     */
+    public function toBeEnum(): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || ! $object->reflectionClass->isEnum(),
+            'not to be enum',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are not enums.
+     */
+    public function toBeEnums(): ArchExpectation
+    {
+        return $this->toBeEnum();
+    }
+
+    /**
+     * Asserts that the given expectation targets is not class.
+     */
+    public function toBeClass(): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => ! class_exists($object->name),
+            'not to be class',
+            FileLineFinder::where(fn (string $line): bool => true),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are not classes.
+     */
+    public function toBeClasses(): ArchExpectation
+    {
+        return $this->toBeClass();
+    }
+
+    /**
+     * Asserts that the given expectation target is not interface.
+     */
+    public function toBeInterface(): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || ! $object->reflectionClass->isInterface(),
+            'not to be interface',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are not interfaces.
+     */
+    public function toBeInterfaces(): ArchExpectation
+    {
+        return $this->toBeInterface();
+    }
+
+    /**
+     * Asserts that the given expectation target to be not subclass of the given class.
+     */
+    public function toExtend(string $class): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || ! $object->reflectionClass->isSubclassOf($class),
+            sprintf("not to extend '%s'", $class),
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to be not have any parent class.
+     */
+    public function toExtendNothing(): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || $object->reflectionClass->getParentClass() !== false,
+            'to extend a class',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target not to use the given trait.
+     */
+    public function toUseTrait(string $trait): ArchExpectation
+    {
+        return $this->toUseTraits($trait);
+    }
+
+    /**
+     * Asserts that the given expectation target not to use the given traits.
+     *
+     * @param  array<int, string>|string  $traits
+     */
+    public function toUseTraits(array|string $traits): ArchExpectation
+    {
+        $traits = is_array($traits) ? $traits : [$traits];
+
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => array_all($traits, fn (string $trait): bool => ! (isset($object->reflectionClass) && in_array($trait, $object->reflectionClass->getTraitNames(), true))),
+            "not to use traits '".implode("', '", $traits)."'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target not to implement the given interfaces.
+     *
+     * @param  array<int, string>|string  $interfaces
+     */
+    public function toImplement(array|string $interfaces): ArchExpectation
+    {
+        $interfaces = is_array($interfaces) ? $interfaces : [$interfaces];
+
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => array_all($interfaces, fn (string $interface): bool => ! (isset($object->reflectionClass) && $object->reflectionClass->implementsInterface($interface))),
+            "not to implement '".implode("', '", $interfaces)."'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to not implement any interfaces.
+     */
+    public function toImplementNothing(): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || $object->reflectionClass->getInterfaceNames() !== [],
+            'to implement an interface',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Not supported.
+     */
+    public function toOnlyImplement(): void
+    {
+        throw InvalidExpectation::fromMethods(['not', 'toOnlyImplement']);
+    }
+
+    /**
+     * Asserts that the given expectation target to not have the given prefix.
+     */
+    public function toHavePrefix(string $prefix): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || ! str_starts_with($object->reflectionClass->getShortName(), $prefix),
+            "not to have prefix '{$prefix}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target to not have the given suffix.
+     */
+    public function toHaveSuffix(string $suffix): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || ! str_ends_with($object->reflectionClass->getName(), $suffix),
+            "not to have suffix '{$suffix}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Not supported.
+     */
+    public function toOnlyUse(): void
     {
         throw InvalidExpectation::fromMethods(['not', 'toOnlyUse']);
     }
 
-    public function toUseNothing(): never
+    /**
+     * Not supported.
+     */
+    public function toUseNothing(): void
     {
         throw InvalidExpectation::fromMethods(['not', 'toUseNothing']);
     }
@@ -89,7 +679,10 @@ final class OppositeExpectation
      */
     public function toBeUsed(): ArchExpectation
     {
-        return ToBeUsedInNothing::make($this->original);
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return ToBeUsedInNothing::make($original);
     }
 
     /**
@@ -99,12 +692,15 @@ final class OppositeExpectation
      */
     public function toBeUsedIn(array|string $targets): ArchExpectation
     {
-        return GroupArchExpectation::fromExpectations($this->original, array_map(fn (string $target): GroupArchExpectation => ToBeUsedIn::make($this->original, $target)->opposite(
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return GroupArchExpectation::fromExpectations($original, array_map(fn (string $target): GroupArchExpectation => ToBeUsedIn::make($original, $target)->opposite(
             fn () => $this->throwExpectationFailedException('toBeUsedIn', $target),
         ), is_string($targets) ? [$targets] : $targets));
     }
 
-    public function toOnlyBeUsedIn(): never
+    public function toOnlyBeUsedIn(): void
     {
         throw InvalidExpectation::fromMethods(['not', 'toOnlyBeUsedIn']);
     }
@@ -112,11 +708,43 @@ final class OppositeExpectation
     /**
      * Asserts that the given expectation dependency is not used.
      */
-    public function toBeUsedInNothing(): never
+    public function toBeUsedInNothing(): void
     {
         throw InvalidExpectation::fromMethods(['not', 'toBeUsedInNothing']);
     }
 
+    /**
+     * Asserts that the given expectation dependency is not an invokable class.
+     */
+    public function toBeInvokable(): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || ! $object->reflectionClass->hasMethod('__invoke'),
+            'to not be invokable',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target not to have the given attribute.
+     */
+    public function toHaveAttribute(string $attribute): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false || $object->reflectionClass->getAttributes($attribute) === [],
+            "to not have attribute '{$attribute}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
+        );
+    }
+
     /**
      * Handle dynamic method calls into the original expectation.
      *
@@ -126,9 +754,13 @@ final class OppositeExpectation
     public function __call(string $name, array $arguments): Expectation
     {
         try {
+            if (! is_object($this->original->value) && method_exists(PendingArchExpectation::class, $name)) {
+                throw InvalidExpectation::fromMethods(['not', $name]);
+            }
+
             /* @phpstan-ignore-next-line */
             $this->original->{$name}(...$arguments);
-        } catch (ExpectationFailedException) {
+        } catch (ExpectationFailedException|AssertionFailedError) {
             return $this->original;
         }
 
@@ -143,8 +775,12 @@ final class OppositeExpectation
     public function __get(string $name): Expectation
     {
         try {
+            if (! is_object($this->original->value) && method_exists(PendingArchExpectation::class, $name)) {
+                throw InvalidExpectation::fromMethods(['not', $name]);
+            }
+
             $this->original->{$name}; // @phpstan-ignore-line
-        } catch (ExpectationFailedException) {  // @phpstan-ignore-line
+        } catch (ExpectationFailedException) {
             return $this->original;
         }
 
@@ -162,8 +798,80 @@ final class OppositeExpectation
 
         $exporter = Exporter::default();
 
-        $toString = fn ($argument): string => $exporter->shortenedExport($argument);
+        $toString = fn (mixed $argument): string => $exporter->shortenedExport($argument);
 
-        throw new ExpectationFailedException(sprintf('Expecting %s not %s %s.', $toString($this->original->value), strtolower((string) preg_replace('/(?<!\ )[A-Z]/', ' $0', $name)), implode(' ', array_map(fn ($argument): string => $toString($argument), $arguments))));
+        throw new ExpectationFailedException(sprintf(
+            'Expecting %s not %s %s.',
+            $toString($this->original->value),
+            strtolower((string) preg_replace('/(?<!\ )[A-Z]/', ' $0', $name)),
+            implode(' ', array_map(fn (mixed $argument): string => $toString($argument), $arguments)),
+        ));
+    }
+
+    /**
+     * Asserts that the given expectation target does not have a constructor method.
+     */
+    public function toHaveConstructor(): ArchExpectation
+    {
+        return $this->toHaveMethod('__construct');
+    }
+
+    /**
+     * Asserts that the given expectation target does not have a destructor method.
+     */
+    public function toHaveDestructor(): ArchExpectation
+    {
+        return $this->toHaveMethod('__destruct');
+    }
+
+    /**
+     * Asserts that the given expectation target is not a backed enum of given type.
+     */
+    private function toBeBackedEnum(string $backingType): ArchExpectation
+    {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
+        return Targeted::make(
+            $original,
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) === false
+                || ! $object->reflectionClass->isEnum()
+                || ! new \ReflectionEnum($object->name)->isBacked() // @phpstan-ignore-line
+                || (string) new \ReflectionEnum($object->name)->getBackingType() !== $backingType, // @phpstan-ignore-line
+            'not to be '.$backingType.' backed enum',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are not string backed enums.
+     */
+    public function toBeStringBackedEnums(): ArchExpectation
+    {
+        return $this->toBeStringBackedEnum();
+    }
+
+    /**
+     * Asserts that the given expectation targets are not int backed enums.
+     */
+    public function toBeIntBackedEnums(): ArchExpectation
+    {
+        return $this->toBeIntBackedEnum();
+    }
+
+    /**
+     * Asserts that the given expectation target is not a string backed enum.
+     */
+    public function toBeStringBackedEnum(): ArchExpectation
+    {
+        return $this->toBeBackedEnum('string');
+    }
+
+    /**
+     * Asserts that the given expectation target is not an int backed enum.
+     */
+    public function toBeIntBackedEnum(): ArchExpectation
+    {
+        return $this->toBeBackedEnum('int');
     }
 }

src/Factories/Annotations/CoversNothing.php

@@ -1,27 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Factories\Annotations;
-
-use Pest\Contracts\AddsAnnotations;
-use Pest\Factories\Covers\CoversNothing as CoversNothingFactory;
-use Pest\Factories\TestCaseMethodFactory;
-
-/**
- * @internal
- */
-final class CoversNothing implements AddsAnnotations
-{
-    /**
-     * {@inheritdoc}
-     */
-    public function __invoke(TestCaseMethodFactory $method, array $annotations): array
-    {
-        if (($method->covers[0] ?? null) instanceof CoversNothingFactory) {
-            $annotations[] = '@coversNothing';
-        }
-
-        return $annotations;
-    }
-}

src/Factories/Annotations/Depends.php

@@ -1,29 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Factories\Annotations;
-
-use Pest\Contracts\AddsAnnotations;
-use Pest\Factories\TestCaseMethodFactory;
-use Pest\Support\Str;
-
-/**
- * @internal
- */
-final class Depends implements AddsAnnotations
-{
-    /**
-     * {@inheritdoc}
-     */
-    public function __invoke(TestCaseMethodFactory $method, array $annotations): array
-    {
-        foreach ($method->depends as $depend) {
-            $depend = Str::evaluable($depend);
-
-            $annotations[] = "@depends $depend";
-        }
-
-        return $annotations;
-    }
-}

src/Factories/Annotations/Groups.php

@@ -1,26 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Factories\Annotations;
-
-use Pest\Contracts\AddsAnnotations;
-use Pest\Factories\TestCaseMethodFactory;
-
-/**
- * @internal
- */
-final class Groups implements AddsAnnotations
-{
-    /**
-     * {@inheritdoc}
-     */
-    public function __invoke(TestCaseMethodFactory $method, array $annotations): array
-    {
-        foreach ($method->groups as $group) {
-            $annotations[] = "@group $group";
-        }
-
-        return $annotations;
-    }
-}

src/Factories/Annotations/TestDox.php

@@ -1,31 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Factories\Annotations;
-
-use Pest\Contracts\AddsAnnotations;
-use Pest\Factories\TestCaseMethodFactory;
-
-final class TestDox implements AddsAnnotations
-{
-    /**
-     * {@inheritdoc}
-     */
-    public function __invoke(TestCaseMethodFactory $method, array $annotations): array
-    {
-        /*
-       * escapes docblock according to
-       * https://manual.phpdoc.org/HTMLframesConverter/default/phpDocumentor/tutorial_phpDocumentor.howto.pkg.html#basics.desc
-       *
-       * note: '@' escaping is not needed as it cannot be the first character of the line (it always starts with @testdox
-       */
-
-        assert($method->description !== null);
-        $methodDescription = str_replace('*/', '{@*}', $method->description);
-
-        $annotations[] = "@testdox $methodDescription";
-
-        return $annotations;
-    }
-}

src/Factories/Attribute.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Factories;
+
+/**
+ * @internal
+ */
+final class Attribute
+{
+    /**
+     * @param  iterable<int, string>  $arguments
+     */
+    public function __construct(public string $name, public iterable $arguments)
+    {
+        //
+    }
+}

src/Factories/Attributes/Attribute.php

@@ -1,27 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Factories\Attributes;
-
-use Pest\Factories\TestCaseMethodFactory;
-
-/**
- * @internal
- */
-abstract class Attribute
-{
-    /**
-     * Determine if the attribute should be placed above the class instead of above the method.
-     */
-    public static bool $above = false;
-
-    /**
-     * @param  array<int, string>  $attributes
-     * @return array<int, string>
-     */
-    public function __invoke(TestCaseMethodFactory $method, array $attributes): array // @phpstan-ignore-line
-    {
-        return $attributes;
-    }
-}

src/Factories/Attributes/Covers.php

@@ -1,44 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Factories\Attributes;
-
-use Pest\Factories\Covers\CoversClass;
-use Pest\Factories\Covers\CoversFunction;
-use Pest\Factories\TestCaseMethodFactory;
-
-/**
- * @internal
- */
-final class Covers extends Attribute
-{
-    /**
-     * Determine if the attribute should be placed above the class instead of above the method.
-     */
-    public static bool $above = true;
-
-    /**
-     * Adds attributes regarding the "covers" feature.
-     *
-     * @param  array<int, string>  $attributes
-     * @return array<int, string>
-     */
-    public function __invoke(TestCaseMethodFactory $method, array $attributes): array
-    {
-        foreach ($method->covers as $covering) {
-            if ($covering instanceof CoversClass) {
-                // Prepend a backslash for FQN classes
-                if (str_contains($covering->class, '\\')) {
-                    $covering->class = '\\'.$covering->class;
-                }
-
-                $attributes[] = "#[\PHPUnit\Framework\Attributes\CoversClass({$covering->class}::class)]";
-            } elseif ($covering instanceof CoversFunction) {
-                $attributes[] = "#[\PHPUnit\Framework\Attributes\CoversFunction('{$covering->function}')]";
-            }
-        }
-
-        return $attributes;
-    }
-}

src/Factories/Concerns/HigherOrderable.php

@@ -28,8 +28,8 @@ trait HigherOrderable
      */
     private function bootHigherOrderable(): void
     {
-        $this->chains = new HigherOrderMessageCollection();
-        $this->factoryProxies = new HigherOrderMessageCollection();
-        $this->proxies = new HigherOrderMessageCollection();
+        $this->chains = new HigherOrderMessageCollection;
+        $this->factoryProxies = new HigherOrderMessageCollection;
+        $this->proxies = new HigherOrderMessageCollection;
     }
 }

src/Factories/Covers/CoversClass.php

@@ -9,7 +9,5 @@ namespace Pest\Factories\Covers;
  */
 final class CoversClass
 {
-    public function __construct(public string $class)
-    {
-    }
+    public function __construct(public string $class) {}
 }

src/Factories/Covers/CoversFunction.php

@@ -9,7 +9,5 @@ namespace Pest\Factories\Covers;
  */
 final class CoversFunction
 {
-    public function __construct(public string $function)
-    {
-    }
+    public function __construct(public string $function) {}
 }

src/Factories/Covers/CoversNothing.php

@@ -1,12 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Factories\Covers;
-
-/**
- * @internal
- */
-final class CoversNothing
-{
-}

src/Factories/TestCaseFactory.php

@@ -6,11 +6,12 @@ namespace Pest\Factories;
 
 use ParseError;
 use Pest\Concerns;
-use Pest\Contracts\AddsAnnotations;
 use Pest\Contracts\HasPrintableTestCaseName;
+use Pest\Evaluators\Attributes;
 use Pest\Exceptions\DatasetMissing;
 use Pest\Exceptions\ShouldNotHappen;
 use Pest\Exceptions\TestAlreadyExist;
+use Pest\Exceptions\TestClosureMustNotBeStatic;
 use Pest\Exceptions\TestDescriptionMissing;
 use Pest\Factories\Concerns\HigherOrderable;
 use Pest\Support\Reflection;
@@ -26,26 +27,12 @@ final class TestCaseFactory
 {
     use HigherOrderable;
 
-    /**
-     * The list of annotations.
-     *
-     * @var array<int, class-string<AddsAnnotations>>
-     */
-    private const ANNOTATIONS = [
-        Annotations\Depends::class,
-        Annotations\Groups::class,
-        Annotations\CoversNothing::class,
-        Annotations\TestDox::class,
-    ];
-
     /**
      * The list of attributes.
      *
-     * @var array<int, class-string<\Pest\Factories\Attributes\Attribute>>
+     * @var array<int, Attribute>
      */
-    private const ATTRIBUTES = [
-        Attributes\Covers::class,
-    ];
+    public array $attributes = [];
 
     /**
      * The FQN of the Test Case class.
@@ -98,7 +85,7 @@ final class TestCaseFactory
     {
         if ('\\' === DIRECTORY_SEPARATOR) {
             // In case Windows, strtolower drive name, like in UsesCall.
-            $filename = (string) preg_replace_callback('~^(?P<drive>[a-z]+:\\\)~i', static fn ($match): string => strtolower($match['drive']), $filename);
+            $filename = (string) preg_replace_callback('~^(?P<drive>[a-z]+:\\\)~i', static fn (array $match): string => strtolower($match['drive']), $filename);
         }
 
         $filename = str_replace('\\\\', '\\', addslashes((string) realpath($filename)));
@@ -134,7 +121,7 @@ final class TestCaseFactory
 
         $hasPrintableTestCaseClassFQN = sprintf('\%s', HasPrintableTestCaseName::class);
         $traitsCode = sprintf('use %s;', implode(', ', array_map(
-            static fn ($trait): string => sprintf('\%s', $trait), $this->traits))
+            static fn (string $trait): string => sprintf('\%s', $trait), $this->traits))
         );
 
         $partsFQN = explode('\\', $classFQN);
@@ -142,36 +129,25 @@ final class TestCaseFactory
         $namespace = implode('\\', $partsFQN);
         $baseClass = sprintf('\%s', $this->class);
 
-        if ('' === trim($className)) {
+        if (trim($className) === '') {
             $className = 'InvalidTestName'.Str::random();
         }
 
-        $classAvailableAttributes = array_filter(self::ATTRIBUTES, fn (string $attribute): bool => $attribute::$above);
-        $methodAvailableAttributes = array_filter(self::ATTRIBUTES, fn (string $attribute): bool => ! $attribute::$above);
+        $this->attributes = [
+            new Attribute(
+                \PHPUnit\Framework\Attributes\TestDox::class,
+                [$this->filename],
+            ),
+            ...$this->attributes,
+        ];
 
-        $classAttributes = [];
-
-        foreach ($classAvailableAttributes as $attribute) {
-            $classAttributes = array_reduce(
-                $methods,
-                fn (array $carry, TestCaseMethodFactory $methodFactory): array => (new $attribute())->__invoke($methodFactory, $carry),
-                $classAttributes
-            );
-        }
+        $attributesCode = Attributes::code($this->attributes);
 
         $methodsCode = implode('', array_map(
-            fn (TestCaseMethodFactory $methodFactory): string => $methodFactory->buildForEvaluation(
-                self::ANNOTATIONS,
-                $methodAvailableAttributes
-            ),
+            fn (TestCaseMethodFactory $methodFactory): string => $methodFactory->buildForEvaluation(),
             $methods
         ));
 
-        $classAttributesCode = implode('', array_map(
-            static fn (string $attribute): string => sprintf("\n%s", $attribute),
-            array_unique($classAttributes),
-        ));
-
         try {
             $classCode = <<<PHP
             namespace $namespace;
@@ -179,10 +155,7 @@ final class TestCaseFactory
             use Pest\Repositories\DatasetsRepository as __PestDatasets;
             use Pest\TestSuite as __PestTestSuite;
 
-            /**
-             * @testdox $filename
-             */
-            $classAttributesCode
+            $attributesCode
             #[\AllowDynamicProperties]
             final class $className extends $baseClass implements $hasPrintableTestCaseClassFQN {
                 $traitsCode
@@ -193,7 +166,7 @@ final class TestCaseFactory
             }
             PHP;
 
-            eval($classCode); // @phpstan-ignore-line
+            eval($classCode);
         } catch (ParseError $caught) {
             throw new RuntimeException(sprintf(
                 "Unable to create test case for test file at %s. \n %s",
@@ -216,6 +189,14 @@ final class TestCaseFactory
             throw new TestAlreadyExist($method->filename, $method->description);
         }
 
+        if (
+            $method->closure instanceof \Closure &&
+            new \ReflectionFunction($method->closure)->isStatic()
+        ) {
+
+            throw new TestClosureMustNotBeStatic($method);
+        }
+
         if (! $method->receivesArguments()) {
             if (! $method->closure instanceof \Closure) {
                 throw ShouldNotHappen::fromMessage('The test closure may not be empty.');
@@ -241,7 +222,7 @@ final class TestCaseFactory
                 throw ShouldNotHappen::fromMessage('The test description may not be empty.');
             }
 
-            if (Str::evaluable($method->description) === $methodName) {
+            if ($methodName === Str::evaluable($method->description)) {
                 return true;
             }
         }
@@ -259,7 +240,7 @@ final class TestCaseFactory
                 throw ShouldNotHappen::fromMessage('The test description may not be empty.');
             }
 
-            if (Str::evaluable($method->description) === $methodName) {
+            if ($methodName === Str::evaluable($method->description)) {
                 return $method;
             }
         }

src/Factories/TestCaseMethodFactory.php

@@ -5,13 +5,14 @@ declare(strict_types=1);
 namespace Pest\Factories;
 
 use Closure;
-use Pest\Contracts\AddsAnnotations;
+use Pest\Evaluators\Attributes;
 use Pest\Exceptions\ShouldNotHappen;
 use Pest\Factories\Concerns\HigherOrderable;
 use Pest\Repositories\DatasetsRepository;
 use Pest\Support\Str;
 use Pest\TestSuite;
 use PHPUnit\Framework\Assert;
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 
 /**
@@ -22,57 +23,106 @@ final class TestCaseMethodFactory
     use HigherOrderable;
 
     /**
-     * Determines if the Test Case Method is a "todo".
+     * The list of attributes.
+     *
+     * @var array<int, Attribute>
+     */
+    public array $attributes = [];
+
+    /**
+     * The test's describing, if any.
+     *
+     * @var array<int, \Pest\Support\Description>
+     */
+    public array $describing = [];
+
+    /**
+     * The test's description, if any.
+     */
+    public ?string $description = null;
+
+    /**
+     * The test's number of repetitions.
+     */
+    public int $repetitions = 1;
+
+    /**
+     * Determines if the test is a "todo".
      */
     public bool $todo = false;
 
     /**
-     * The Test Case Dataset, if any.
+     * The associated issue numbers.
+     *
+     * @var array<int, int>
+     */
+    public array $issues = [];
+
+    /**
+     * The test assignees.
+     *
+     * @var array<int, string>
+     */
+    public array $assignees = [];
+
+    /**
+     * The associated PRs numbers.
+     *
+     * @var array<int, int>
+     */
+    public array $prs = [];
+
+    /**
+     * The test's notes.
+     *
+     * @var array<int, string>
+     */
+    public array $notes = [];
+
+    /**
+     * The test's datasets.
      *
      * @var array<Closure|iterable<int|string, mixed>|string>
      */
     public array $datasets = [];
 
     /**
-     * The Test Case depends, if any.
+     * The test's dependencies.
      *
      * @var array<int, string>
      */
     public array $depends = [];
 
     /**
-     * The Test Case groups, if any.
+     * The test's groups.
      *
      * @var array<int, string>
      */
     public array $groups = [];
 
     /**
-     * The covered classes and functions, if any.
-     *
-     * @var array<int, \Pest\Factories\Covers\CoversClass|\Pest\Factories\Covers\CoversFunction|\Pest\Factories\Covers\CoversNothing>
+     * @see This property is not actually used in the codebase, it's only here to make Rector happy.
      */
-    public array $covers = [];
+    public bool $__ran = false;
 
     /**
-     * Creates a new Factory instance.
+     * Creates a new test case method factory instance.
      */
     public function __construct(
         public string $filename,
-        public ?string $description,
         public ?Closure $closure,
     ) {
         $this->closure ??= function (): void {
-            Assert::getCount() > 0 ?: self::markTestIncomplete(); // @phpstan-ignore-line
+            (Assert::getCount() > 0 || $this->doesNotPerformAssertions()) ?: self::markTestIncomplete(); // @phpstan-ignore-line
         };
 
         $this->bootHigherOrderable();
     }
 
     /**
-     * Makes the Test Case classes.
+     * Sets the test's hooks, and runs any proxy to the test case.
      */
-    public function getClosure(TestCase $concrete): Closure
+    public function setUp(TestCase $concrete): void
     {
         $concrete::flush(); // @phpstan-ignore-line
 
@@ -80,16 +130,32 @@ final class TestCaseMethodFactory
             throw ShouldNotHappen::fromMessage('Description can not be empty.');
         }
 
-        $closure = $this->closure;
-
         $testCase = TestSuite::getInstance()->tests->get($this->filename);
 
+        assert($testCase instanceof TestCaseFactory);
         $testCase->factoryProxies->proxy($concrete);
         $this->factoryProxies->proxy($concrete);
+    }
 
+    /**
+     * Flushes the test case.
+     */
+    public function tearDown(TestCase $concrete): void
+    {
+        $concrete::flush(); // @phpstan-ignore-line
+    }
+
+    /**
+     * Creates the test's closure.
+     */
+    public function getClosure(): Closure
+    {
+        $closure = $this->closure;
+        $testCase = TestSuite::getInstance()->tests->get($this->filename);
+        assert($testCase instanceof TestCaseFactory);
         $method = $this;
 
-        return function () use ($testCase, $method, $closure): mixed { // @phpstan-ignore-line
+        return function (...$arguments) use ($testCase, $method, $closure): mixed {
             /* @var TestCase $this */
             $testCase->proxies->proxy($this);
             $method->proxies->proxy($this);
@@ -97,7 +163,9 @@ final class TestCaseMethodFactory
             $testCase->chains->chain($this);
             $method->chains->chain($this);
 
-            return \Pest\Support\Closure::bind($closure, $this, self::class)(...func_get_args());
+            $this->__ran = true;
+
+            return \Pest\Support\Closure::bind($closure, $this, self::class)(...$arguments);
         };
     }
 
@@ -106,16 +174,13 @@ final class TestCaseMethodFactory
      */
     public function receivesArguments(): bool
     {
-        return $this->datasets !== [] || $this->depends !== [];
+        return $this->datasets !== [] || $this->depends !== [] || $this->repetitions > 1;
     }
 
     /**
      * Creates a PHPUnit method as a string ready for evaluation.
-     *
-     * @param  array<int, class-string<AddsAnnotations>>  $annotationsToUse
-     * @param  array<int, class-string<\Pest\Factories\Attributes\Attribute>>  $attributesToUse
      */
-    public function buildForEvaluation(array $annotationsToUse, array $attributesToUse): string
+    public function buildForEvaluation(): string
     {
         if ($this->description === null) {
             throw ShouldNotHappen::fromMessage('The test description may not be empty.');
@@ -124,46 +189,49 @@ final class TestCaseMethodFactory
         $methodName = Str::evaluable($this->description);
 
         $datasetsCode = '';
-        $annotations = ['@test'];
-        $attributes = [];
 
-        foreach ($annotationsToUse as $annotation) {
-            $annotations = (new $annotation())->__invoke($this, $annotations);
+        $this->attributes = [
+            new Attribute(
+                \PHPUnit\Framework\Attributes\Test::class,
+                [],
+            ),
+            new Attribute(
+                \PHPUnit\Framework\Attributes\TestDox::class,
+                [str_replace('*/', '{@*}', $this->description)],
+            ),
+            ...$this->attributes,
+        ];
+
+        foreach ($this->depends as $depend) {
+            $depend = Str::evaluable($this->describing === [] ? $depend : Str::describe($this->describing, $depend));
+
+            $this->attributes[] = new Attribute(
+                \PHPUnit\Framework\Attributes\Depends::class,
+                [$depend],
+            );
         }
 
-        foreach ($attributesToUse as $attribute) {
-            $attributes = (new $attribute())->__invoke($this, $attributes);
-        }
-
-        if ($this->datasets !== []) {
+        if ($this->datasets !== [] || $this->repetitions > 1) {
             $dataProviderName = $methodName.'_dataset';
-            $annotations[] = "@dataProvider $dataProviderName";
+            $this->attributes[] = new Attribute(
+                DataProvider::class,
+                [$dataProviderName],
+            );
             $datasetsCode = $this->buildDatasetForEvaluation($methodName, $dataProviderName);
         }
 
-        $annotations = implode('', array_map(
-            static fn ($annotation): string => sprintf("\n     * %s", $annotation), $annotations,
-        ));
-
-        $attributes = implode('', array_map(
-            static fn ($attribute): string => sprintf("\n        %s", $attribute), $attributes,
-        ));
+        $attributesCode = Attributes::code($this->attributes);
 
         return <<<PHP
-
-                /**$annotations
-                 */
-                $attributes
-                public function $methodName()
+            $attributesCode
+                public function $methodName(...\$arguments)
                 {
-                    \$test = \Pest\TestSuite::getInstance()->tests->get(self::\$__filename)->getMethod(\$this->name())->getClosure(\$this);
-
                     return \$this->__runTest(
-                        \$test,
-                        ...func_get_args(),
+                        \$this->__test,
+                        ...\$arguments,
                     );
                 }
-                $datasetsCode
+            $datasetsCode
             PHP;
     }
 
@@ -172,7 +240,13 @@ final class TestCaseMethodFactory
      */
     private function buildDatasetForEvaluation(string $methodName, string $dataProviderName): string
     {
-        DatasetsRepository::with($this->filename, $methodName, $this->datasets);
+        $datasets = $this->datasets;
+
+        if ($this->repetitions > 1) {
+            $datasets = [range(1, $this->repetitions), ...$datasets];
+        }
+
+        DatasetsRepository::with($this->filename, $methodName, $datasets);
 
         return <<<EOF
 

src/Functions.php

@@ -2,14 +2,26 @@
 
 declare(strict_types=1);
 
+use Pest\Browser\Api\ArrayablePendingAwaitablePage;
+use Pest\Browser\Api\PendingAwaitablePage;
+use Pest\Concerns\Expectable;
+use Pest\Configuration;
+use Pest\Exceptions\AfterAllWithinDescribe;
+use Pest\Exceptions\BeforeAllWithinDescribe;
 use Pest\Expectation;
+use Pest\Installers\PluginBrowser;
+use Pest\Mutate\Contracts\MutationTestRunner;
+use Pest\Mutate\Repositories\ConfigurationRepository;
 use Pest\PendingCalls\AfterEachCall;
 use Pest\PendingCalls\BeforeEachCall;
+use Pest\PendingCalls\DescribeCall;
 use Pest\PendingCalls\TestCall;
 use Pest\PendingCalls\UsesCall;
 use Pest\Repositories\DatasetsRepository;
 use Pest\Support\Backtrace;
+use Pest\Support\Container;
 use Pest\Support\DatasetInfo;
+use Pest\Support\Description;
 use Pest\Support\HigherOrderTapProxy;
 use Pest\TestSuite;
 use PHPUnit\Framework\TestCase;
@@ -35,6 +47,12 @@ if (! function_exists('beforeAll')) {
      */
     function beforeAll(Closure $closure): void
     {
+        if (DescribeCall::describing() !== []) {
+            $filename = Backtrace::file();
+
+            throw new BeforeAllWithinDescribe($filename);
+        }
+
         TestSuite::getInstance()->beforeAll->set($closure);
     }
 }
@@ -43,9 +61,11 @@ if (! function_exists('beforeEach')) {
     /**
      * Runs the given closure before each test in the current file.
      *
-     * @return HigherOrderTapProxy<TestCall|TestCase>|TestCall|TestCase|mixed
+     * @param-closure-this TestCase  $closure
+     *
+     * @return HigherOrderTapProxy<Expectable|TestCall|TestCase>|Expectable|TestCall|TestCase|mixed
      */
-    function beforeEach(Closure $closure = null): BeforeEachCall
+    function beforeEach(?Closure $closure = null): BeforeEachCall
     {
         $filename = Backtrace::file();
 
@@ -67,6 +87,22 @@ if (! function_exists('dataset')) {
     }
 }
 
+if (! function_exists('describe')) {
+    /**
+     * Adds the given closure as a group of tests. The first argument
+     * is the group description; the second argument is a closure
+     * that contains the group tests.
+     *
+     * @return HigherOrderTapProxy<Expectable|TestCall|TestCase>|Expectable|TestCall|TestCase|mixed
+     */
+    function describe(string $description, Closure $tests): DescribeCall
+    {
+        $filename = Backtrace::testFile();
+
+        return new DescribeCall(TestSuite::getInstance(), $filename, new Description($description), $tests);
+    }
+}
+
 if (! function_exists('uses')) {
     /**
      * The uses function binds the given
@@ -82,15 +118,27 @@ if (! function_exists('uses')) {
     }
 }
 
+if (! function_exists('pest')) {
+    /**
+     * Creates a new Pest configuration instance.
+     */
+    function pest(): Configuration
+    {
+        return new Configuration(Backtrace::file());
+    }
+}
+
 if (! function_exists('test')) {
     /**
      * Adds the given closure as a test. The first argument
      * is the test description; the second argument is
      * a closure that contains the test expectations.
      *
-     * @return TestCall|TestCase|mixed
+     * @param-closure-this TestCase  $closure
+     *
+     * @return Expectable|TestCall|TestCase|mixed
      */
-    function test(string $description = null, Closure $closure = null): HigherOrderTapProxy|TestCall
+    function test(?string $description = null, ?Closure $closure = null): HigherOrderTapProxy|TestCall
     {
         if ($description === null && TestSuite::getInstance()->test instanceof \PHPUnit\Framework\TestCase) {
             return new HigherOrderTapProxy(TestSuite::getInstance()->test);
@@ -108,9 +156,11 @@ if (! function_exists('it')) {
      * is the test description; the second argument is
      * a closure that contains the test expectations.
      *
-     * @return TestCall|TestCase|mixed
+     * @param-closure-this TestCase  $closure
+     *
+     * @return Expectable|TestCall|TestCase|mixed
      */
-    function it(string $description, Closure $closure = null): TestCall
+    function it(string $description, ?Closure $closure = null): TestCall
     {
         $description = sprintf('it %s', $description);
 
@@ -123,11 +173,9 @@ if (! function_exists('it')) {
 
 if (! function_exists('todo')) {
     /**
-     * Adds the given todo test. Internally, this test
-     * is marked as incomplete. Yet, Collision, Pest's
-     * printer, will display it as a "todo" test.
+     * Creates a new test that is marked as "todo".
      *
-     * @return TestCall|TestCase|mixed
+     * @return Expectable|TestCall|TestCase|mixed
      */
     function todo(string $description): TestCall
     {
@@ -143,9 +191,11 @@ if (! function_exists('afterEach')) {
     /**
      * Runs the given closure after each test in the current file.
      *
-     * @return HigherOrderTapProxy<TestCall|TestCase>|TestCall|mixed
+     * @param-closure-this TestCase  $closure
+     *
+     * @return Expectable|HigherOrderTapProxy<Expectable|TestCall|TestCase>|TestCall|mixed
      */
-    function afterEach(Closure $closure = null): AfterEachCall
+    function afterEach(?Closure $closure = null): AfterEachCall
     {
         $filename = Backtrace::file();
 
@@ -159,6 +209,124 @@ if (! function_exists('afterAll')) {
      */
     function afterAll(Closure $closure): void
     {
+        if (DescribeCall::describing() !== []) {
+            $filename = Backtrace::file();
+
+            throw new AfterAllWithinDescribe($filename);
+        }
+
         TestSuite::getInstance()->afterAll->set($closure);
     }
 }
+
+if (! function_exists('covers')) {
+    /**
+     * Specifies which classes, or functions, a test case covers.
+     *
+     * @param  array<int, string>|string  $classesOrFunctions
+     */
+    function covers(array|string ...$classesOrFunctions): void
+    {
+        $filename = Backtrace::file();
+
+        $beforeEachCall = (new BeforeEachCall(TestSuite::getInstance(), $filename));
+
+        $beforeEachCall->covers(...$classesOrFunctions);
+        $beforeEachCall->group('__pest_mutate_only');
+
+        /** @var MutationTestRunner $runner */
+        $runner = Container::getInstance()->get(MutationTestRunner::class);
+        /** @var \Pest\Mutate\Repositories\ConfigurationRepository $configurationRepository */
+        $configurationRepository = Container::getInstance()->get(ConfigurationRepository::class);
+        $everything = $configurationRepository->cliConfiguration->toArray()['everything'] ?? false;
+        $classes = $configurationRepository->cliConfiguration->toArray()['classes'] ?? false;
+        $paths = $configurationRepository->cliConfiguration->toArray()['paths'] ?? false;
+
+        if ($runner->isEnabled() && ! $everything && ! is_array($classes) && ! is_array($paths)) {
+            $beforeEachCall->only('__pest_mutate_only');
+        }
+    }
+}
+
+if (! function_exists('mutates')) {
+    /**
+     * Specifies which classes, enums, or traits a test case mutates.
+     *
+     * @param  array<int, string>|string  $targets
+     */
+    function mutates(array|string ...$targets): void
+    {
+        $filename = Backtrace::file();
+
+        $beforeEachCall = (new BeforeEachCall(TestSuite::getInstance(), $filename));
+        $beforeEachCall->group('__pest_mutate_only');
+
+        /** @var MutationTestRunner $runner */
+        $runner = Container::getInstance()->get(MutationTestRunner::class);
+        /** @var \Pest\Mutate\Repositories\ConfigurationRepository $configurationRepository */
+        $configurationRepository = Container::getInstance()->get(ConfigurationRepository::class);
+        $everything = $configurationRepository->cliConfiguration->toArray()['everything'] ?? false;
+        $classes = $configurationRepository->cliConfiguration->toArray()['classes'] ?? false;
+        $paths = $configurationRepository->cliConfiguration->toArray()['paths'] ?? false;
+
+        if ($runner->isEnabled() && ! $everything && ! is_array($classes) && ! is_array($paths)) {
+            $beforeEachCall->only('__pest_mutate_only');
+        }
+
+        /** @var ConfigurationRepository $configurationRepository */
+        $configurationRepository = Container::getInstance()->get(ConfigurationRepository::class);
+        $paths = $configurationRepository->cliConfiguration->toArray()['paths'] ?? false;
+
+        if (! is_array($paths)) {
+            $configurationRepository->globalConfiguration('default')->class(...$targets); // @phpstan-ignore-line
+        }
+    }
+}
+
+if (! function_exists('fixture')) {
+    /**
+     * Returns the absolute path to a fixture file.
+     */
+    function fixture(string $file): string
+    {
+        $file = implode(DIRECTORY_SEPARATOR, [
+            TestSuite::getInstance()->rootPath,
+            TestSuite::getInstance()->testPath,
+            'Fixtures',
+            str_replace(['/', '\\'], DIRECTORY_SEPARATOR, $file),
+        ]);
+
+        $fileRealPath = realpath($file);
+
+        if ($fileRealPath === false) {
+            throw new InvalidArgumentException(
+                'The fixture file ['.$file.'] does not exist.',
+            );
+        }
+
+        return $fileRealPath;
+    }
+}
+
+if (! function_exists('visit')) {
+    /**
+     * Browse to the given URL.
+     *
+     * @template TUrl of array<int, string>|string
+     *
+     * @param  TUrl  $url
+     * @param  array<string, mixed>  $options
+     * @return (TUrl is array<int, string> ? ArrayablePendingAwaitablePage : PendingAwaitablePage)
+     */
+    function visit(array|string $url, array $options = []): ArrayablePendingAwaitablePage|PendingAwaitablePage
+    {
+        if (! class_exists(\Pest\Browser\Configuration::class)) {
+            PluginBrowser::install();
+
+            exit(0);
+        }
+
+        // @phpstan-ignore-next-line
+        return test()->visit($url, $options);
+    }
+}

src/Installers/PluginBrowser.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Installers;
+
+use Pest\Support\View;
+
+final readonly class PluginBrowser
+{
+    public static function install(): void
+    {
+        View::render('installers/plugin-browser');
+    }
+}

src/Kernel.php

@@ -4,45 +4,53 @@ declare(strict_types=1);
 
 namespace Pest;
 
+use NunoMaduro\Collision\Writer;
 use Pest\Contracts\Bootstrapper;
+use Pest\Exceptions\FatalException;
 use Pest\Exceptions\NoDirtyTestsFound;
 use Pest\Plugins\Actions\CallsAddsOutput;
 use Pest\Plugins\Actions\CallsBoot;
 use Pest\Plugins\Actions\CallsHandleArguments;
-use Pest\Plugins\Actions\CallsShutdown;
+use Pest\Plugins\Actions\CallsHandleOriginalArguments;
+use Pest\Plugins\Actions\CallsTerminable;
 use Pest\Support\Container;
+use Pest\Support\Reflection;
+use Pest\Support\View;
 use PHPUnit\TestRunner\TestResult\Facade;
 use PHPUnit\TextUI\Application;
 use PHPUnit\TextUI\Configuration\Registry;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
+use Throwable;
+use Whoops\Exception\Inspector;
 
 /**
  * @internal
  */
-final class Kernel
+final readonly class Kernel
 {
     /**
      * The Kernel bootstrappers.
      *
      * @var array<int, class-string>
      */
-    private const BOOTSTRAPPERS = [
+    private const array BOOTSTRAPPERS = [
         Bootstrappers\BootOverrides::class,
         Bootstrappers\BootSubscribers::class,
         Bootstrappers\BootFiles::class,
         Bootstrappers\BootView::class,
         Bootstrappers\BootKernelDump::class,
+        Bootstrappers\BootExcludeList::class,
     ];
 
     /**
      * Creates a new Kernel instance.
      */
     public function __construct(
-        private readonly Application $application,
-        private readonly OutputInterface $output,
+        private Application $application,
+        private OutputInterface $output,
     ) {
-        register_shutdown_function(fn () => $this->shutdown());
+        //
     }
 
     /**
@@ -58,6 +66,13 @@ final class Kernel
             ->add(OutputInterface::class, $output)
             ->add(Container::class, $container);
 
+        $kernel = new self(
+            new Application,
+            $output,
+        );
+
+        register_shutdown_function($kernel->shutdown(...));
+
         foreach (self::BOOTSTRAPPERS as $bootstrapper) {
             $bootstrapper = Container::getInstance()->get($bootstrapper);
             assert($bootstrapper instanceof Bootstrapper);
@@ -67,23 +82,25 @@ final class Kernel
 
         CallsBoot::execute();
 
-        return new self(
-            new Application(),
-            $output,
-        );
+        Container::getInstance()->add(self::class, $kernel);
+
+        return $kernel;
     }
 
     /**
      * Runs the application, and returns the exit code.
      *
-     * @param  array<int, string>  $args
+     * @param  array<int, string>  $originalArguments
+     * @param  array<int, string>  $arguments
      */
-    public function handle(array $args): int
+    public function handle(array $originalArguments, array $arguments): int
     {
-        $args = CallsHandleArguments::execute($args);
+        CallsHandleOriginalArguments::execute($originalArguments);
+
+        $arguments = CallsHandleArguments::execute($arguments);
 
         try {
-            $this->application->run($args);
+            $this->application->run($arguments);
         } catch (NoDirtyTestsFound) {
             $this->output->writeln([
                 '',
@@ -101,16 +118,54 @@ final class Kernel
     }
 
     /**
-     * Shutdown the Kernel.
+     * Terminate the Kernel.
      */
-    public function shutdown(): void
+    public function terminate(): void
     {
         $preBufferOutput = Container::getInstance()->get(KernelDump::class);
 
         assert($preBufferOutput instanceof KernelDump);
 
-        $preBufferOutput->shutdown();
+        $preBufferOutput->terminate();
 
-        CallsShutdown::execute();
+        CallsTerminable::execute();
+    }
+
+    /**
+     * Shutdowns unexpectedly the Kernel.
+     */
+    public function shutdown(): void
+    {
+        $this->terminate();
+
+        if (is_array($error = error_get_last())) {
+            if (! in_array($error['type'], [E_ERROR, E_CORE_ERROR], true)) {
+                return;
+            }
+
+            $message = $error['message'];
+            $file = $error['file'];
+            $line = $error['line'];
+
+            try {
+                $writer = new Writer(null, $this->output);
+
+                $throwable = new FatalException($message);
+
+                Reflection::setPropertyValue($throwable, 'line', $line);
+                Reflection::setPropertyValue($throwable, 'file', $file);
+
+                $inspector = new Inspector($throwable);
+
+                $writer->write($inspector);
+            } catch (Throwable) { // @phpstan-ignore-line
+                View::render('components.badge', [
+                    'type' => 'ERROR',
+                    'content' => sprintf('%s in %s:%d', $message, $file, $line),
+                ]);
+            }
+
+            exit(1);
+        }
     }
 }

src/KernelDump.php

@@ -40,7 +40,7 @@ final class KernelDump
      */
     public function disable(): void
     {
-        @ob_clean(); // @phpstan-ignore-line
+        @ob_clean();
 
         if ($this->buffer !== '') {
             $this->flush();
@@ -48,9 +48,9 @@ final class KernelDump
     }
 
     /**
-     * Shutdown the output buffering.
+     * Terminate the output buffering.
      */
-    public function shutdown(): void
+    public function terminate(): void
     {
         $this->disable();
     }

src/Logging/Converter.php

@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 
-namespace Pest\Logging\TeamCity;
+namespace Pest\Logging;
 
 use NunoMaduro\Collision\Adapters\Phpunit\State;
 use Pest\Exceptions\ShouldNotHappen;
@@ -11,6 +11,7 @@ use Pest\Support\Str;
 use PHPUnit\Event\Code\Test;
 use PHPUnit\Event\Code\TestMethod;
 use PHPUnit\Event\Code\Throwable;
+use PHPUnit\Event\Test\AfterLastTestMethodErrored;
 use PHPUnit\Event\Test\BeforeFirstTestMethodErrored;
 use PHPUnit\Event\Test\ConsideredRisky;
 use PHPUnit\Event\Test\Errored;
@@ -18,25 +19,32 @@ use PHPUnit\Event\Test\Failed;
 use PHPUnit\Event\Test\MarkedIncomplete;
 use PHPUnit\Event\Test\Skipped;
 use PHPUnit\Event\TestSuite\TestSuite;
+use PHPUnit\Event\TestSuite\TestSuiteForTestMethodWithDataProvider;
 use PHPUnit\Framework\Exception as FrameworkException;
 use PHPUnit\TestRunner\TestResult\TestResult as PhpUnitTestResult;
 
 /**
  * @internal
  */
-final class Converter
+final readonly class Converter
 {
-    private const PREFIX = 'P\\';
+    /**
+     * The prefix for the test suite name.
+     */
+    private const string PREFIX = 'P\\';
 
-    private readonly StateGenerator $stateGenerator;
+    /**
+     *  The state generator.
+     */
+    private StateGenerator $stateGenerator;
 
     /**
      * Creates a new instance of the Converter.
      */
     public function __construct(
-        private readonly string $rootPath,
+        private string $rootPath,
     ) {
-        $this->stateGenerator = new StateGenerator();
+        $this->stateGenerator = new StateGenerator;
     }
 
     /**
@@ -123,13 +131,13 @@ final class Converter
 
         // clean the paths of each frame.
         $frames = array_map(
-            fn (string $frame): string => $this->toRelativePath($frame),
+            $this->toRelativePath(...),
             $frames
         );
 
         // Format stacktrace as `at <path>`
         $frames = array_map(
-            fn (string $frame) => "at $frame",
+            fn (string $frame): string => "at $frame",
             $frames
         );
 
@@ -141,6 +149,13 @@ final class Converter
      */
     public function getTestSuiteName(TestSuite $testSuite): string
     {
+        if ($testSuite instanceof TestSuiteForTestMethodWithDataProvider) {
+            $firstTest = $this->getFirstTest($testSuite);
+            if ($firstTest instanceof \PHPUnit\Event\Code\TestMethod) {
+                return $this->getTestMethodNameWithoutDatasetSuffix($firstTest);
+            }
+        }
+
         $name = $testSuite->name();
 
         if (! str_starts_with($name, self::PREFIX)) {
@@ -150,10 +165,47 @@ final class Converter
         return Str::after($name, self::PREFIX);
     }
 
+    /**
+     * Gets the trimmed test class name.
+     */
+    public function getTrimmedTestClassName(TestMethod $test): string
+    {
+        return Str::after($test->className(), self::PREFIX);
+    }
+
     /**
      * Gets the test suite location.
      */
-    public function getTestSuiteLocation(TestSuite $testSuite): string|null
+    public function getTestSuiteLocation(TestSuite $testSuite): ?string
+    {
+        $firstTest = $this->getFirstTest($testSuite);
+        if (! $firstTest instanceof \PHPUnit\Event\Code\TestMethod) {
+            return null;
+        }
+        $path = $firstTest->testDox()->prettifiedClassName();
+        $classRelativePath = $this->toRelativePath($path);
+
+        if ($testSuite instanceof TestSuiteForTestMethodWithDataProvider) {
+            $methodName = $this->getTestMethodNameWithoutDatasetSuffix($firstTest);
+
+            return "$classRelativePath::$methodName";
+        }
+
+        return $classRelativePath;
+    }
+
+    /**
+     * Gets the prettified test method name without dataset-related suffix.
+     */
+    private function getTestMethodNameWithoutDatasetSuffix(TestMethod $testMethod): string
+    {
+        return Str::beforeLast($testMethod->testDox()->prettifiedMethodName(), ' with data set ');
+    }
+
+    /**
+     * Gets the first test from the test suite.
+     */
+    private function getFirstTest(TestSuite $testSuite): ?TestMethod
     {
         $tests = $testSuite->tests()->asArray();
 
@@ -167,9 +219,7 @@ final class Converter
             throw ShouldNotHappen::fromMessage('Not an instance of TestMethod');
         }
 
-        $path = $firstTest->testDox()->prettifiedClassName();
-
-        return $this->toRelativePath($path);
+        return $firstTest;
     }
 
     /**
@@ -205,8 +255,9 @@ final class Converter
         $numberOfNotPassedTests = count(
             array_unique(
                 array_map(
-                    function (BeforeFirstTestMethodErrored|Errored|Failed|Skipped|ConsideredRisky|MarkedIncomplete $event): string {
-                        if ($event instanceof BeforeFirstTestMethodErrored) {
+                    function (AfterLastTestMethodErrored|BeforeFirstTestMethodErrored|Errored|Failed|Skipped|ConsideredRisky|MarkedIncomplete $event): string {
+                        if ($event instanceof BeforeFirstTestMethodErrored
+                            || $event instanceof AfterLastTestMethodErrored) {
                             return $event->testClassName();
                         }
 

src/Logging/TeamCity/ServiceMessage.php

@@ -9,7 +9,10 @@ namespace Pest\Logging\TeamCity;
  */
 final class ServiceMessage
 {
-    private static int|null $flowId = null;
+    /**
+     * The flow ID.
+     */
+    private static ?int $flowId = null;
 
     /**
      * @param  array<string, string|int|null>  $parameters
@@ -17,26 +20,25 @@ final class ServiceMessage
     public function __construct(
         private readonly string $type,
         private readonly array $parameters,
-    ) {
-    }
+    ) {}
 
     public function toString(): string
     {
         $paramsToString = '';
 
         foreach ([...$this->parameters, 'flowId' => self::$flowId] as $key => $value) {
-            $value = self::escapeServiceMessage((string) $value);
+            $value = $this->escapeServiceMessage((string) $value);
             $paramsToString .= " $key='$value'";
         }
 
         return "##teamcity[$this->type$paramsToString]";
     }
 
-    public static function testSuiteStarted(string $name, string|null $location): self
+    public static function testSuiteStarted(string $name, ?string $location): self
     {
         return new self('testSuiteStarted', [
             'name' => $name,
-            'locationHint' => $location === null ? null : "file://$location",
+            'locationHint' => $location === null ? null : "pest_qn://$location",
         ]);
     }
 
@@ -63,7 +65,7 @@ final class ServiceMessage
     }
 
     /**
-     * @param  int  $duration in milliseconds
+     * @param  int  $duration  in milliseconds
      */
     public static function testFinished(string $name, int $duration): self
     {
@@ -106,7 +108,7 @@ final class ServiceMessage
         ]);
     }
 
-    public static function testIgnored(string $name, string $message, string $details = null): self
+    public static function testIgnored(string $name, string $message, ?string $details = null): self
     {
         return new self('testIgnored', [
             'name' => $name,
@@ -127,7 +129,7 @@ final class ServiceMessage
         ]);
     }
 
-    private static function escapeServiceMessage(string $text): string
+    private function escapeServiceMessage(string $text): string
     {
         return str_replace(
             ['|', "'", "\n", "\r", ']', '['],

src/Logging/TeamCity/Subscriber/Subscriber.php

@@ -9,19 +9,17 @@ use Pest\Logging\TeamCity\TeamCityLogger;
 /**
  * @internal
  */
-abstract class Subscriber
+abstract class Subscriber // @pest-arch-ignore-line
 {
     /**
      * Creates a new Subscriber instance.
      */
-    public function __construct(private readonly TeamCityLogger $logger)
-    {
-    }
+    public function __construct(private readonly TeamCityLogger $logger) {}
 
     /**
      * Creates a new TeamCityLogger instance.
      */
-    final protected function logger(): TeamCityLogger
+    final protected function logger(): TeamCityLogger // @pest-arch-ignore-line
     {
         return $this->logger;
     }

src/Logging/TeamCity/Subscriber/TestMarkedIncompleteSubscriber.php

@@ -1,19 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Logging\TeamCity\Subscriber;
-
-use PHPUnit\Event\Test\MarkedIncomplete;
-use PHPUnit\Event\Test\MarkedIncompleteSubscriber;
-
-/**
- * @internal
- */
-final class TestMarkedIncompleteSubscriber extends Subscriber implements MarkedIncompleteSubscriber
-{
-    public function notify(MarkedIncomplete $event): void
-    {
-        $this->logger()->testMarkedIncomplete($event);
-    }
-}

src/Logging/TeamCity/TeamCityLogger.php

@@ -6,12 +6,12 @@ namespace Pest\Logging\TeamCity;
 
 use NunoMaduro\Collision\Adapters\Phpunit\Style;
 use Pest\Exceptions\ShouldNotHappen;
+use Pest\Logging\Converter;
 use Pest\Logging\TeamCity\Subscriber\TestConsideredRiskySubscriber;
 use Pest\Logging\TeamCity\Subscriber\TestErroredSubscriber;
 use Pest\Logging\TeamCity\Subscriber\TestExecutionFinishedSubscriber;
 use Pest\Logging\TeamCity\Subscriber\TestFailedSubscriber;
 use Pest\Logging\TeamCity\Subscriber\TestFinishedSubscriber;
-use Pest\Logging\TeamCity\Subscriber\TestMarkedIncompleteSubscriber;
 use Pest\Logging\TeamCity\Subscriber\TestPreparedSubscriber;
 use Pest\Logging\TeamCity\Subscriber\TestSkippedSubscriber;
 use Pest\Logging\TeamCity\Subscriber\TestSuiteFinishedSubscriber;
@@ -27,7 +27,6 @@ use PHPUnit\Event\Test\ConsideredRisky;
 use PHPUnit\Event\Test\Errored;
 use PHPUnit\Event\Test\Failed;
 use PHPUnit\Event\Test\Finished;
-use PHPUnit\Event\Test\MarkedIncomplete;
 use PHPUnit\Event\Test\Prepared;
 use PHPUnit\Event\Test\Skipped;
 use PHPUnit\Event\TestRunner\ExecutionFinished;
@@ -44,8 +43,14 @@ use Symfony\Component\Console\Output\OutputInterface;
  */
 final class TeamCityLogger
 {
+    /**
+     * The current time.
+     */
     private ?HRTime $time = null;
 
+    /**
+     * Indicates if the summary test count has been printed.
+     */
     private bool $isSummaryTestCountPrinted = false;
 
     /**
@@ -60,7 +65,7 @@ final class TeamCityLogger
     public function __construct(
         private readonly OutputInterface $output,
         private readonly Converter $converter,
-        private readonly int|null $flowId,
+        private readonly ?int $flowId,
         private readonly bool $withoutDuration,
     ) {
         $this->registerSubscribers();
@@ -107,7 +112,7 @@ final class TeamCityLogger
         $this->time = $event->telemetryInfo()->time();
     }
 
-    public function testMarkedIncomplete(MarkedIncomplete $event): never
+    public function testMarkedIncomplete(): never
     {
         throw ShouldNotHappen::fromMessage('testMarkedIncomplete not implemented.');
     }
@@ -227,7 +232,6 @@ final class TeamCityLogger
             $reflector = new ReflectionClass($telemetry);
 
             $property = $reflector->getProperty('current');
-            $property->setAccessible(true);
             $snapshot = $property->getValue($telemetry);
             assert($snapshot instanceof Snapshot);
 
@@ -261,7 +265,6 @@ final class TeamCityLogger
             new TestFinishedSubscriber($this),
             new TestErroredSubscriber($this),
             new TestFailedSubscriber($this),
-            new TestMarkedIncompleteSubscriber($this),
             new TestSkippedSubscriber($this),
             new TestConsideredRiskySubscriber($this),
             new TestExecutionFinishedSubscriber($this),

src/Matchers/Any.php

@@ -7,6 +7,4 @@ namespace Pest\Matchers;
 /**
  * @internal
  */
-final class Any
-{
-}
+final class Any {}