chore: adjusts sponsors

Add SerpApi as a sponsor in the README.

.github/workflows/static.yml

@@ -2,10 +2,15 @@ name: Static Analysis
 
 on:
   push:
+    branches: [4.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'
@@ -19,17 +24,35 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
 
     - name: Setup PHP
       uses: shivammathur/setup-php@v2
       with:
-        php-version: 8.1
+        php-version: 8.3
         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.3-${{ matrix.dependency-version }}-composer-${{ hashFiles('**/composer.json') }}
+        restore-keys: |
+          static-php-8.3-${{ matrix.dependency-version }}-composer-
+          static-php-8.3-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: Profanity Check
+      run: composer test:profanity
 
     - name: Type Check
       run: composer test:type:check

.github/workflows/tests.yml

@@ -2,9 +2,12 @@ name: Tests
 
 on:
   push:
+    branches: [4.x]
   pull_request:
-  schedule:
-    - cron: '0 0 * * *'
+
+concurrency:
+  group: tests-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
 
 jobs:
   tests:
@@ -14,19 +17,19 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-        symfony: ['6.4', '7.0']
-        php: ['8.1', '8.2', '8.3']
-        dependency_version: [prefer-lowest, prefer-stable]
+        os: [ubuntu-latest, macos-latest] # windows-latest
+        symfony: ['7.4', '8.0']
+        php: ['8.3', '8.4', '8.5']
+        dependency_version: [prefer-stable]
         exclude:
-          - php: '8.1'
-            symfony: '7.0'
+          - php: '8.3'
+            symfony: '8.0'
 
     name: PHP ${{ matrix.php }} - Symfony ^${{ matrix.symfony }} - ${{ matrix.os }} - ${{ matrix.dependency_version }}
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
 
     - name: Setup PHP
       uses: shivammathur/setup-php@v2
@@ -34,6 +37,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: |
@@ -41,7 +59,8 @@ jobs:
         echo "::add-matcher::${{ runner.tool_cache }}/phpunit.json"
 
     - name: Install PHP dependencies
-      run: composer update --${{ matrix.dependency_version }} --no-interaction --no-progress --ansi --with="symfony/console:~${{ matrix.symfony }}"
+      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

.gitignore

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

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,38 +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)**
-- **[Spatie](https://spatie.be)**
-- **[Worksome](https://www.worksome.com/)**
+- **[CodeRabbit](https://coderabbit.ai/?ref=pestphp)**
+- **[Mailtrap](https://l.rw.rw/pestphp)**
+- **[SerpApi](https://serpapi.com/?ref=nunomaduro)**
+- **[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
 
+- [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)
-- [Codecourse](https://codecourse.com/?ref=pestphp)
-- [Laracasts](https://laracasts.com/?ref=pestphp)
-- [Laradir](https://laradir.com/?ref=pestphp)
-- [Localazy](https://localazy.com/?ref=pestphp)
-- [Stormlikes](https://www.stormlikes.net/?ref=pestphp)
-- [Zapiet](https://www.zapiet.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,10 +2,10 @@
 
 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}...2.x)
+- 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 Pest file with the message: `git commit -m "release: vX.X.X"`

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 (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);
 
@@ -32,10 +32,13 @@ $bootPest = (static function (): void {
         'status-file:',
         'progress-file:',
         'unexpected-output-file:',
-        'testresult-file:',
+        'test-result-file:',
+        'result-cache-file:',
         'teamcity-file:',
         'testdox-file:',
         'testdox-color',
+        'testdox-columns:',
+        'testdox-summary',
         'phpunit-argv:',
     ]);
 
@@ -61,7 +64,8 @@ $bootPest = (static function (): void {
 
     assert(isset($getopt['progress-file']) && is_string($getopt['progress-file']));
     assert(isset($getopt['unexpected-output-file']) && is_string($getopt['unexpected-output-file']));
-    assert(isset($getopt['testresult-file']) && is_string($getopt['testresult-file']));
+    assert(isset($getopt['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']));
 
@@ -77,10 +81,12 @@ $bootPest = (static function (): void {
         $phpunitArgv,
         $getopt['progress-file'],
         $getopt['unexpected-output-file'],
-        $getopt['testresult-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) {

composer.json

@@ -17,17 +17,21 @@
         }
     ],
     "require": {
-        "php": "^8.1.0",
-        "brianium/paratest": "^7.3.1",
-        "nunomaduro/collision": "^7.10.0|^8.1.0",
-        "nunomaduro/termwind": "^1.15.1|^2.0.0",
-        "pestphp/pest-plugin": "^2.1.1",
-        "pestphp/pest-plugin-arch": "^2.6.1",
-        "phpunit/phpunit": "^10.5.7"
+        "php": "^8.3.0",
+        "brianium/paratest": "^7.19.0",
+        "nunomaduro/collision": "^8.9.0",
+        "nunomaduro/termwind": "^2.4.0",
+        "pestphp/pest-plugin": "^4.0.0",
+        "pestphp/pest-plugin-arch": "^4.0.0",
+        "pestphp/pest-plugin-mutate": "^4.0.1",
+        "pestphp/pest-plugin-profanity": "^4.2.1",
+        "phpunit/phpunit": "^12.5.12",
+        "symfony/process": "^7.4.5|^8.0.5"
     },
     "conflict": {
-        "phpunit/phpunit": ">10.5.7",
-        "sebastian/exporter": "<5.1.0",
+        "filp/whoops": "<2.18.3",
+        "phpunit/phpunit": ">12.5.12",
+        "sebastian/exporter": "<7.0.0",
         "webmozart/assert": "<1.11.0"
     },
     "autoload": {
@@ -51,9 +55,10 @@
         ]
     },
     "require-dev": {
-        "pestphp/pest-dev-tools": "^2.16.0",
-        "pestphp/pest-plugin-type-coverage": "^2.8.0",
-        "symfony/process": "^6.4.0|^7.0.2"
+        "pestphp/pest-dev-tools": "^4.1.0",
+        "pestphp/pest-plugin-browser": "^4.3.0",
+        "pestphp/pest-plugin-type-coverage": "^4.0.3",
+        "psy/psysh": "^0.12.20"
     },
     "minimum-stability": "dev",
     "prefer-stable": true,
@@ -69,16 +74,17 @@
     ],
     "scripts": {
         "refacto": "rector",
-        "lint": "pint",
+        "lint": "pint --parallel",
         "test:refacto": "rector --dry-run",
-        "test:lint": "pint --test",
+        "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 bin/pest --type-coverage --min=100",
-        "test:unit": "php bin/pest --colors=always --exclude-group=integration --compact",
-        "test:inline": "php bin/pest --colors=always --configuration=phpunit.inline.xml",
-        "test:parallel": "php bin/pest --colors=always --exclude-group=integration --parallel --processes=3",
-        "test:integration": "php bin/pest --colors=always --group=integration",
-        "update:snapshots": "REBUILD_SNAPSHOTS=true php bin/pest --colors=always --update-snapshots",
+        "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",
@@ -92,6 +98,8 @@
     "extra": {
         "pest": {
             "plugins": [
+                "Pest\\Mutate\\Plugins\\Mutate",
+                "Pest\\Plugins\\Configuration",
                 "Pest\\Plugins\\Bail",
                 "Pest\\Plugins\\Cache",
                 "Pest\\Plugins\\Coverage",
@@ -107,8 +115,8 @@
                 "Pest\\Plugins\\Snapshot",
                 "Pest\\Plugins\\Verbose",
                 "Pest\\Plugins\\Version",
-                "Pest\\Plugins\\Parallel",
-                "Pest\\Plugins\\JUnit"
+                "Pest\\Plugins\\Shard",
+                "Pest\\Plugins\\Parallel"
             ]
         },
         "phpstan": {

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

@@ -2,13 +2,11 @@ ARG PHP=8.1
 FROM php:${PHP}-cli-alpine
 
 RUN apk update && apk add \
-    zip libzip-dev icu-dev git \
+    zip libzip-dev icu-dev git
 
-RUN docker-php-ext-configure zip intl
 RUN docker-php-ext-install zip intl
-RUN docker-php-ext-enable zip intl
 
-RUN apk add --no-cache 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

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

@@ -1,16 +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)
     {
-        /** @see \Pest\Logging\JUnit\JUnitLogger */
+        $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,19 +32,27 @@
  * 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 Exception;
 use Pest\Contracts\HasPrintableTestCaseName;
-use PHPUnit\Framework\SelfDescribing;
 use PHPUnit\Framework\Test;
-use PHPUnit\Framework\TestCase;
 use PHPUnit\Framework\TestSuite;
+use PHPUnit\Runner\PhptTestCase;
 use RecursiveFilterIterator;
 use RecursiveIterator;
 
 use function end;
-use function implode;
 use function preg_match;
 use function sprintf;
 use function str_replace;
@@ -52,22 +60,30 @@ 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
@@ -78,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
@@ -108,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:
@@ -126,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],
                 );
             }
 
@@ -139,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

@@ -46,9 +46,10 @@ declare(strict_types=1);
 namespace PHPUnit\Runner\ResultCache;
 
 use const DIRECTORY_SEPARATOR;
+use const LOCK_EX;
 
 use PHPUnit\Framework\TestStatus\TestStatus;
-use PHPUnit\Runner\DirectoryCannotBeCreatedException;
+use PHPUnit\Runner\DirectoryDoesNotExistException;
 use PHPUnit\Runner\Exception;
 use PHPUnit\Util\Filesystem;
 
@@ -65,29 +66,23 @@ use function json_encode;
 use function Pest\version;
 
 /**
+ * @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 = [];
 
@@ -100,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
@@ -133,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) {
@@ -167,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 = [
@@ -183,7 +192,7 @@ final class DefaultResultCache implements ResultCache
         file_put_contents(
             $this->cacheFilename,
             json_encode($data),
-            LOCK_EX
+            LOCK_EX,
         );
     }
 

overrides/Runner/TestSuiteLoader.php

@@ -38,11 +38,13 @@ namespace PHPUnit\Runner;
 
 use Exception;
 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;
@@ -86,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);
         })();

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.
  *
@@ -46,6 +45,7 @@ declare(strict_types=1);
 namespace PHPUnit\TextUI;
 
 use Pest\Plugins\Only;
+use Pest\Runner\Filter\EnsureTestCaseIsInitiatedFilter;
 use PHPUnit\Event;
 use PHPUnit\Framework\TestSuite;
 use PHPUnit\Runner\Filter\Factory;
@@ -57,73 +57,82 @@ 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

@@ -17,7 +17,7 @@ final class BootExcludeList implements Bootstrapper
      *
      * @var array<int, non-empty-string>
      */
-    private const EXCLUDE_LIST = [
+    private const array EXCLUDE_LIST = [
         'bin',
         'overrides',
         'resources',

src/Bootstrappers/BootFiles.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Pest\Bootstrappers;
 
 use Pest\Contracts\Bootstrapper;
+use Pest\Exceptions\FatalException;
 use Pest\Support\DatasetInfo;
 use Pest\Support\Str;
 use Pest\TestSuite;
@@ -24,7 +25,7 @@ final class BootFiles implements Bootstrapper
      *
      * @var array<int, string>
      */
-    private const STRUCTURE = [
+    private const array STRUCTURE = [
         'Expectations',
         'Expectations.php',
         'Helpers',
@@ -40,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);
 
@@ -78,7 +83,7 @@ final class BootFiles implements Bootstrapper
 
     private function bootDatasets(string $testsPath): void
     {
-        assert(strlen($testsPath) > 0);
+        assert($testsPath !== '');
 
         $files = (new PhpUnitFileIterator)->getFilesAsArray($testsPath, '.php');
 

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,12 +17,12 @@ 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,28 +13,26 @@ 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,
         Subscribers\EnsureTeamCityEnabled::class,
-        Subscribers\EnsureJunitEnabled::class,
     ];
 
     /**
      * 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

@@ -60,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;
 
 /**
@@ -33,9 +38,40 @@ trait Testable
     private static string $__latestDescription;
 
     /**
-     * The test's describing, if any.
+     * The test's assignees.
      */
-    public ?string $__describing = null;
+    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.
@@ -77,20 +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->__describing = $method->describing;
-            $this->__test = $method->getClosure($this);
-        }
+        return $this;
     }
 
     /**
@@ -164,7 +195,11 @@ trait Testable
             $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);
+        }
     }
 
     /**
@@ -186,14 +221,20 @@ 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 = $this->dataName() ? $method->description.' with '.$this->dataName() : $method->description;
-        $description = htmlspecialchars(html_entity_decode($description), ENT_NOQUOTES);
+        $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 = [];
@@ -211,6 +252,10 @@ trait Testable
         }
 
         $this->__description = self::$__latestDescription = $description;
+        self::$__latestAssignees = $method->assignees;
+        self::$__latestNotes = $method->notes;
+        self::$__latestIssues = $method->issues;
+        self::$__latestPrs = $method->prs;
 
         parent::setUp();
 
@@ -220,13 +265,40 @@ trait Testable
             $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);
 
@@ -234,11 +306,16 @@ trait Testable
             $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);
+        }
     }
 
     /**
@@ -249,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);
     }
@@ -264,7 +341,12 @@ trait Testable
         $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
 
         if ($method->repetitions > 1) {
-            array_shift($arguments);
+            // 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');
@@ -286,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;
         }
 
@@ -309,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;
@@ -322,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);
     }
 
     /**
@@ -337,22 +429,22 @@ trait Testable
         return ExceptionTrace::ensure(fn (): mixed => call_user_func_array(Closure::bind($closure, $this, $this::class), $arguments));
     }
 
-    /** @postCondition */
+    /**
+     * 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;
         }
 
-        if (count($this->__snapshotChanges) === 1) {
-            $this->markTestIncomplete($this->__snapshotChanges[0]);
-
-            return;
-        }
-
-        $messages = implode(PHP_EOL, array_map(static fn (string $message): string => '- $message', $this->__snapshotChanges));
-
-        $this->markTestIncomplete($messages);
+        $this->markTestIncomplete(implode('. ', $this->__snapshotChanges));
     }
 
     /**
@@ -376,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,17 +15,21 @@ 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 = [
+    private const array FUNDING_MESSAGES = [
         'Star' => 'https://github.com/pestphp/pest',
-        'News' => 'https://twitter.com/pestphp',
-        'Videos' => 'https://youtube.com/@nunomaduro',
+        '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',
     ];
 
@@ -33,8 +37,8 @@ final class Thanks
      * Creates a new Console Command instance.
      */
     public function __construct(
-        private readonly InputInterface $input,
-        private readonly OutputInterface $output
+        private InputInterface $input,
+        private OutputInterface $output
     ) {
         // ..
     }
@@ -50,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(
@@ -72,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/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/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/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

@@ -30,8 +30,12 @@ use Pest\Expectations\HigherOrderExpectation;
 use Pest\Expectations\OppositeExpectation;
 use Pest\Matchers\Any;
 use Pest\Support\ExpectationPipeline;
+use Pest\Support\Reflection;
 use PHPUnit\Architecture\Elements\ObjectDescription;
 use PHPUnit\Framework\ExpectationFailedException;
+use ReflectionEnum;
+use ReflectionMethod;
+use ReflectionProperty;
 
 /**
  * @template TValue
@@ -48,7 +52,9 @@ use PHPUnit\Framework\ExpectationFailedException;
  */
 final class Expectation
 {
+    /** @use Extendable<self<TValue>> */
     use Extendable;
+
     use Pipeable;
     use Retrievable;
 
@@ -219,7 +225,7 @@ final class Expectation
             throw new BadMethodCallException('Expectation value is not iterable.');
         }
 
-        if (count($callbacks) == 0) {
+        if ($callbacks === []) {
             throw new InvalidArgumentException('No sequence expectations defined.');
         }
 
@@ -260,7 +266,7 @@ final class Expectation
         $matched = false;
 
         foreach ($expressions as $key => $callback) {
-            if ($subject != $key) {
+            if ($subject != $key) { // @pest-arch-ignore-line
                 continue;
             }
 
@@ -326,7 +332,7 @@ final class Expectation
      * @param  array<int, mixed>  $parameters
      * @return Expectation<TValue>|HigherOrderExpectation<Expectation<TValue>, TValue>
      */
-    public function __call(string $method, array $parameters): Expectation|HigherOrderExpectation|PendingArchExpectation
+    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)) {
@@ -347,9 +353,19 @@ final class Expectation
             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;
@@ -370,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;
             }
         }
@@ -383,7 +399,7 @@ 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)) {
@@ -414,7 +430,7 @@ final class Expectation
      */
     public function any(): Any
     {
-        return new Any();
+        return new Any;
     }
 
     /**
@@ -427,6 +443,71 @@ 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.
      */
@@ -434,12 +515,25 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => str_contains((string) file_get_contents($object->path), 'declare(strict_types=1);'),
+            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.
      */
@@ -447,7 +541,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && $object->reflectionClass->isFinal(),
+            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')),
         );
@@ -460,7 +554,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && $object->reflectionClass->isReadOnly() && assert(true), // @phpstan-ignore-line
+            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')),
         );
@@ -473,7 +567,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->isTrait(),
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && $object->reflectionClass->isTrait(),
             'to be trait',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -494,7 +588,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->isAbstract(),
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && $object->reflectionClass->isAbstract(),
             'to be abstract',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -502,17 +596,79 @@ final class Expectation
 
     /**
      * Asserts that the given expectation target has a specific method.
+     *
+     * @param  array<int, string>|string  $method
      */
-    public function toHaveMethod(string $method): ArchExpectation
+    public function toHaveMethod(array|string $method): ArchExpectation
     {
+        $methods = is_array($method) ? $method : [$method];
+
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->hasMethod($method),
-            'to have method',
+            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.
      */
@@ -520,7 +676,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->isEnum(),
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && $object->reflectionClass->isEnum(),
             'to be enum',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -562,7 +718,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->isInterface(),
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && $object->reflectionClass->isInterface(),
             'to be interface',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -578,14 +734,12 @@ final class Expectation
 
     /**
      * Asserts that the given expectation target to be subclass of the given class.
-     *
-     * @param  class-string  $class
      */
     public function toExtend(string $class): ArchExpectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $class === $object->reflectionClass->getName() || $object->reflectionClass->isSubclassOf($class),
+            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')),
         );
@@ -604,6 +758,43 @@ final class Expectation
         );
     }
 
+    /**
+     * 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.
      */
@@ -611,7 +802,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->getInterfaceNames() === [],
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && $object->reflectionClass->getInterfaceNames() === [],
             'to implement nothing',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
@@ -620,7 +811,7 @@ final class Expectation
     /**
      * Asserts that the given expectation target to only implement the given interfaces.
      *
-     * @param  array<int, class-string>|class-string  $interfaces
+     * @param  array<int, string>|string  $interfaces
      */
     public function toOnlyImplement(array|string $interfaces): ArchExpectation
     {
@@ -628,7 +819,8 @@ final class Expectation
 
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => count($interfaces) === count($object->reflectionClass->getInterfaceNames())
+            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')),
@@ -642,7 +834,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => str_starts_with($object->reflectionClass->getShortName(), $prefix),
+            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')),
         );
@@ -655,7 +847,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => str_ends_with($object->reflectionClass->getName(), $suffix),
+            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')),
         );
@@ -664,7 +856,7 @@ final class Expectation
     /**
      * Asserts that the given expectation target to implement the given interfaces.
      *
-     * @param  array<int, class-string>|class-string  $interfaces
+     * @param  array<int, string>|string  $interfaces
      */
     public function toImplement(array|string $interfaces): ArchExpectation
     {
@@ -674,7 +866,7 @@ final class Expectation
             $this,
             function (ObjectDescription $object) use ($interfaces): bool {
                 foreach ($interfaces as $interface) {
-                    if (! $object->reflectionClass->implementsInterface($interface)) {
+                    if (! isset($object->reflectionClass) || ! $object->reflectionClass->implementsInterface($interface)) {
                         return false;
                     }
                 }
@@ -704,7 +896,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']);
     }
@@ -744,7 +947,7 @@ final class Expectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->hasMethod('__invoke'),
+            fn (ObjectDescription $object): bool => isset($object->reflectionClass) && $object->reflectionClass->hasMethod('__invoke'),
             'to be invokable',
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
         );
@@ -848,14 +1051,12 @@ final class Expectation
 
     /**
      * Asserts that the given expectation target to have the given attribute.
-     *
-     * @param  class-string<Attribute>  $attribute
      */
     public function toHaveAttribute(string $attribute): ArchExpectation
     {
         return Targeted::make(
             $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->getAttributes($attribute) !== [],
+            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')),
         );
@@ -876,4 +1077,52 @@ final class Expectation
     {
         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

@@ -17,6 +17,9 @@ use function expect;
  */
 final class EachExpectation
 {
+    /**
+     * Indicates if the expectation is the opposite.
+     */
     private bool $opposite = false;
 
     /**
@@ -24,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

@@ -15,12 +15,18 @@ 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
@@ -29,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.
@@ -72,32 +76,126 @@ 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));
     }
 
+    /**
+     * Asserts that the given expectation target does not have the given permissions
+     */
+    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(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! str_contains((string) file_get_contents($object->path), 'declare(strict_types=1);'),
+            $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(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && ! $object->reflectionClass->isFinal(),
+            $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')),
         );
@@ -108,9 +206,12 @@ final class OppositeExpectation
      */
     public function toBeReadonly(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && ! $object->reflectionClass->isReadOnly() && assert(true), // @phpstan-ignore-line
+            $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')),
         );
@@ -121,9 +222,12 @@ final class OppositeExpectation
      */
     public function toBeTrait(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isTrait(),
+            $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')),
         );
@@ -142,9 +246,12 @@ final class OppositeExpectation
      */
     public function toBeAbstract(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isAbstract(),
+            $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')),
         );
@@ -152,25 +259,208 @@ final class OppositeExpectation
 
     /**
      * Asserts that the given expectation target does not have a specific method.
+     *
+     * @param  array<int, string>|string  $method
      */
-    public function toHaveMethod(string $method): ArchExpectation
+    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(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! $object->reflectionClass->hasMethod($method),
-            'to not have method',
+            $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(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isEnum(),
+            $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')),
         );
@@ -189,8 +479,11 @@ final class OppositeExpectation
      */
     public function toBeClass(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
+            $original,
             fn (ObjectDescription $object): bool => ! class_exists($object->name),
             'not to be class',
             FileLineFinder::where(fn (string $line): bool => true),
@@ -210,9 +503,12 @@ final class OppositeExpectation
      */
     public function toBeInterface(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isInterface(),
+            $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')),
         );
@@ -228,14 +524,15 @@ final class OppositeExpectation
 
     /**
      * Asserts that the given expectation target to be not subclass of the given class.
-     *
-     * @param  class-string  $class
      */
     public function toExtend(string $class): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isSubclassOf($class),
+            $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')),
         );
@@ -246,28 +543,70 @@ final class OppositeExpectation
      */
     public function toExtendNothing(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->getParentClass() !== false,
+            $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,
+            function (ObjectDescription $object) use ($traits): bool {
+                foreach ($traits as $trait) {
+                    if (isset($object->reflectionClass) && in_array($trait, $object->reflectionClass->getTraitNames(), true)) {
+                        return false;
+                    }
+                }
+
+                return 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, class-string>|string  $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(
-            $this->original,
+            $original,
             function (ObjectDescription $object) use ($interfaces): bool {
                 foreach ($interfaces as $interface) {
-                    if ($object->reflectionClass->implementsInterface($interface)) {
+                    if (isset($object->reflectionClass) && $object->reflectionClass->implementsInterface($interface)) {
                         return false;
                     }
                 }
@@ -284,9 +623,12 @@ final class OppositeExpectation
      */
     public function toImplementNothing(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->getInterfaceNames() !== [],
+            $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')),
         );
@@ -294,10 +636,8 @@ final class OppositeExpectation
 
     /**
      * Not supported.
-     *
-     * @param  array<int, class-string>|string  $interfaces
      */
-    public function toOnlyImplement(array|string $interfaces): never
+    public function toOnlyImplement(): void
     {
         throw InvalidExpectation::fromMethods(['not', 'toOnlyImplement']);
     }
@@ -307,9 +647,12 @@ final class OppositeExpectation
      */
     public function toHavePrefix(string $prefix): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! str_starts_with($object->reflectionClass->getShortName(), $prefix),
+            $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')),
         );
@@ -320,9 +663,12 @@ final class OppositeExpectation
      */
     public function toHaveSuffix(string $suffix): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! str_ends_with($object->reflectionClass->getName(), $suffix),
+            $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')),
         );
@@ -330,10 +676,8 @@ final class OppositeExpectation
 
     /**
      * Not supported.
-     *
-     * @param  array<int, string>|string  $targets
      */
-    public function toOnlyUse(array|string $targets): never
+    public function toOnlyUse(): void
     {
         throw InvalidExpectation::fromMethods(['not', 'toOnlyUse']);
     }
@@ -341,7 +685,7 @@ final class OppositeExpectation
     /**
      * Not supported.
      */
-    public function toUseNothing(): never
+    public function toUseNothing(): void
     {
         throw InvalidExpectation::fromMethods(['not', 'toUseNothing']);
     }
@@ -351,7 +695,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);
     }
 
     /**
@@ -361,12 +708,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']);
     }
@@ -374,7 +724,7 @@ 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']);
     }
@@ -384,9 +734,12 @@ final class OppositeExpectation
      */
     public function toBeInvokable(): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => ! $object->reflectionClass->hasMethod('__invoke'),
+            $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'))
         );
@@ -394,14 +747,15 @@ final class OppositeExpectation
 
     /**
      * Asserts that the given expectation target not to have the given attribute.
-     *
-     * @param  class-string<Attribute>  $attribute
      */
     public function toHaveAttribute(string $attribute): ArchExpectation
     {
+        /** @var Expectation<array<int, string>|string> $original */
+        $original = $this->original;
+
         return Targeted::make(
-            $this->original,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->getAttributes($attribute) === [],
+            $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'))
         );
@@ -485,4 +839,55 @@ final class OppositeExpectation
     {
         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($method->describing !== null ? Str::describe($method->describing, $depend) : $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,30 +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.
@@ -146,32 +133,21 @@ final class TestCaseFactory
             $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.');

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,9 +23,23 @@ final class TestCaseMethodFactory
     use HigherOrderable;
 
     /**
-     * The test's describing, if any.
+     * The list of attributes.
+     *
+     * @var array<int, Attribute>
      */
-    public ?string $describing = null;
+    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.
@@ -36,6 +51,34 @@ final class TestCaseMethodFactory
      */
     public bool $todo = false;
 
+    /**
+     * 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.
      *
@@ -58,31 +101,28 @@ final class TestCaseMethodFactory
     public array $groups = [];
 
     /**
-     * The covered classes and functions.
-     *
-     * @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 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();
     }
 
     /**
-     * Creates the test's closure.
+     * 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
 
@@ -90,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);
@@ -107,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);
         };
     }
 
@@ -116,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.');
@@ -134,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 ($attributesToUse as $attribute) {
-            $attributes = (new $attribute())->__invoke($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],
+            );
         }
 
         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 (string $annotation): string => sprintf("\n     * %s", $annotation), $annotations,
-        ));
-
-        $attributes = implode('', array_map(
-            static fn (string $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;
     }
 

src/Functions.php

@@ -2,10 +2,16 @@
 
 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;
@@ -13,7 +19,9 @@ 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;
@@ -39,7 +47,7 @@ if (! function_exists('beforeAll')) {
      */
     function beforeAll(Closure $closure): void
     {
-        if (! is_null(DescribeCall::describing())) {
+        if (DescribeCall::describing() !== []) {
             $filename = Backtrace::file();
 
             throw new BeforeAllWithinDescribe($filename);
@@ -53,6 +61,8 @@ if (! function_exists('beforeEach')) {
     /**
      * Runs the given closure before each test in the current file.
      *
+     * @param-closure-this TestCase  $closure
+     *
      * @return HigherOrderTapProxy<Expectable|TestCall|TestCase>|Expectable|TestCall|TestCase|mixed
      */
     function beforeEach(?Closure $closure = null): BeforeEachCall
@@ -89,7 +99,7 @@ if (! function_exists('describe')) {
     {
         $filename = Backtrace::testFile();
 
-        return new DescribeCall(TestSuite::getInstance(), $filename, $description, $tests);
+        return new DescribeCall(TestSuite::getInstance(), $filename, new Description($description), $tests);
     }
 }
 
@@ -108,12 +118,24 @@ 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.
      *
+     * @param-closure-this TestCase  $closure
+     *
      * @return Expectable|TestCall|TestCase|mixed
      */
     function test(?string $description = null, ?Closure $closure = null): HigherOrderTapProxy|TestCall
@@ -134,6 +156,8 @@ if (! function_exists('it')) {
      * is the test description; the second argument is
      * a closure that contains the test expectations.
      *
+     * @param-closure-this TestCase  $closure
+     *
      * @return Expectable|TestCall|TestCase|mixed
      */
     function it(string $description, ?Closure $closure = null): TestCall
@@ -149,9 +173,7 @@ 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 Expectable|TestCall|TestCase|mixed
      */
@@ -169,6 +191,8 @@ if (! function_exists('afterEach')) {
     /**
      * Runs the given closure after each test in the current file.
      *
+     * @param-closure-this TestCase  $closure
+     *
      * @return Expectable|HigherOrderTapProxy<Expectable|TestCall|TestCase>|TestCall|mixed
      */
     function afterEach(?Closure $closure = null): AfterEachCall
@@ -185,7 +209,7 @@ if (! function_exists('afterAll')) {
      */
     function afterAll(Closure $closure): void
     {
-        if (! is_null(DescribeCall::describing())) {
+        if (DescribeCall::describing() !== []) {
             $filename = Backtrace::file();
 
             throw new AfterAllWithinDescribe($filename);
@@ -194,3 +218,115 @@ if (! function_exists('afterAll')) {
         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,30 +4,37 @@ 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,
@@ -40,10 +47,10 @@ final class Kernel
      * 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());
+        //
     }
 
     /**
@@ -59,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);
@@ -68,11 +82,6 @@ final class Kernel
 
         CallsBoot::execute();
 
-        $kernel = new self(
-            new Application(),
-            $output,
-        );
-
         Container::getInstance()->add(self::class, $kernel);
 
         return $kernel;
@@ -81,14 +90,17 @@ final class 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([
                 '',
@@ -106,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

@@ -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)) {
@@ -162,6 +177,35 @@ final class Converter
      * Gets the test suite location.
      */
     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();
 
@@ -175,9 +219,7 @@ final class Converter
             throw ShouldNotHappen::fromMessage('Not an instance of TestMethod');
         }
 
-        $path = $firstTest->testDox()->prettifiedClassName();
-
-        return $this->toRelativePath($path);
+        return $firstTest;
     }
 
     /**
@@ -213,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/JUnit/JUnitLogger.php

@@ -1,384 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Logging\JUnit;
-
-use DOMDocument;
-use DOMElement;
-use Pest\Logging\Converter;
-use Pest\Logging\JUnit\Subscriber\TestErroredSubscriber;
-use Pest\Logging\JUnit\Subscriber\TestFailedSubscriber;
-use Pest\Logging\JUnit\Subscriber\TestFinishedSubscriber;
-use Pest\Logging\JUnit\Subscriber\TestMarkedIncompleteSubscriber;
-use Pest\Logging\JUnit\Subscriber\TestPreparedSubscriber;
-use Pest\Logging\JUnit\Subscriber\TestRunnerExecutionFinishedSubscriber;
-use Pest\Logging\JUnit\Subscriber\TestSkippedSubscriber;
-use Pest\Logging\JUnit\Subscriber\TestSuiteFinishedSubscriber;
-use Pest\Logging\JUnit\Subscriber\TestSuiteStartedSubscriber;
-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\Prepared;
-use PHPUnit\Event\Test\Skipped;
-use PHPUnit\Event\TestData\NoDataSetFromDataProviderException;
-use PHPUnit\Event\TestSuite\Started;
-use PHPUnit\Event\UnknownSubscriberTypeException;
-use PHPUnit\TextUI\Output\Printer;
-use PHPUnit\Util\Xml;
-
-/**
- * @internal
- */
-final class JUnitLogger
-{
-    private DOMDocument $document;
-
-    private DOMElement $root;
-
-    /**
-     * @var DOMElement[]
-     */
-    private array $testSuites = [];
-
-    /**
-     * @psalm-var array<int,int>
-     */
-    private array $testSuiteTests = [0];
-
-    /**
-     * @psalm-var array<int,int>
-     */
-    private array $testSuiteAssertions = [0];
-
-    /**
-     * @psalm-var array<int,int>
-     */
-    private array $testSuiteErrors = [0];
-
-    /**
-     * @psalm-var array<int,int>
-     */
-    private array $testSuiteFailures = [0];
-
-    /**
-     * @psalm-var array<int,int>
-     */
-    private array $testSuiteSkipped = [0];
-
-    /**
-     * @psalm-var array<int,int|float>
-     */
-    private array $testSuiteTimes = [0];
-
-    private int $testSuiteLevel = 0;
-
-    private ?DOMElement $currentTestCase = null;
-
-    private ?HRTime $time = null;
-
-    private bool $prepared = false;
-
-    /**
-     * @throws EventFacadeIsSealedException
-     * @throws UnknownSubscriberTypeException
-     */
-    public function __construct(
-        private readonly Printer $printer,
-        private readonly Converter $converter,
-    ) {
-        $this->registerSubscribers();
-        $this->createDocument();
-    }
-
-    public function flush(): void
-    {
-        $this->printer->print((string) $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()));
-
-        if ($event->testSuite()->isForTestClass()) {
-            $testSuite->setAttribute('file', $this->converter->getTestSuiteLocation($event->testSuite()) ?? '');
-        }
-
-        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
-     * @throws NoDataSetFromDataProviderException
-     */
-    public function testPrepared(Prepared $event): void
-    {
-        $this->createTestCase($event);
-        $this->prepared = true;
-    }
-
-    /**
-     * @throws InvalidArgumentException
-     */
-    public function testFinished(Finished $event): void
-    {
-        $this->handleFinish($event->telemetryInfo(), $event->numberOfAssertionsPerformed());
-    }
-
-    /**
-     * @throws InvalidArgumentException
-     * @throws NoDataSetFromDataProviderException
-     */
-    public function testMarkedIncomplete(MarkedIncomplete $event): void
-    {
-        $this->handleIncompleteOrSkipped($event);
-    }
-
-    /**
-     * @throws InvalidArgumentException
-     * @throws NoDataSetFromDataProviderException
-     */
-    public function testSkipped(Skipped $event): void
-    {
-        $this->handleIncompleteOrSkipped($event);
-    }
-
-    /**
-     * @throws InvalidArgumentException
-     * @throws NoDataSetFromDataProviderException
-     */
-    public function testErrored(Errored $event): void
-    {
-        $this->handleFault($event, 'error');
-
-        $this->testSuiteErrors[$this->testSuiteLevel]++;
-    }
-
-    /**
-     * @throws InvalidArgumentException
-     * @throws NoDataSetFromDataProviderException
-     */
-    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 instanceof \DOMElement);
-        assert($this->time instanceof \PHPUnit\Event\Telemetry\HRTime);
-
-        $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(): void
-    {
-        $subscribers = [
-            new TestSuiteStartedSubscriber($this),
-            new TestSuiteFinishedSubscriber($this),
-            new TestPreparedSubscriber($this),
-            new TestFinishedSubscriber($this),
-            new TestErroredSubscriber($this),
-            new TestFailedSubscriber($this),
-            new TestMarkedIncompleteSubscriber($this),
-            new TestSkippedSubscriber($this),
-            new TestRunnerExecutionFinishedSubscriber($this),
-        ];
-
-        Facade::instance()->registerSubscribers(...$subscribers);
-    }
-
-    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
-     * @throws NoDataSetFromDataProviderException
-     */
-    private function handleFault(Errored|Failed $event, string $type): void
-    {
-        if (! $this->prepared) {
-            $this->createTestCase($event);
-        }
-
-        assert($this->currentTestCase instanceof \DOMElement);
-
-        $throwable = $event->throwable();
-
-        $testName = $this->converter->getTestCaseMethodName($event->test());
-        $message = $this->converter->getExceptionMessage($throwable);
-        $details = $this->converter->getExceptionDetails($throwable);
-
-        $buffer = $testName;
-        $buffer .= trim(
-            $message.PHP_EOL.
-            $details,
-        );
-
-        $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
-     * @throws NoDataSetFromDataProviderException
-     */
-    private function handleIncompleteOrSkipped(MarkedIncomplete|Skipped $event): void
-    {
-        if (! $this->prepared) {
-            $this->createTestCase($event);
-        }
-
-        assert($this->currentTestCase instanceof \DOMElement);
-
-        $skipped = $this->document->createElement('skipped');
-
-        $this->currentTestCase->appendChild($skipped);
-
-        $this->testSuiteSkipped[$this->testSuiteLevel]++;
-
-        if (! $this->prepared) {
-            $this->handleFinish($event->telemetryInfo(), 0);
-        }
-    }
-
-    /**
-     * @throws InvalidArgumentException
-     * @throws NoDataSetFromDataProviderException
-     *
-     * @psalm-assert !null $this->currentTestCase
-     */
-    private function createTestCase(Errored|Failed|MarkedIncomplete|Prepared|Skipped $event): void
-    {
-        $testCase = $this->document->createElement('testcase');
-
-        $test = $event->test();
-        $file = $this->converter->getTestCaseLocation($test);
-
-        $testCase->setAttribute('name', $this->converter->getTestCaseMethodName($test));
-        $testCase->setAttribute('file', $file);
-
-        if ($test->isTestMethod()) {
-            $className = $this->converter->getTrimmedTestClassName($test);
-            $testCase->setAttribute('class', $className);
-            $testCase->setAttribute('classname', str_replace('\\', '.', $className));
-        }
-
-        $this->currentTestCase = $testCase;
-        $this->time = $event->telemetryInfo()->time();
-    }
-}

src/Logging/JUnit/Subscriber/Subscriber.php

@@ -1,28 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Logging\JUnit\Subscriber;
-
-use Pest\Logging\JUnit\JUnitLogger;
-
-/**
- * @internal
- */
-abstract class Subscriber
-{
-    /**
-     * Creates a new Subscriber instance.
-     */
-    public function __construct(private readonly JUnitLogger $logger)
-    {
-    }
-
-    /**
-     * Creates a new JunitLogger instance.
-     */
-    final protected function logger(): JUnitLogger
-    {
-        return $this->logger;
-    }
-}

src/Logging/JUnit/Subscriber/TestErroredSubscriber.php

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

src/Logging/JUnit/Subscriber/TestFailedSubscriber.php

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

src/Logging/JUnit/Subscriber/TestFinishedSubscriber.php

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

src/Logging/JUnit/Subscriber/TestMarkedIncompleteSubscriber.php

@@ -1,19 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Logging\JUnit\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/JUnit/Subscriber/TestPreparedSubscriber.php

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

src/Logging/JUnit/Subscriber/TestRunnerExecutionFinishedSubscriber.php

@@ -1,19 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Logging\JUnit\Subscriber;
-
-use PHPUnit\Event\TestRunner\ExecutionFinished;
-use PHPUnit\Event\TestRunner\ExecutionFinishedSubscriber;
-
-/**
- * @internal
- */
-final class TestRunnerExecutionFinishedSubscriber extends Subscriber implements ExecutionFinishedSubscriber
-{
-    public function notify(ExecutionFinished $event): void
-    {
-        $this->logger()->flush();
-    }
-}

src/Logging/JUnit/Subscriber/TestSkippedSubscriber.php

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

src/Logging/JUnit/Subscriber/TestSuiteFinishedSubscriber.php

@@ -1,19 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Logging\JUnit\Subscriber;
-
-use PHPUnit\Event\TestSuite\Finished;
-use PHPUnit\Event\TestSuite\FinishedSubscriber;
-
-/**
- * @internal
- */
-final class TestSuiteFinishedSubscriber extends Subscriber implements FinishedSubscriber
-{
-    public function notify(Finished $event): void
-    {
-        $this->logger()->testSuiteFinished();
-    }
-}

src/Logging/JUnit/Subscriber/TestSuiteStartedSubscriber.php

@@ -1,19 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Logging\JUnit\Subscriber;
-
-use PHPUnit\Event\TestSuite\Started;
-use PHPUnit\Event\TestSuite\StartedSubscriber;
-
-/**
- * @internal
- */
-final class TestSuiteStartedSubscriber extends Subscriber implements StartedSubscriber
-{
-    public function notify(Started $event): void
-    {
-        $this->logger()->testSuiteStarted($event);
-    }
-}

src/Logging/TeamCity/ServiceMessage.php

@@ -9,6 +9,9 @@ namespace Pest\Logging\TeamCity;
  */
 final class ServiceMessage
 {
+    /**
+     * The flow ID.
+     */
     private static ?int $flowId = null;
 
     /**
@@ -17,8 +20,7 @@ final class ServiceMessage
     public function __construct(
         private readonly string $type,
         private readonly array $parameters,
-    ) {
-    }
+    ) {}
 
     public function toString(): string
     {
@@ -36,7 +38,7 @@ final class ServiceMessage
     {
         return new self('testSuiteStarted', [
             'name' => $name,
-            'locationHint' => $location === null ? null : "file://$location",
+            'locationHint' => $location === null ? null : "pest_qn://$location",
         ]);
     }
 

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

@@ -12,7 +12,6 @@ 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;
@@ -28,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;
@@ -45,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;
 
     /**
@@ -108,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.');
     }
@@ -228,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);
 
@@ -262,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),