release: 2.35.1

Include method name in toHaveMethod error message

.github/workflows/tests.yml

@@ -3,8 +3,6 @@ name: Tests
 on:
   push:
   pull_request:
-  schedule:
-    - cron: '0 0 * * *'
 
 jobs:
   tests:
@@ -15,12 +13,12 @@ jobs:
       fail-fast: true
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        symfony: ['6.4.0', '7.0.1']
+        symfony: ['6.4', '7.0']
         php: ['8.1', '8.2', '8.3']
         dependency_version: [prefer-lowest, prefer-stable]
         exclude:
           - php: '8.1'
-            symfony: '7.0.1'
+            symfony: '7.0'
 
     name: PHP ${{ matrix.php }} - Symfony ^${{ matrix.symfony }} - ${{ matrix.os }} - ${{ matrix.dependency_version }}
 
@@ -41,7 +39,7 @@ 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 }}"
+      run: composer update --${{ matrix.dependency_version }} --no-interaction --no-progress --ansi --with="symfony/console:~${{ matrix.symfony }}"
 
     - name: Unit Tests
       run: composer test:unit

README.md

@@ -21,18 +21,20 @@ We cannot thank our sponsors enough for their incredible support in funding Pest
 
 ### Platinum Sponsors
 
+- **[LaraJobs](https://larajobs.com)**
+- **[Brokerchooser](https://brokerchooser.com)**
 - **[Forge](https://forge.laravel.com)**
-- **[LoadForge](https://loadforge.com)**
 - **[Spatie](https://spatie.be)**
 - **[Worksome](https://www.worksome.com/)**
 
 ### Premium Sponsors
 
-- [Akaunting](https://akaunting.com)
-- [Codecourse](https://codecourse.com/)
-- [Laracasts](https://laracasts.com/)
-- [Localazy](https://localazy.com)
-- [Meema](https://meema.io)
-- [Zapiet](https://www.zapiet.com)
+- [Akaunting](https://akaunting.com/?ref=pestphp)
+- [Codecourse](https://codecourse.com/?ref=pestphp)
+- [DocuWriter.ai](https://www.docuwriter.ai/?ref=pestphp)
+- [Laracasts](https://laracasts.com/?ref=pestphp)
+- [Localazy](https://localazy.com/?ref=pestphp)
+- [Route4Me](https://www.route4me.com/?ref=pestphp)
+- [Zapiet](https://www.zapiet.com/?ref=pestphp)
 
 Pest is an open-sourced software licensed under the **[MIT license](https://opensource.org/licenses/MIT)**.

bin/pest

@@ -13,39 +13,39 @@ 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;
 
-    foreach ($args as $key => $value) {
+    foreach ($arguments 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]);
+            unset($arguments[$key]);
         }
 
         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 (str_contains($value, '--teamcity')) {
-            unset($args[$key]);
-            $args[] = '--no-output';
+            unset($arguments[$key]);
+            $arguments[] = '--no-output';
             unset($_SERVER['COLLISION_PRINTER']);
         }
     }
@@ -88,9 +88,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);
 
@@ -81,6 +81,7 @@ $bootPest = (static function (): void {
         $getopt['teamcity-file'] ?? null,
         $getopt['testdox-file'] ?? null,
         isset($getopt['testdox-color']),
+        $getopt['testdox-columns'] ?? null,
     );
 
     while (true) {

composer.json

@@ -19,14 +19,14 @@
     "require": {
         "php": "^8.1.0",
         "brianium/paratest": "^7.3.1",
-        "nunomaduro/collision": "^7.10.0|^8.0.0",
-        "nunomaduro/termwind": "^1.15.1|^2.0.0",
+        "nunomaduro/collision": "^7.10.0|^8.4.0",
+        "nunomaduro/termwind": "^1.15.1|^2.0.1",
         "pestphp/pest-plugin": "^2.1.1",
-        "pestphp/pest-plugin-arch": "^2.5.0",
-        "phpunit/phpunit": "^10.5.2"
+        "pestphp/pest-plugin-arch": "^2.7.0",
+        "phpunit/phpunit": "^10.5.17"
     },
     "conflict": {
-        "phpunit/phpunit": ">10.5.2",
+        "phpunit/phpunit": ">10.5.17",
         "sebastian/exporter": "<5.1.0",
         "webmozart/assert": "<1.11.0"
     },
@@ -52,8 +52,8 @@
     },
     "require-dev": {
         "pestphp/pest-dev-tools": "^2.16.0",
-        "pestphp/pest-plugin-type-coverage": "^2.5.0",
-        "symfony/process": "^6.4.0|^7.0.1"
+        "pestphp/pest-plugin-type-coverage": "^2.8.5",
+        "symfony/process": "^6.4.0|^7.1.3"
     },
     "minimum-stability": "dev",
     "prefer-stable": true,

docker/Dockerfile

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

overrides/Logging/JUnit/JunitXmlLogger.php

@@ -0,0 +1,459 @@
+<?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\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;
+
+/**
+ * @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 = [];
+
+    /**
+     * @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>
+     */
+    private array $testSuiteTimes = [0];
+
+    private int $testSuiteLevel = 0;
+
+    private ?DOMElement $currentTestCase = null;
+
+    private ?HRTime $time = null;
+
+    private bool $prepared = false;
+
+    private bool $preparationFailed = false;
+
+    /**
+     * @throws EventFacadeIsSealedException
+     * @throws UnknownSubscriberTypeException
+     */
+    public function __construct(Printer $printer, Facade $facade)
+    {
+        $this->printer = $printer;
+        $this->converter = new \Pest\Logging\Converter(\Pest\Support\Container::getInstance()->get(\Pest\TestSuite::class)->rootPath); // pest-added
+
+        $this->registerSubscribers($facade);
+        $this->createDocument();
+    }
+
+    public function flush(): void
+    {
+        $this->printer->print($this->document->saveXML());
+
+        $this->printer->flush();
+    }
+
+    public function testSuiteStarted(Started $event): void
+    {
+        $testSuite = $this->document->createElement('testsuite');
+        $testSuite->setAttribute('name', $this->converter->getTestSuiteName($event->testSuite())); // pest-changed
+
+        if ($event->testSuite()->isForTestClass()) {
+            $testSuite->setAttribute('file', $this->converter->getTestSuiteLocation($event->testSuite()) ?? ''); // pest-changed
+        }
+
+        if ($this->testSuiteLevel > 0) {
+            $this->testSuites[$this->testSuiteLevel]->appendChild($testSuite);
+        } else {
+            $this->root->appendChild($testSuite);
+        }
+
+        $this->testSuiteLevel++;
+        $this->testSuites[$this->testSuiteLevel] = $testSuite;
+        $this->testSuiteTests[$this->testSuiteLevel] = 0;
+        $this->testSuiteAssertions[$this->testSuiteLevel] = 0;
+        $this->testSuiteErrors[$this->testSuiteLevel] = 0;
+        $this->testSuiteFailures[$this->testSuiteLevel] = 0;
+        $this->testSuiteSkipped[$this->testSuiteLevel] = 0;
+        $this->testSuiteTimes[$this->testSuiteLevel] = 0;
+    }
+
+    public function testSuiteFinished(): void
+    {
+        $this->testSuites[$this->testSuiteLevel]->setAttribute(
+            'tests',
+            (string) $this->testSuiteTests[$this->testSuiteLevel],
+        );
+
+        $this->testSuites[$this->testSuiteLevel]->setAttribute(
+            'assertions',
+            (string) $this->testSuiteAssertions[$this->testSuiteLevel],
+        );
+
+        $this->testSuites[$this->testSuiteLevel]->setAttribute(
+            'errors',
+            (string) $this->testSuiteErrors[$this->testSuiteLevel],
+        );
+
+        $this->testSuites[$this->testSuiteLevel]->setAttribute(
+            'failures',
+            (string) $this->testSuiteFailures[$this->testSuiteLevel],
+        );
+
+        $this->testSuites[$this->testSuiteLevel]->setAttribute(
+            'skipped',
+            (string) $this->testSuiteSkipped[$this->testSuiteLevel],
+        );
+
+        $this->testSuites[$this->testSuiteLevel]->setAttribute(
+            'time',
+            sprintf('%F', $this->testSuiteTimes[$this->testSuiteLevel]),
+        );
+
+        if ($this->testSuiteLevel > 1) {
+            $this->testSuiteTests[$this->testSuiteLevel - 1] += $this->testSuiteTests[$this->testSuiteLevel];
+            $this->testSuiteAssertions[$this->testSuiteLevel - 1] += $this->testSuiteAssertions[$this->testSuiteLevel];
+            $this->testSuiteErrors[$this->testSuiteLevel - 1] += $this->testSuiteErrors[$this->testSuiteLevel];
+            $this->testSuiteFailures[$this->testSuiteLevel - 1] += $this->testSuiteFailures[$this->testSuiteLevel];
+            $this->testSuiteSkipped[$this->testSuiteLevel - 1] += $this->testSuiteSkipped[$this->testSuiteLevel];
+            $this->testSuiteTimes[$this->testSuiteLevel - 1] += $this->testSuiteTimes[$this->testSuiteLevel];
+        }
+
+        $this->testSuiteLevel--;
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public function testPreparationStarted(PreparationStarted $event): void
+    {
+        $this->createTestCase($event);
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public function testPreparationFailed(): void
+    {
+        $this->preparationFailed = true;
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public function testPrepared(): void
+    {
+        $this->prepared = true;
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public function testFinished(Finished $event): void
+    {
+        if ($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 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
+     *
+     * @psalm-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/ResultCache/DefaultResultCache.php

@@ -59,7 +59,6 @@ use function file_get_contents;
 use function file_put_contents;
 use function is_array;
 use function is_dir;
-use function is_file;
 use function json_decode;
 use function json_encode;
 use function Pest\version;
@@ -91,7 +90,7 @@ final class DefaultResultCache implements ResultCache
      */
     private array $times = [];
 
-    public function __construct(string $filepath = null)
+    public function __construct(?string $filepath = null)
     {
         if ($filepath !== null && is_dir($filepath)) {
             $filepath .= DIRECTORY_SEPARATOR.self::DEFAULT_RESULT_CACHE_FILENAME;
@@ -129,13 +128,15 @@ final class DefaultResultCache implements ResultCache
 
     public function load(): void
     {
-        if (! is_file($this->cacheFilename)) {
+        $contents = @file_get_contents($this->cacheFilename);
+
+        if ($contents === false) {
             return;
         }
 
         $data = json_decode(
-            file_get_contents($this->cacheFilename),
-            true
+            $contents,
+            true,
         );
 
         if ($data === null) {

overrides/TextUI/TestSuiteFilterProcessor.php

@@ -59,19 +59,14 @@ use function array_map;
  */
 final class TestSuiteFilterProcessor
 {
-    private Factory $filterFactory;
-
-    public function __construct(Factory $factory = new Factory)
-    {
-        $this->filterFactory = $factory;
-    }
-
     /**
      * @throws Event\RuntimeException
      * @throws FilterNotConfiguredException
      */
     public function process(Configuration $configuration, TestSuite $suite): void
     {
+        $factory = new Factory;
+
         if (! $configuration->hasFilter() &&
             ! $configuration->hasGroups() &&
             ! $configuration->hasExcludeGroups() &&
@@ -83,21 +78,21 @@ final class TestSuiteFilterProcessor
         }
 
         if ($configuration->hasExcludeGroups()) {
-            $this->filterFactory->addExcludeGroupFilter(
+            $factory->addExcludeGroupFilter(
                 $configuration->excludeGroups()
             );
         }
 
         if (Only::isEnabled()) {
-            $this->filterFactory->addIncludeGroupFilter(['__pest_only']);
+            $factory->addIncludeGroupFilter(['__pest_only']);
         } elseif ($configuration->hasGroups()) {
-            $this->filterFactory->addIncludeGroupFilter(
+            $factory->addIncludeGroupFilter(
                 $configuration->groups()
             );
         }
 
         if ($configuration->hasTestsCovering()) {
-            $this->filterFactory->addIncludeGroupFilter(
+            $factory->addIncludeGroupFilter(
                 array_map(
                     static fn (string $name): string => '__phpunit_covers_'.$name,
                     $configuration->testsCovering()
@@ -106,7 +101,7 @@ final class TestSuiteFilterProcessor
         }
 
         if ($configuration->hasTestsUsing()) {
-            $this->filterFactory->addIncludeGroupFilter(
+            $factory->addIncludeGroupFilter(
                 array_map(
                     static fn (string $name): string => '__phpunit_uses_'.$name,
                     $configuration->testsUsing()
@@ -115,12 +110,12 @@ final class TestSuiteFilterProcessor
         }
 
         if ($configuration->hasFilter()) {
-            $this->filterFactory->addNameFilter(
+            $factory->addNameFilter(
                 $configuration->filter()
             );
         }
 
-        $suite->injectFilter($this->filterFactory);
+        $suite->injectFilter($factory);
 
         Event\Facade::emitter()->testSuiteFiltered(
             Event\TestSuite\TestSuiteBuilder::from($suite)

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>

src/Bootstrappers/BootOverrides.php

@@ -15,16 +15,17 @@ final class BootOverrides implements Bootstrapper
     /**
      * The list of files to be overridden.
      *
-     * @var array<int, string>
+     * @var array<string, string>
      */
-    private const FILES = [
-        'Runner/Filter/NameFilterIterator.php',
-        'Runner/ResultCache/DefaultResultCache.php',
-        'Runner/TestSuiteLoader.php',
-        'TextUI/Command/WarmCodeCoverageCacheCommand.php',
-        'TextUI/Output/Default/ProgressPrinter/TestSkippedSubscriber.php',
-        'TextUI/TestSuiteFilterProcessor.php',
-        'Event/Value/ThrowableBuilder.php',
+    public const FILES = [
+        'c7b9c8a96006dea314204a8f09a8764e51ce0b9b79aadd58da52e8c328db4870' => 'Runner/Filter/NameFilterIterator.php',
+        'c7c09ab7c9378710b27f761a4b2948196cbbdf2a73e4389bcdca1e7c94fa9c21' => 'Runner/ResultCache/DefaultResultCache.php',
+        'bc8718c89264f65800beabc23e51c6d3bcff87dfc764a12179ef5dbfde272c8b' => 'Runner/TestSuiteLoader.php',
+        'f41e48d6cb546772a7de4f8e66b6b7ce894a5318d063eb52e354d206e96c701c' => 'TextUI/Command/Commands/WarmCodeCoverageCacheCommand.php',
+        'cb7519f2d82893640b694492cf7ec9528da80773cc1d259634181b5d393528b5' => 'TextUI/Output/Default/ProgressPrinter/Subscriber/TestSkippedSubscriber.php',
+        '2f06e4b1a9f3a24145bfc7ea25df4f124117f940a2cde30a04d04d5678006bff' => 'TextUI/TestSuiteFilterProcessor.php',
+        'ef64a657ed9c0067791483784944107827bf227c7e3200f212b6751876b99e25' => 'Event/Value/ThrowableBuilder.php',
+        'c78f96e34b98ed01dd8106539d59b8aa8d67f733274118b827c01c5c4111c033' => 'Logging/JUnit/JunitXmlLogger.php',
     ];
 
     /**

src/Bootstrappers/BootSubscribers.php

@@ -32,8 +32,7 @@ final class BootSubscribers implements Bootstrapper
      */
     public function __construct(
         private readonly Container $container,
-    ) {
-    }
+    ) {}
 
     /**
      * Boots the list of Subscribers.

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

@@ -290,7 +290,7 @@ trait Testable
             return $arguments;
         }
 
-        if (in_array($testParameterTypes[0], [Closure::class, 'callable'])) {
+        if (isset($testParameterTypes[0]) && in_array($testParameterTypes[0], [Closure::class, 'callable'])) {
             return $arguments;
         }
 

src/Console/Thanks.php

@@ -50,7 +50,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(

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

@@ -32,6 +32,7 @@ use Pest\Matchers\Any;
 use Pest\Support\ExpectationPipeline;
 use PHPUnit\Architecture\Elements\ObjectDescription;
 use PHPUnit\Framework\ExpectationFailedException;
+use ReflectionEnum;
 
 /**
  * @template TValue
@@ -190,7 +191,7 @@ final class Expectation
      *
      * @return EachExpectation<TValue>
      */
-    public function each(callable $callback = null): EachExpectation
+    public function each(?callable $callback = null): EachExpectation
     {
         if (! is_iterable($this->value)) {
             throw new BadMethodCallException('Expectation value is not iterable.');
@@ -347,9 +348,15 @@ 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();
+
+        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;
@@ -414,7 +421,7 @@ final class Expectation
      */
     public function any(): Any
     {
-        return new Any();
+        return new Any;
     }
 
     /**
@@ -508,7 +515,7 @@ final class Expectation
         return Targeted::make(
             $this,
             fn (ObjectDescription $object): bool => $object->reflectionClass->hasMethod($method),
-            'to have method',
+            sprintf("to have method '%s'", $method),
             FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
         );
     }
@@ -535,7 +542,7 @@ final class Expectation
     }
 
     /**
-     * Asserts that the given expectation targets is an class.
+     * Asserts that the given expectation target is a class.
      */
     public function toBeClass(): ArchExpectation
     {
@@ -876,4 +883,51 @@ 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 => $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

@@ -24,9 +24,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/OppositeExpectation.php

@@ -36,9 +36,7 @@ final class OppositeExpectation
      *
      * @param  Expectation<TValue>  $original
      */
-    public function __construct(private readonly Expectation $original)
-    {
-    }
+    public function __construct(private readonly Expectation $original) {}
 
     /**
      * Asserts that the value array not has the provided $keys.
@@ -485,4 +483,51 @@ 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
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! $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/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

@@ -7,6 +7,4 @@ namespace Pest\Factories\Covers;
 /**
  * @internal
  */
-final class CoversNothing
-{
-}
+final class CoversNothing {}

src/Factories/TestCaseFactory.php

@@ -154,7 +154,7 @@ final class TestCaseFactory
         foreach ($classAvailableAttributes as $attribute) {
             $classAttributes = array_reduce(
                 $methods,
-                fn (array $carry, TestCaseMethodFactory $methodFactory): array => (new $attribute())->__invoke($methodFactory, $carry),
+                fn (array $carry, TestCaseMethodFactory $methodFactory): array => (new $attribute)->__invoke($methodFactory, $carry),
                 $classAttributes
             );
         }

src/Factories/TestCaseMethodFactory.php

@@ -73,7 +73,7 @@ final class TestCaseMethodFactory
         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();
@@ -138,11 +138,11 @@ final class TestCaseMethodFactory
         $attributes = [];
 
         foreach ($annotationsToUse as $annotation) {
-            $annotations = (new $annotation())->__invoke($this, $annotations);
+            $annotations = (new $annotation)->__invoke($this, $annotations);
         }
 
         foreach ($attributesToUse as $attribute) {
-            $attributes = (new $attribute())->__invoke($this, $attributes);
+            $attributes = (new $attribute)->__invoke($this, $attributes);
         }
 
         if ($this->datasets !== [] || $this->repetitions > 1) {

src/Functions.php

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

src/Kernel.php

@@ -4,18 +4,25 @@ 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
@@ -43,7 +50,7 @@ final class Kernel
         private readonly Application $application,
         private readonly 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(fn () => $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

@@ -48,9 +48,9 @@ final class KernelDump
     }
 
     /**
-     * Shutdown the output buffering.
+     * Terminate the output buffering.
      */
-    public function shutdown(): void
+    public function terminate(): void
     {
         $this->disable();
     }

src/Logging/Converter.php

@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 
-namespace Pest\Logging\TeamCity;
+namespace Pest\Logging;
 
 use NunoMaduro\Collision\Adapters\Phpunit\State;
 use Pest\Exceptions\ShouldNotHappen;
@@ -36,7 +36,7 @@ final class Converter
     public function __construct(
         private readonly string $rootPath,
     ) {
-        $this->stateGenerator = new StateGenerator();
+        $this->stateGenerator = new StateGenerator;
     }
 
     /**
@@ -150,6 +150,14 @@ final class Converter
         return Str::after($name, self::PREFIX);
     }
 
+    /**
+     * Gets the trimmed test class name.
+     */
+    public function getTrimmedTestClassName(TestMethod $test): string
+    {
+        return Str::after($test->className(), self::PREFIX);
+    }
+
     /**
      * Gets the test suite location.
      */

src/Logging/TeamCity/ServiceMessage.php

@@ -17,8 +17,7 @@ final class ServiceMessage
     public function __construct(
         private readonly string $type,
         private readonly array $parameters,
-    ) {
-    }
+    ) {}
 
     public function toString(): string
     {
@@ -63,7 +62,7 @@ final class ServiceMessage
     }
 
     /**
-     * @param  int  $duration in milliseconds
+     * @param  int  $duration  in milliseconds
      */
     public static function testFinished(string $name, int $duration): self
     {
@@ -106,7 +105,7 @@ final class ServiceMessage
         ]);
     }
 
-    public static function testIgnored(string $name, string $message, string $details = null): self
+    public static function testIgnored(string $name, string $message, ?string $details = null): self
     {
         return new self('testIgnored', [
             'name' => $name,

src/Logging/TeamCity/Subscriber/Subscriber.php

@@ -14,9 +14,7 @@ abstract class Subscriber
     /**
      * Creates a new Subscriber instance.
      */
-    public function __construct(private readonly TeamCityLogger $logger)
-    {
-    }
+    public function __construct(private readonly TeamCityLogger $logger) {}
 
     /**
      * Creates a new TeamCityLogger instance.

src/Logging/TeamCity/TeamCityLogger.php

@@ -6,6 +6,7 @@ namespace Pest\Logging\TeamCity;
 
 use NunoMaduro\Collision\Adapters\Phpunit\Style;
 use Pest\Exceptions\ShouldNotHappen;
+use Pest\Logging\Converter;
 use Pest\Logging\TeamCity\Subscriber\TestConsideredRiskySubscriber;
 use Pest\Logging\TeamCity\Subscriber\TestErroredSubscriber;
 use Pest\Logging\TeamCity\Subscriber\TestExecutionFinishedSubscriber;

src/Matchers/Any.php

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

src/Mixins/Expectation.php

@@ -131,7 +131,7 @@ final class Expectation
      *
      * @return self<TValue>
      */
-    public function toBeGreaterThan(int|float|DateTimeInterface $expected, string $message = ''): self
+    public function toBeGreaterThan(int|float|string|DateTimeInterface $expected, string $message = ''): self
     {
         Assert::assertGreaterThan($expected, $this->value, $message);
 
@@ -143,7 +143,7 @@ final class Expectation
      *
      * @return self<TValue>
      */
-    public function toBeGreaterThanOrEqual(int|float|DateTimeInterface $expected, string $message = ''): self
+    public function toBeGreaterThanOrEqual(int|float|string|DateTimeInterface $expected, string $message = ''): self
     {
         Assert::assertGreaterThanOrEqual($expected, $this->value, $message);
 
@@ -155,7 +155,7 @@ final class Expectation
      *
      * @return self<TValue>
      */
-    public function toBeLessThan(int|float|DateTimeInterface $expected, string $message = ''): self
+    public function toBeLessThan(int|float|string|DateTimeInterface $expected, string $message = ''): self
     {
         Assert::assertLessThan($expected, $this->value, $message);
 
@@ -167,7 +167,7 @@ final class Expectation
      *
      * @return self<TValue>
      */
-    public function toBeLessThanOrEqual(int|float|DateTimeInterface $expected, string $message = ''): self
+    public function toBeLessThanOrEqual(int|float|string|DateTimeInterface $expected, string $message = ''): self
     {
         Assert::assertLessThanOrEqual($expected, $this->value, $message);
 
@@ -196,6 +196,24 @@ final class Expectation
         return $this;
     }
 
+    /**
+     * Asserts that $needle equal an element of the value.
+     *
+     * @return self<TValue>
+     */
+    public function toContainEqual(mixed ...$needles): self
+    {
+        if (! is_iterable($this->value)) {
+            InvalidExpectationValue::expected('iterable');
+        }
+
+        foreach ($needles as $needle) {
+            Assert::assertContainsEquals($needle, $this->value);
+        }
+
+        return $this;
+    }
+
     /**
      * Asserts that the value starts with $expected.
      *
@@ -296,7 +314,7 @@ final class Expectation
      *
      * @return self<TValue>
      */
-    public function toHaveProperty(string $name, mixed $value = new Any(), string $message = ''): self
+    public function toHaveProperty(string $name, mixed $value = new Any, string $message = ''): self
     {
         $this->toBeObject();
 
@@ -314,13 +332,13 @@ final class Expectation
     /**
      * Asserts that the value contains the provided properties $names.
      *
-     * @param  iterable<array-key, string>  $names
+     * @param  iterable<string, mixed>|iterable<int, string>  $names
      * @return self<TValue>
      */
     public function toHaveProperties(iterable $names, string $message = ''): self
     {
         foreach ($names as $name => $value) {
-            is_int($name) ? $this->toHaveProperty($value, message: $message) : $this->toHaveProperty($name, $value, $message);
+            is_int($name) ? $this->toHaveProperty($value, message: $message) : $this->toHaveProperty($name, $value, $message); // @phpstan-ignore-line
         }
 
         return $this;
@@ -449,6 +467,18 @@ final class Expectation
         return $this;
     }
 
+    /**
+     * Asserts that the value is a list.
+     *
+     * @return self<TValue>
+     */
+    public function toBeList(string $message = ''): self
+    {
+        Assert::assertIsList($this->value, $message);
+
+        return $this;
+    }
+
     /**
      * Asserts that the value is of type bool.
      *
@@ -624,7 +654,7 @@ final class Expectation
      *
      * @return self<TValue>
      */
-    public function toHaveKey(string|int $key, mixed $value = new Any(), string $message = ''): self
+    public function toHaveKey(string|int $key, mixed $value = new Any, string $message = ''): self
     {
         if (is_object($this->value) && method_exists($this->value, 'toArray')) {
             $array = $this->value->toArray();
@@ -920,7 +950,7 @@ final class Expectation
      * @param  (Closure(Throwable): mixed)|string  $exception
      * @return self<TValue>
      */
-    public function toThrow(callable|string|Throwable $exception, string $exceptionMessage = null, string $message = ''): self
+    public function toThrow(callable|string|Throwable $exception, ?string $exceptionMessage = null, string $message = ''): self
     {
         $callback = NullClosure::create();
 

src/Panic.php

@@ -42,7 +42,7 @@ final class Panic
         try {
             $output = Container::getInstance()->get(OutputInterface::class);
         } catch (Throwable) { // @phpstan-ignore-line
-            $output = new ConsoleOutput();
+            $output = new ConsoleOutput;
         }
 
         assert($output instanceof OutputInterface);

src/PendingCalls/AfterEachCall.php

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

src/PendingCalls/BeforeEachCall.php

@@ -40,12 +40,12 @@ final class BeforeEachCall
     public function __construct(
         public readonly TestSuite $testSuite,
         private readonly string $filename,
-        Closure $closure = null
+        ?Closure $closure = null
     ) {
         $this->closure = $closure instanceof Closure ? $closure : NullClosure::create();
 
-        $this->testCallProxies = new HigherOrderMessageCollection();
-        $this->testCaseProxies = new HigherOrderMessageCollection();
+        $this->testCallProxies = new HigherOrderMessageCollection;
+        $this->testCaseProxies = new HigherOrderMessageCollection;
 
         $this->describing = DescribeCall::describing();
     }

src/PendingCalls/TestCall.php

@@ -18,6 +18,7 @@ use Pest\Support\HigherOrderCallables;
 use Pest\Support\NullClosure;
 use Pest\Support\Str;
 use Pest\TestSuite;
+use PHPUnit\Framework\AssertionFailedError;
 use PHPUnit\Framework\TestCase;
 
 /**
@@ -45,8 +46,8 @@ final class TestCall
     public function __construct(
         private readonly TestSuite $testSuite,
         private readonly string $filename,
-        string $description = null,
-        Closure $closure = null
+        ?string $description = null,
+        ?Closure $closure = null
     ) {
         $this->testCaseMethod = new TestCaseMethodFactory($filename, $description, $closure);
 
@@ -57,10 +58,18 @@ final class TestCall
         $this->testSuite->beforeEach->get($this->filename)[0]($this);
     }
 
+    /**
+     * Asserts that the test fails with the given message.
+     */
+    public function fails(?string $message = null): self
+    {
+        return $this->throws(AssertionFailedError::class, $message);
+    }
+
     /**
      * Asserts that the test throws the given `$exceptionClass` when called.
      */
-    public function throws(string|int $exception, string $exceptionMessage = null, int $exceptionCode = null): self
+    public function throws(string|int $exception, ?string $exceptionMessage = null, ?int $exceptionCode = null): self
     {
         if (is_int($exception)) {
             $exceptionCode = $exception;
@@ -92,7 +101,7 @@ final class TestCall
      *
      * @param  (callable(): bool)|bool  $condition
      */
-    public function throwsIf(callable|bool $condition, string|int $exception, string $exceptionMessage = null, int $exceptionCode = null): self
+    public function throwsIf(callable|bool $condition, string|int $exception, ?string $exceptionMessage = null, ?int $exceptionCode = null): self
     {
         $condition = is_callable($condition)
             ? $condition
@@ -110,7 +119,7 @@ final class TestCall
      *
      * @param  (callable(): bool)|bool  $condition
      */
-    public function throwsUnless(callable|bool $condition, string|int $exception, string $exceptionMessage = null, int $exceptionCode = null): self
+    public function throwsUnless(callable|bool $condition, string|int $exception, ?string $exceptionMessage = null, ?int $exceptionCode = null): self
     {
         $condition = is_callable($condition)
             ? $condition
@@ -199,12 +208,37 @@ final class TestCall
         return $this;
     }
 
+    /**
+     * Skips the current test on the given PHP version.
+     */
+    public function skipOnPhp(string $version): self
+    {
+        if (mb_strlen($version) < 2) {
+            throw new InvalidArgumentException('The version must start with [<] or [>].');
+        }
+
+        if (str_starts_with($version, '>=') || str_starts_with($version, '<=')) {
+            $operator = substr($version, 0, 2);
+            $version = substr($version, 2);
+        } elseif (str_starts_with($version, '>') || str_starts_with($version, '<')) {
+            $operator = $version[0];
+            $version = substr($version, 1);
+            // ensure starts with number:
+        } elseif (is_numeric($version[0])) {
+            $operator = '==';
+        } else {
+            throw new InvalidArgumentException('The version must start with [<, >, <=, >=] or a number.');
+        }
+
+        return $this->skip(version_compare(PHP_VERSION, $version, $operator), sprintf('This test is skipped on PHP [%s%s].', $operator, $version));
+    }
+
     /**
      * Skips the current test if the given test is running on Windows.
      */
     public function skipOnWindows(): self
     {
-        return $this->skipOn('Windows', 'This test is skipped on [Windows].');
+        return $this->skipOnOs('Windows', 'This test is skipped on [Windows].');
     }
 
     /**
@@ -212,7 +246,7 @@ final class TestCall
      */
     public function skipOnMac(): self
     {
-        return $this->skipOn('Darwin', 'This test is skipped on [Mac].');
+        return $this->skipOnOs('Darwin', 'This test is skipped on [Mac].');
     }
 
     /**
@@ -220,13 +254,13 @@ final class TestCall
      */
     public function skipOnLinux(): self
     {
-        return $this->skipOn('Linux', 'This test is skipped on [Linux].');
+        return $this->skipOnOs('Linux', 'This test is skipped on [Linux].');
     }
 
     /**
      * Skips the current test if the given test is running on the given operating systems.
      */
-    private function skipOn(string $osFamily, string $message): self
+    private function skipOnOs(string $osFamily, string $message): self
     {
         return $osFamily === PHP_OS_FAMILY
             ? $this->skip($message)
@@ -335,7 +369,7 @@ final class TestCall
      */
     public function coversNothing(): self
     {
-        $this->testCaseMethod->covers = [new CoversNothing()];
+        $this->testCaseMethod->covers = [new CoversNothing];
 
         return $this;
     }
@@ -375,7 +409,7 @@ final class TestCall
      *
      * @param  array<int, mixed>|null  $arguments
      */
-    private function addChain(string $file, int $line, string $name, array $arguments = null): self
+    private function addChain(string $file, int $line, string $name, ?array $arguments = null): self
     {
         $exporter = Exporter::default();
 

src/Pest.php

@@ -6,7 +6,7 @@ namespace Pest;
 
 function version(): string
 {
-    return '2.28.0';
+    return '2.35.1';
 }
 
 function testDirectory(string $file = ''): string

src/Plugins/Actions/CallsHandleOriginalArguments.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Actions;
+
+use Pest\Contracts\Plugins;
+use Pest\Plugin\Loader;
+
+/**
+ * @internal
+ */
+final class CallsHandleOriginalArguments
+{
+    /**
+     * Executes the Plugin action.
+     *
+     * Transform the input arguments by passing it to the relevant plugins.
+     *
+     * @param  array<int, string>  $argv
+     */
+    public static function execute(array $argv): void
+    {
+        $plugins = Loader::getPlugins(Plugins\HandlesOriginalArguments::class);
+
+        /** @var Plugins\HandlesOriginalArguments $plugin */
+        foreach ($plugins as $plugin) {
+            $plugin->handleOriginalArguments($argv);
+        }
+    }
+}

src/Plugins/Actions/CallsTerminable.php

@@ -10,20 +10,20 @@ use Pest\Plugin\Loader;
 /**
  * @internal
  */
-final class CallsShutdown
+final class CallsTerminable
 {
     /**
      * Executes the Plugin action.
      *
-     * Provides an opportunity for any plugins to shutdown.
+     * Provides an opportunity for any plugins to terminate.
      */
     public static function execute(): void
     {
-        $plugins = Loader::getPlugins(Plugins\Shutdownable::class);
+        $plugins = Loader::getPlugins(Plugins\Terminable::class);
 
-        /** @var Plugins\Shutdownable $plugin */
+        /** @var Plugins\Terminable $plugin */
         foreach ($plugins as $plugin) {
-            $plugin->shutdown();
+            $plugin->terminate();
         }
     }
 }

src/Plugins/Cache.php

@@ -6,6 +6,10 @@ namespace Pest\Plugins;
 
 use Pest\Contracts\Plugins\HandlesArguments;
 use Pest\Plugins\Concerns\HandleArguments;
+use PHPUnit\TextUI\CliArguments\Builder as CliConfigurationBuilder;
+use PHPUnit\TextUI\CliArguments\XmlConfigurationFileFinder;
+use PHPUnit\TextUI\XmlConfiguration\DefaultConfiguration;
+use PHPUnit\TextUI\XmlConfiguration\Loader;
 
 /**
  * @internal
@@ -30,10 +34,21 @@ final class Cache implements HandlesArguments
      */
     public function handleArguments(array $arguments): array
     {
-        $arguments = $this->pushArgument(
-            sprintf('--cache-directory=%s', realpath(self::TEMPORARY_FOLDER)),
-            $arguments
-        );
+        if (! $this->hasArgument('--cache-directory', $arguments)) {
+
+            $cliConfiguration = (new CliConfigurationBuilder)->fromParameters([]);
+            $configurationFile = (new XmlConfigurationFileFinder)->find($cliConfiguration);
+            $xmlConfiguration = DefaultConfiguration::create();
+
+            if (is_string($configurationFile)) {
+                $xmlConfiguration = (new Loader)->load($configurationFile);
+            }
+
+            if (! $xmlConfiguration->phpunit()->hasCacheDirectory()) {
+                $arguments = $this->pushArgument('--cache-directory', $arguments);
+                $arguments = $this->pushArgument((string) realpath(self::TEMPORARY_FOLDER), $arguments);
+            }
+        }
 
         if (! $this->hasArgument('--parallel', $arguments)) {
             return $this->pushArgument('--cache-result', $arguments);

src/Plugins/Concerns/HandleArguments.php

@@ -16,7 +16,17 @@ trait HandleArguments
      */
     public function hasArgument(string $argument, array $arguments): bool
     {
-        return in_array($argument, $arguments, true);
+        foreach ($arguments as $arg) {
+            if ($arg === $argument) {
+                return true;
+            }
+
+            if (str_starts_with($arg, "$argument=")) {
+                return true;
+            }
+        }
+
+        return false;
     }
 
     /**

src/Plugins/Coverage.php

@@ -128,9 +128,9 @@ final class Coverage implements AddsOutput, HandlesArguments
 
             if ($exitCode === 1) {
                 $this->output->writeln(sprintf(
-                    "\n  <fg=white;bg=red;options=bold> FAIL </> Code coverage below expected:<fg=red;options=bold> %s %%</>. Minimum:<fg=white;options=bold> %s %%</>.",
-                    number_format($coverage, 1),
-                    number_format($this->coverageMin, 1)
+                    "\n  <fg=white;bg=red;options=bold> FAIL </> Code coverage below expected <fg=white;options=bold> %s %%</>, currently <fg=red;options=bold> %s %%</>.",
+                    number_format($this->coverageMin, 1),
+                    number_format($coverage, 1)
                 ));
             }
 

src/Plugins/Environment.php

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

src/Plugins/Help.php

@@ -61,6 +61,10 @@ final class Help implements HandlesArguments
 
                     assert(is_string($argument));
 
+                    if (trim($argument) === '--process-isolation') {
+                        continue;
+                    }
+
                     View::render('components.two-column-detail', [
                         'left' => $this->colorizeOptions($argument),
                         'right' => preg_replace(['/</', '/>/'], ['[', ']'], $description),
@@ -93,10 +97,9 @@ final class Help implements HandlesArguments
      */
     private function getContent(): array
     {
-        $helpReflection = new \ReflectionClass(PHPUnitHelp::class);
+        $helpReflection = new PHPUnitHelp;
 
-        /** @var array<string, array<int, array{arg: string, desc: string}>> $content */
-        $content = $helpReflection->getConstant('HELP_TEXT');
+        $content = (fn (): array => $this->elements())->call($helpReflection);
 
         $content['Configuration'] = [...[[
             'arg' => '--init',

src/Plugins/Only.php

@@ -4,13 +4,13 @@ declare(strict_types=1);
 
 namespace Pest\Plugins;
 
-use Pest\Contracts\Plugins\Shutdownable;
+use Pest\Contracts\Plugins\Terminable;
 use Pest\PendingCalls\TestCall;
 
 /**
  * @internal
  */
-final class Only implements Shutdownable
+final class Only implements Terminable
 {
     /**
      * The temporary folder.
@@ -26,7 +26,7 @@ final class Only implements Shutdownable
     /**
      * {@inheritDoc}
      */
-    public function shutdown(): void
+    public function terminate(): void
     {
         $lockFile = self::TEMPORARY_FOLDER.DIRECTORY_SEPARATOR.'only.lock';
 
@@ -40,6 +40,10 @@ final class Only implements Shutdownable
      */
     public static function enable(TestCall $testCall): void
     {
+        if (Environment::name() == Environment::CI) {
+            return;
+        }
+
         $testCall->group('__pest_only');
 
         $lockFile = self::TEMPORARY_FOLDER.DIRECTORY_SEPARATOR.'only.lock';

src/Plugins/Parallel.php

@@ -41,7 +41,7 @@ final class Parallel implements HandlesArguments
      */
     public static function isEnabled(): bool
     {
-        $argv = new ArgvInput();
+        $argv = new ArgvInput;
         if ($argv->hasParameterOption('--parallel')) {
             return true;
         }
@@ -126,7 +126,7 @@ final class Parallel implements HandlesArguments
             $arguments
         );
 
-        $exitCode = $this->paratestCommand()->run(new ArgvInput($filteredArguments), new CleanConsoleOutput());
+        $exitCode = $this->paratestCommand()->run(new ArgvInput($filteredArguments), new CleanConsoleOutput);
 
         return CallsAddsOutput::execute($exitCode);
     }
@@ -173,7 +173,7 @@ final class Parallel implements HandlesArguments
      */
     private function hasArgumentsThatWouldBeFasterWithoutParallel(): bool
     {
-        $arguments = new ArgvInput();
+        $arguments = new ArgvInput;
 
         foreach (self::UNSUPPORTED_ARGUMENTS as $unsupportedArgument) {
             if ($arguments->hasParameterOption($unsupportedArgument)) {

src/Plugins/Parallel/Paratest/ResultPrinter.php

@@ -63,8 +63,7 @@ final class ResultPrinter
         {
             public function __construct(
                 private readonly OutputInterface $output,
-            ) {
-            }
+            ) {}
 
             public function print(string $buffer): void
             {
@@ -79,9 +78,7 @@ final class ResultPrinter
                 $this->output->write(OutputFormatter::escape($buffer));
             }
 
-            public function flush(): void
-            {
-            }
+            public function flush(): void {}
         };
 
         $this->compactPrinter = CompactPrinter::default();
@@ -172,7 +169,7 @@ final class ResultPrinter
             return;
         }
 
-        $state = (new StateGenerator())->fromPhpUnitTestResult($this->passedTests, $testResult);
+        $state = (new StateGenerator)->fromPhpUnitTestResult($this->passedTests, $testResult);
 
         $this->compactPrinter->errors($state);
         $this->compactPrinter->recap($state, $testResult, $duration, $this->options);

src/Plugins/Parallel/Paratest/WrapperRunner.php

@@ -91,13 +91,13 @@ final class WrapperRunner implements RunnerInterface
         private readonly OutputInterface $output
     ) {
         $this->printer = new ResultPrinter($output, $options);
-        $this->timer = new Timer();
+        $this->timer = new Timer;
 
         $wrapper = realpath(
             dirname(__DIR__, 4).DIRECTORY_SEPARATOR.'bin'.DIRECTORY_SEPARATOR.'worker.php',
         );
         assert($wrapper !== false);
-        $phpFinder = new PhpExecutableFinder();
+        $phpFinder = new PhpExecutableFinder;
         $phpBin = $phpFinder->find(false);
         assert($phpBin !== false);
         $parameters = [$phpBin];
@@ -110,7 +110,7 @@ final class WrapperRunner implements RunnerInterface
         $parameters[] = $wrapper;
 
         $this->parameters = $parameters;
-        $this->codeCoverageFilterRegistry = new CodeCoverageFilterRegistry();
+        $this->codeCoverageFilterRegistry = new CodeCoverageFilterRegistry;
     }
 
     public function run(): int
@@ -357,12 +357,21 @@ final class WrapperRunner implements RunnerInterface
             return;
         }
 
-        $coverageManager = new CodeCoverage();
+        $coverageManager = new CodeCoverage;
         $coverageManager->init(
             $this->options->configuration,
             $this->codeCoverageFilterRegistry,
             false,
         );
+        if (! $coverageManager->isActive()) {
+            $this->output->writeln([
+                '',
+                '  <fg=black;bg=yellow;options=bold> WARN </> No code coverage driver is available.</>',
+                '',
+            ]);
+
+            return;
+        }
         $coverageMerger = new CoverageMerger($coverageManager->codeCoverage());
         foreach ($this->coverageFiles as $coverageFile) {
             $coverageMerger->addCoverageFromFile($coverageFile);
@@ -380,8 +389,8 @@ final class WrapperRunner implements RunnerInterface
             return;
         }
 
-        $testSuite = (new LogMerger())->merge($this->junitFiles);
-        (new Writer())->write(
+        $testSuite = (new LogMerger)->merge($this->junitFiles);
+        (new Writer)->write(
             $testSuite,
             $this->options->configuration->logfileJunit(),
         );

src/Plugins/Printer.php

@@ -22,6 +22,10 @@ final class Printer implements HandlesArguments
             return $arguments;
         }
 
+        if (in_array('--no-output', $arguments, true)) {
+            return $arguments;
+        }
+
         return $this->pushArgument('--no-output', $arguments);
     }
 }

src/Repositories/SnapshotRepository.php

@@ -21,8 +21,7 @@ final class SnapshotRepository
     public function __construct(
         readonly private string $testsPath,
         readonly private string $snapshotsPath,
-    ) {
-    }
+    ) {}
 
     /**
      * Checks if the snapshot exists.

src/Repositories/TestRepository.php

@@ -25,17 +25,17 @@ final class TestRepository
     private array $testCases = [];
 
     /**
-     * @var array<string, array{0: array<int, string>, 1: array<int, string>, 2: array<int, string|Closure>}>
+     * @var array<string, array{0: array<int, string>, 1: array<int, string>, 2: array<int, array<int, string|Closure>>}>
      */
     private array $uses = [];
 
     /**
-     * @var  array<int, TestCaseFilter>
+     * @var array<int, TestCaseFilter>
      */
     private array $testCaseFilters = [];
 
     /**
-     * @var  array<int, TestCaseMethodFilter>
+     * @var array<int, TestCaseMethodFilter>
      */
     private array $testCaseMethodFilters = [];
 
@@ -77,12 +77,17 @@ final class TestRepository
             throw new TestCaseClassOrTraitNotFound($classOrTrait);
         }
 
+        $hooks = array_map(fn (Closure $hook): array => [$hook], $hooks);
+
         foreach ($paths as $path) {
             if (array_key_exists($path, $this->uses)) {
                 $this->uses[$path] = [
                     [...$this->uses[$path][0], ...$classOrTraits],
                     [...$this->uses[$path][1], ...$groups],
-                    $this->uses[$path][2] + $hooks,
+                    array_map(
+                        fn (int $index): array => [...$this->uses[$path][2][$index] ?? [], ...($hooks[$index] ?? [])],
+                        range(0, 3),
+                    ),
                 ];
             } else {
                 $this->uses[$path] = [$classOrTraits, $groups, $hooks];
@@ -189,10 +194,11 @@ final class TestRepository
                     $method->groups = [...$groups, ...$method->groups];
                 }
 
-                $testCase->factoryProxies->add($testCase->filename, 0, '__addBeforeAll', [$hooks[0] ?? null]);
-                $testCase->factoryProxies->add($testCase->filename, 0, '__addBeforeEach', [$hooks[1] ?? null]);
-                $testCase->factoryProxies->add($testCase->filename, 0, '__addAfterEach', [$hooks[2] ?? null]);
-                $testCase->factoryProxies->add($testCase->filename, 0, '__addAfterAll', [$hooks[3] ?? null]);
+                foreach (['__addBeforeAll', '__addBeforeEach', '__addAfterEach', '__addAfterAll'] as $index => $name) {
+                    foreach ($hooks[$index] ?? [null] as $hook) {
+                        $testCase->factoryProxies->add($testCase->filename, 0, $name, [$hook]);
+                    }
+                }
             }
         }
 

src/Subscribers/EnsureTeamCityEnabled.php

@@ -4,7 +4,7 @@ declare(strict_types=1);
 
 namespace Pest\Subscribers;
 
-use Pest\Logging\TeamCity\Converter;
+use Pest\Logging\Converter;
 use Pest\Logging\TeamCity\TeamCityLogger;
 use Pest\TestSuite;
 use PHPUnit\Event\TestRunner\Configured;
@@ -24,8 +24,7 @@ final class EnsureTeamCityEnabled implements ConfiguredSubscriber
         private readonly InputInterface $input,
         private readonly OutputInterface $output,
         private readonly TestSuite $testSuite,
-    ) {
-    }
+    ) {}
 
     /**
      * Runs the subscriber.

src/Support/Backtrace.php

@@ -115,7 +115,11 @@ final class Backtrace
                 continue;
             }
 
-            if (str_contains($trace['file'], 'pest'.DIRECTORY_SEPARATOR.'src')) {
+            if (($GLOBALS['__PEST_INTERNAL_TEST_SUITE'] ?? false) && str_contains($trace['file'], 'pest'.DIRECTORY_SEPARATOR.'src')) {
+                continue;
+            }
+
+            if (str_contains($trace['file'], DIRECTORY_SEPARATOR.'pestphp'.DIRECTORY_SEPARATOR.'pest'.DIRECTORY_SEPARATOR.'src')) {
                 continue;
             }
 

src/Support/Container.php

@@ -26,7 +26,7 @@ final class Container
     public static function getInstance(): self
     {
         if (! self::$instance instanceof \Pest\Support\Container) {
-            self::$instance = new self();
+            self::$instance = new self;
         }
 
         return self::$instance;

src/Support/Coverage.php

@@ -37,7 +37,7 @@ final class Coverage
      */
     public static function isAvailable(): bool
     {
-        $runtime = new Runtime();
+        $runtime = new Runtime;
 
         if (! $runtime->canCollectCodeCoverage()) {
             return false;
@@ -67,7 +67,7 @@ final class Coverage
      */
     public static function usingXdebug(): bool
     {
-        return (new Runtime())->hasXdebug();
+        return (new Runtime)->hasXdebug();
     }
 
     /**

src/Support/ExpectationPipeline.php

@@ -30,8 +30,7 @@ final class ExpectationPipeline
      */
     public function __construct(
         private readonly Closure $closure
-    ) {
-    }
+    ) {}
 
     /**
      * Creates a new instance of Expectation Pipeline with given closure.

src/Support/Exporter.php

@@ -32,7 +32,7 @@ final class Exporter
     public static function default(): self
     {
         return new self(
-            new BaseExporter()
+            new BaseExporter
         );
     }
 
@@ -41,13 +41,13 @@ final class Exporter
      *
      * @param  array<int|string, mixed>  $data
      */
-    public function shortenedRecursiveExport(array &$data, Context $context = null): string
+    public function shortenedRecursiveExport(array &$data, ?Context $context = null): string
     {
         $result = [];
         $array = $data;
         $itemsCount = 0;
         $exporter = self::default();
-        $context ??= new Context();
+        $context ??= new Context;
 
         $context->add($data);
 
@@ -64,6 +64,8 @@ final class Exporter
                 continue;
             }
 
+            assert(is_array($data));
+
             $result[] = $context->contains($data[$key]) !== false
                 ? '*RECURSION*'
                 : sprintf('[%s]', $this->shortenedRecursiveExport($data[$key], $context));

src/Support/HigherOrderMessageCollection.php

@@ -58,7 +58,7 @@ final class HigherOrderMessageCollection
     /**
      * Count the number of messages with the given name.
      *
-     * @param  string  $name A higher order message name (usually a method name)
+     * @param  string  $name  A higher order message name (usually a method name)
      */
     public function count(string $name): int
     {

src/Support/NullClosure.php

@@ -16,7 +16,6 @@ final class NullClosure
      */
     public static function create(): Closure
     {
-        return Closure::fromCallable(function (): void {
-        });
+        return Closure::fromCallable(function (): void {});
     }
 }

src/Support/Reflection.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Pest\Support;
 
 use Closure;
+use InvalidArgumentException;
 use Pest\Exceptions\ShouldNotHappen;
 use Pest\TestSuite;
 use ReflectionClass;
@@ -66,9 +67,17 @@ final class Reflection
     {
         $test = TestSuite::getInstance()->test;
 
-        return $test instanceof \PHPUnit\Framework\TestCase
-            ? Closure::fromCallable($callable)->bindTo($test)(...$test->providedData())
-            : self::bindCallable($callable);
+        if (! $test instanceof \PHPUnit\Framework\TestCase) {
+            return self::bindCallable($callable);
+        }
+
+        foreach ($test->providedData() as $value) {
+            if ($value instanceof Closure) {
+                throw new InvalidArgumentException('Bound datasets are not supported while doing high order testing.');
+            }
+        }
+
+        return Closure::fromCallable($callable)->bindTo($test)(...$test->providedData());
     }
 
     /**

src/Support/StateGenerator.php

@@ -20,7 +20,7 @@ final class StateGenerator
 {
     public function fromPhpUnitTestResult(int $passedTests, PHPUnitTestResult $testResult): State
     {
-        $state = new State();
+        $state = new State;
 
         foreach ($testResult->testErroredEvents() as $testResultEvent) {
             if ($testResultEvent instanceof Errored) {

src/Support/Str.php

@@ -24,7 +24,7 @@ final class Str
      * Create a (unsecure & non-cryptographically safe) random alpha-numeric
      * string value.
      *
-     * @param  int  $length the length of the resulting randomized string
+     * @param  int  $length  the length of the resulting randomized string
      *
      * @see https://github.com/laravel/framework/blob/4.2/src/Illuminate/Support/Str.php#L240-L242
      */

src/TestCaseFilters/GitDirtyTestCaseFilter.php

@@ -76,7 +76,7 @@ final class GitDirtyTestCaseFilter implements TestCaseFilter
         $dirtyFiles = array_values($dirtyFiles);
 
         if ($dirtyFiles === []) {
-            Panic::with(new NoDirtyTestsFound());
+            Panic::with(new NoDirtyTestsFound);
         }
 
         $this->changedFiles = $dirtyFiles;

src/TestSuite.php

@@ -71,11 +71,11 @@ final class TestSuite
         string $rootPath,
         public string $testPath,
     ) {
-        $this->beforeAll = new BeforeAllRepository();
-        $this->beforeEach = new BeforeEachRepository();
-        $this->tests = new TestRepository();
-        $this->afterEach = new AfterEachRepository();
-        $this->afterAll = new AfterAllRepository();
+        $this->beforeAll = new BeforeAllRepository;
+        $this->beforeEach = new BeforeEachRepository;
+        $this->tests = new TestRepository;
+        $this->afterEach = new AfterEachRepository;
+        $this->afterAll = new AfterAllRepository;
         $this->rootPath = (string) realpath($rootPath);
         $this->snapshots = new SnapshotRepository(
             implode(DIRECTORY_SEPARATOR, [$this->rootPath, $this->testPath]),
@@ -87,8 +87,8 @@ final class TestSuite
      * Returns the current instance of the test suite.
      */
     public static function getInstance(
-        string $rootPath = null,
-        string $testPath = null,
+        ?string $rootPath = null,
+        ?string $testPath = null,
     ): TestSuite {
         if (is_string($rootPath) && is_string($testPath)) {
             self::$instance = new TestSuite($rootPath, $testPath);
@@ -101,7 +101,7 @@ final class TestSuite
         }
 
         if (! self::$instance instanceof self) {
-            Panic::with(new InvalidPestCommand());
+            Panic::with(new InvalidPestCommand);
         }
 
         return self::$instance;

stubs/init-laravel/TestCase.php.stub

@@ -6,5 +6,5 @@ use Illuminate\Foundation\Testing\TestCase as BaseTestCase;
 
 abstract class TestCase extends BaseTestCase
 {
-    use CreatesApplication;
+    //
 }

tests/.cache/test-results

@@ -0,0 +1 @@
+{"version":"pest_2.32.2","defects":[],"times":{"P\\Tests\\Playground::__pest_evaluable_basic":0.005}}

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

@@ -0,0 +1 @@
+<input type="hidden" name="_token" value="1" />

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

@@ -1,5 +1,5 @@
 
-  Pest Testing Framework 2.28.0.  
+  Pest Testing Framework 2.35.0.  
 
   USAGE: pest <file> [options]  
 
@@ -38,7 +38,6 @@
   EXECUTION OPTIONS:
   --parallel ........................................... Run tests in parallel  
   --update-snapshots  Update snapshots for tests using the "toMatchSnapshot" expectation  
-  --process-isolation ................ Run each test in a separate PHP process  
   --globals-backup ................. Backup and restore $GLOBALS for each test  
   --static-backup ......... Backup and restore static properties for each test  
   --strict-coverage ................... Be strict about code coverage metadata  
@@ -56,6 +55,7 @@
   --stop-on-notice ............. Stop after first test that triggered a notice  
   --stop-on-skipped ............................ Stop after first skipped test  
   --stop-on-incomplete ...................... Stop after first incomplete test  
+  --fail-on-empty-test-suite  Signal failure using shell exit code when no tests were run  
   --fail-on-warning  Signal failure using shell exit code when a warning was triggered  
   --fail-on-risky  Signal failure using shell exit code when a test was considered risky  
   --fail-on-deprecation  Signal failure using shell exit code when a deprecation was triggered  
@@ -84,6 +84,7 @@
   --reverse-list .............................. Print defects in reverse order  
   --teamcity . Replace default progress and result output with TeamCity format  
   --testdox ................ Replace default result output with TestDox format  
+  --debug  Replace default progress and result output with debugging information  
   --compact ................ Replace default result output with Compact format  
 
   LOGGING OPTIONS:

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

@@ -1,3 +1,3 @@
 
-  Pest Testing Framework 2.28.0.  
+  Pest Testing Framework 2.35.0.  
 

tests/.snapshots/success.txt

@@ -154,6 +154,10 @@
   ✓ it can correctly resolve a bound dataset that returns an array with (Closure)
   ✓ it can correctly resolve a bound dataset that returns an array but wants to be spread with (Closure)
   ↓ forbids to define tests in Datasets dirs and Datasets.php files
+  ✓ it may be used with high order with dataset "formal"
+  ✓ it may be used with high order with dataset "informal"
+  ✓ it may be used with high order even when bound with dataset "formal"
+  ✓ it may be used with high order even when bound with dataset "informal"
 
    PASS  Tests\Features\Depends
   ✓ first
@@ -426,6 +430,7 @@
    PASS  Tests\Features\Expect\toBeGreaterThan
   ✓ passes
   ✓ passes with DateTime and DateTimeImmutable
+  ✓ passes with strings
   ✓ failures
   ✓ failures with custom message
   ✓ not failures
@@ -433,6 +438,7 @@
    PASS  Tests\Features\Expect\toBeGreaterThanOrEqual
   ✓ passes
   ✓ passes with DateTime and DateTimeImmutable
+  ✓ passes with strings
   ✓ failures
   ✓ failures with custom message
   ✓ not failures
@@ -461,6 +467,10 @@
   ✓ failures with custom message
   ✓ not failures
 
+   PASS  Tests\Features\Expect\toBeIntBackedEnum
+  ✓ enum is backed by int
+  ✓ enum is not backed by int
+
    PASS  Tests\Features\Expect\toBeInvokable
   ✓ class is invokable
   ✓ opposite class is invokable
@@ -490,6 +500,7 @@
    PASS  Tests\Features\Expect\toBeLessThan
   ✓ passes
   ✓ passes with DateTime and DateTimeImmutable
+  ✓ passes with strings
   ✓ failures
   ✓ failures with custom message
   ✓ not failures
@@ -497,6 +508,13 @@
    PASS  Tests\Features\Expect\toBeLessThanOrEqual
   ✓ passes
   ✓ passes with DateTime and DateTimeImmutable
+  ✓ passes with strings
+  ✓ failures
+  ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeList
+  ✓ pass
   ✓ failures
   ✓ failures with custom message
   ✓ not failures
@@ -567,6 +585,10 @@
   ✓ failures with custom message
   ✓ not failures
 
+   PASS  Tests\Features\Expect\toBeStringBackedEnum
+  ✓ enum is backed by string
+  ✓ enum is not backed by string
+
    PASS  Tests\Features\Expect\toBeStudlyCase
   ✓ pass
   ✓ failures
@@ -637,6 +659,16 @@
   ✓ failures with multiple needles (some failing)
   ✓ not failures
   ✓ not failures with multiple needles (all failing)
+  ✓ not failures with multiple needles (some failing)
+
+   PASS  Tests\Features\Expect\toContainEqual
+  ✓ passes arrays
+  ✓ passes arrays with multiple needles
+  ✓ failures
+  ✓ failures with multiple needles (all failing)
+  ✓ failures with multiple needles (some failing)
+  ✓ not failures
+  ✓ not failures with multiple needles (all failing)
   ✓ not failures with multiple needles (some failing)
 
    PASS  Tests\Features\Expect\toContainOnlyInstancesOf
@@ -830,6 +862,7 @@
 
    PASS  Tests\Features\Expect\toMatchSnapshot
   ✓ pass
+  ✓ pass using pipes
   ✓ pass with __toString
   ✓ pass with toString
   ✓ pass with dataset with ('my-datas-set-value')
@@ -898,6 +931,14 @@
   ✓ it skips with falsy closure condition
   ✓ it can be used in higher order tests
 
+   PASS  Tests\Features\Fail
+  ✓ it may fail
+  ✓ it may fail with the given message
+
+   PASS  Tests\Features\Fails
+  ✓ it may fail
+  ✓ it may fail with the given message
+
    WARN  Tests\Features\Helpers
   ✓ it can set/get properties on $this
   ! it gets null if property do not exist → Undefined property Tests\Features\Helpers::$wqdwqdqw
@@ -1085,6 +1126,11 @@
   - it can use something in the test case as a condition → This test was skipped
   - it can user higher order callables and skip
 
+   WARN  Tests\Features\SkipOnPhp
+  ✓ it can run on php version
+  ✓ it can run on specific php version
+  - it can skip on php versions depending on constraint → This test is skipped on PHP [>=7.4.0].
+
    PASS  Tests\Features\Test
   ✓ a test
   ✓ higher order message test
@@ -1127,6 +1173,16 @@
    PASS  Tests\Hooks\BeforeEachTest
   ✓ global beforeEach execution order
 
+   PASS  Tests\Overrides\VersionsTest
+  ✓ versions with dataset "Runner/Filter/NameFilterIterator.php"
+  ✓ versions with dataset "Runner/ResultCache/DefaultResultCache.php"
+  ✓ versions with dataset "Runner/TestSuiteLoader.php"
+  ✓ versions with dataset "TextUI/Command/Commands/WarmCodeCoverageCacheCommand.php"
+  ✓ versions with dataset "TextUI/Output/Default/ProgressPrinter/Subscriber/TestSkippedSubscriber.php"
+  ✓ versions with dataset "TextUI/TestSuiteFilterProcessor.php"
+  ✓ versions with dataset "Event/Value/ThrowableBuilder.php"
+  ✓ versions with dataset "Logging/JUnit/JunitXmlLogger.php"
+
    PASS  Tests\PHPUnit\CustomAffixes\InvalidTestName
   ✓ it runs file names like @#$%^&()-_=+.php
 
@@ -1204,6 +1260,14 @@
    PASS  Tests\Unit\Overrides\ThrowableBuilder
   ✓ collision editor can be added to the stack trace
 
+   PASS  Tests\Unit\Plugins\Concerns\HandleArguments
+  ✓ method hasArgument with ('--long-argument', true)
+  ✓ method hasArgument with ('-a', true)
+  ✓ method hasArgument with ('--with-equal-sign', true)
+  ✓ method hasArgument with ('someValue', true)
+  ✓ method hasArgument with ('--a', false)
+  ✓ method hasArgument with ('--undefined-argument', false)
+
    PASS  Tests\Unit\Plugins\Environment
   ✓ environment is set to CI when --ci option is used
   ✓ environment is set to Local when --ci option is not used
@@ -1331,6 +1395,10 @@
    PASS  Tests\Visual\Help
   ✓ visual snapshot of help command output
 
+   PASS  Tests\Visual\JUnit
+  ✓ junit output
+  ✓ junit with parallel
+
    PASS  Tests\Visual\Parallel
   ✓ parallel
   ✓ a parallel test can extend another test with same name
@@ -1356,4 +1424,4 @@
    WARN  Tests\Visual\Version
   - visual snapshot of help command output
 
-  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 13 todos, 19 skipped, 966 passed (2286 assertions)
+  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 13 todos, 20 skipped, 1013 passed (2405 assertions)

tests/Features/AfterEach.php

@@ -1,6 +1,6 @@
 <?php
 
-$state = new stdClass();
+$state = new stdClass;
 
 beforeEach(function () use ($state) {
     $this->state = $state;

tests/Features/BeforeAll.php

@@ -1,6 +1,6 @@
 <?php
 
-$foo = new \stdClass();
+$foo = new \stdClass;
 $foo->bar = 0;
 
 beforeAll(function () use ($foo) {

tests/Features/Coverage.php

@@ -7,7 +7,7 @@ use Symfony\Component\Console\Output\ConsoleOutput;
 it('has plugin')->assertTrue(class_exists(CoveragePlugin::class));
 
 it('adds coverage if --coverage exist', function () {
-    $plugin = new CoveragePlugin(new ConsoleOutput());
+    $plugin = new CoveragePlugin(new ConsoleOutput);
 
     expect($plugin->coverage)->toBeFalse();
     $arguments = $plugin->handleArguments([]);
@@ -20,7 +20,7 @@ it('adds coverage if --coverage exist', function () {
 })->skip(! \Pest\Support\Coverage::isAvailable() || ! function_exists('xdebug_info') || ! in_array('coverage', xdebug_info('mode'), true), 'Coverage is not available');
 
 it('adds coverage if --min exist', function () {
-    $plugin = new CoveragePlugin(new ConsoleOutput());
+    $plugin = new CoveragePlugin(new ConsoleOutput);
     expect($plugin->coverageMin)->toEqual(0.0)
         ->and($plugin->coverage)->toBeFalse();
 
@@ -35,7 +35,7 @@ it('adds coverage if --min exist', function () {
 });
 
 it('generates coverage based on file input', function () {
-    expect(Coverage::getMissingCoverage(new class()
+    expect(Coverage::getMissingCoverage(new class
     {
         public function lineCoverageData(): array
         {

tests/Features/Covers.php

@@ -10,9 +10,7 @@ use Tests\Fixtures\Covers\CoversTrait;
 
 $runCounter = 0;
 
-function testCoversFunction()
-{
-}
+function testCoversFunction() {}
 
 it('uses the correct PHPUnit attribute for class', function () {
     $attributes = (new ReflectionClass($this))->getAttributes();

tests/Features/DatasetsTests.php

@@ -46,7 +46,7 @@ test('it truncates the description', function () {
     // it gets tested by the integration test
 })->with([str_repeat('Fooo', 10)]);
 
-$state = new stdClass();
+$state = new stdClass;
 $state->text = '';
 
 $datasets = [[1], [2]];
@@ -119,7 +119,7 @@ class Bar
 }
 
 $namedDatasets = [
-    new Bar(),
+    new Bar,
 ];
 
 test('lazy named datasets', function ($text) {
@@ -132,12 +132,12 @@ it('creates unique test case names', function (string $name, Plugin $plugin, boo
     expect(true)->toBeTrue();
     $counter++;
 })->with([
-    ['Name 1', new Plugin(), true],
-    ['Name 1', new Plugin(), true],
-    ['Name 1', new Plugin(), false],
-    ['Name 2', new Plugin(), false],
-    ['Name 2', new Plugin(), true],
-    ['Name 1', new Plugin(), true],
+    ['Name 1', new Plugin, true],
+    ['Name 1', new Plugin, true],
+    ['Name 1', new Plugin, false],
+    ['Name 2', new Plugin, false],
+    ['Name 2', new Plugin, true],
+    ['Name 1', new Plugin, true],
 ]);
 
 it('creates unique test case names - count', function () use (&$counter) {
@@ -230,7 +230,7 @@ test('more than two datasets did the job right', function () use ($state) {
     expect($state->text)->toBe('121212121212131423241314232411122122111221221112212213142324135136145146235236245246');
 });
 
-$wrapped_generator_state = new stdClass();
+$wrapped_generator_state = new stdClass;
 $wrapped_generator_state->text = '';
 $wrapped_generator_function_datasets = [1, 2, 3, 4];
 
@@ -361,3 +361,23 @@ it('can correctly resolve a bound dataset that returns an array but wants to be
 ]);
 
 todo('forbids to define tests in Datasets dirs and Datasets.php files');
+
+dataset('greeting-string', [
+    'formal' => 'Evening',
+    'informal' => 'yo',
+]);
+
+it('may be used with high order')
+    ->with('greeting-string')
+    ->expect(fn (string $greeting) => $greeting)
+    ->throwsNoExceptions();
+
+dataset('greeting-bound', [
+    'formal' => fn () => 'Evening',
+    'informal' => fn () => 'yo',
+]);
+
+it('may be used with high order even when bound')
+    ->with('greeting-bound')
+    ->expect(fn (string $greeting) => $greeting)
+    ->throws(InvalidArgumentException::class);

tests/Features/Exceptions.php

@@ -3,7 +3,7 @@
 it('gives access the the underlying expectException', function () {
     $this->expectException(InvalidArgumentException::class);
 
-    throw new InvalidArgumentException();
+    throw new InvalidArgumentException;
 });
 
 it('catch exceptions', function () {

tests/Features/Expect/HigherOrder/methods.php

@@ -1,29 +1,29 @@
 <?php
 
 it('can access methods', function () {
-    expect(new HasMethods())
+    expect(new HasMethods)
         ->name()->toBeString()->toEqual('Has Methods');
 });
 
 it('can access multiple methods', function () {
-    expect(new HasMethods())
+    expect(new HasMethods)
         ->name()->toBeString()->toEqual('Has Methods')
         ->quantity()->toBeInt()->toEqual(20);
 });
 
 it('works with not', function () {
-    expect(new HasMethods())
+    expect(new HasMethods)
         ->name()->not->toEqual('world')->toEqual('Has Methods')
         ->quantity()->toEqual(20)->not()->toEqual('bar')->not->toBeNull;
 });
 
 it('can accept arguments', function () {
-    expect(new HasMethods())
+    expect(new HasMethods)
         ->multiply(5, 4)->toBeInt->toEqual(20);
 });
 
 it('works with each', function () {
-    expect(new HasMethods())
+    expect(new HasMethods)
         ->attributes()->toBeArray->each->not()->toBeNull
         ->attributes()->each(function ($attribute) {
             $attribute->not->toBeNull();
@@ -31,14 +31,14 @@ it('works with each', function () {
 });
 
 it('works inside of each', function () {
-    expect(new HasMethods())
+    expect(new HasMethods)
         ->books()->each(function ($book) {
             $book->title->not->toBeNull->cost->toBeGreaterThan(19);
         });
 });
 
 it('works with sequence', function () {
-    expect(new HasMethods())
+    expect(new HasMethods)
         ->books()->sequence(
             function ($book) {
                 $book->title->toEqual('Foo')->cost->toEqual(20);
@@ -50,7 +50,7 @@ it('works with sequence', function () {
 });
 
 it('can compose complex expectations', function () {
-    expect(new HasMethods())
+    expect(new HasMethods)
         ->toBeObject()
         ->name()->toEqual('Has Methods')->not()->toEqual('bar')
         ->quantity()->not->toEqual('world')->toEqual(20)->toBeInt
@@ -68,7 +68,7 @@ it('can compose complex expectations', function () {
 });
 
 it('can handle nested method calls', function () {
-    expect(new HasMethods())
+    expect(new HasMethods)
         ->newInstance()->newInstance()->name()->toEqual('Has Methods')->toBeString()
         ->newInstance()->name()->toEqual('Has Methods')->not->toBeInt
         ->name()->toEqual('Has Methods')
@@ -76,14 +76,14 @@ it('can handle nested method calls', function () {
 });
 
 it('works with higher order tests')
-    ->expect(new HasMethods())
+    ->expect(new HasMethods)
     ->newInstance()->newInstance()->name()->toEqual('Has Methods')->toBeString()
     ->newInstance()->name()->toEqual('Has Methods')->not->toBeArray
     ->name()->toEqual('Has Methods')
     ->books()->each->toBeArray;
 
 it('can use the scoped method to lock into the given level for expectations', function () {
-    expect(new HasMethods())
+    expect(new HasMethods)
         ->attributes()->scoped(fn ($attributes) => $attributes
         ->name->toBe('Has Methods')
         ->quantity->toBe(20)
@@ -100,7 +100,7 @@ it('can use the scoped method to lock into the given level for expectations', fu
 });
 
 it('works consistently with the json expectation method', function () {
-    expect(new HasMethods())
+    expect(new HasMethods)
         ->jsonString()->json()->id->toBe(1)
         ->jsonString()->json()->name->toBe('Has Methods')->toBeString()
         ->jsonString()->json()->quantity->toBe(20)->toBeInt();
@@ -152,6 +152,6 @@ class HasMethods
 
     public function newInstance()
     {
-        return new static();
+        return new static;
     }
 }

tests/Features/Expect/HigherOrder/methodsAndProperties.php

@@ -1,7 +1,7 @@
 <?php
 
 it('can access methods and properties', function () {
-    expect(new HasMethodsAndProperties())
+    expect(new HasMethodsAndProperties)
         ->name->toEqual('Has Methods and Properties')->not()->toEqual('bar')
         ->multiply(3, 4)->not->toBeString->toEqual(12)
         ->posts->each(function ($post) {
@@ -19,7 +19,7 @@ it('can access methods and properties', function () {
 });
 
 it('can handle nested methods and properties', function () {
-    expect(new HasMethodsAndProperties())
+    expect(new HasMethodsAndProperties)
         ->meta->foo->bar->toBeString()->toEqual('baz')->not->toBeInt
         ->newInstance()->meta->foo->toBeArray()
         ->newInstance()->multiply(2, 2)->toEqual(4)->not->toEqual(5)
@@ -27,14 +27,14 @@ it('can handle nested methods and properties', function () {
 });
 
 it('works with higher order tests')
-    ->expect(new HasMethodsAndProperties())
+    ->expect(new HasMethodsAndProperties)
     ->meta->foo->bar->toBeString()->toEqual('baz')->not->toBeInt
     ->newInstance()->meta->foo->toBeArray
     ->newInstance()->multiply(2, 2)->toEqual(4)->not->toEqual(5)
     ->newInstance()->books()->toBeArray();
 
 it('can start a new higher order expectation using the and syntax', function () {
-    expect(new HasMethodsAndProperties())
+    expect(new HasMethodsAndProperties)
         ->toBeInstanceOf(HasMethodsAndProperties::class)
         ->meta->toBeArray
         ->and(['foo' => 'bar'])
@@ -45,7 +45,7 @@ it('can start a new higher order expectation using the and syntax', function ()
 });
 
 it('can start a new higher order expectation using the and syntax in higher order tests')
-    ->expect(new HasMethodsAndProperties())
+    ->expect(new HasMethodsAndProperties)
     ->toBeInstanceOf(HasMethodsAndProperties::class)
     ->meta->toBeArray
     ->and(['foo' => 'bar'])
@@ -53,7 +53,7 @@ it('can start a new higher order expectation using the and syntax in higher orde
     ->foo->toEqual('bar');
 
 it('can start a new higher order expectation using the and syntax without nesting expectations', function () {
-    expect(new HasMethodsAndProperties())
+    expect(new HasMethodsAndProperties)
         ->toBeInstanceOf(HasMethodsAndProperties::class)
         ->meta
         ->sequence(
@@ -101,6 +101,6 @@ class HasMethodsAndProperties
 
     public function newInstance()
     {
-        return new static();
+        return new static;
     }
 }

tests/Features/Expect/HigherOrder/properties.php

@@ -53,7 +53,7 @@ it('can compose complex expectations', function () {
 });
 
 it('works with objects', function () {
-    expect(new HasProperties())
+    expect(new HasProperties)
         ->name->toEqual('foo')->not->toEqual('world')
         ->posts->toHaveCount(2)->each(function ($post) {
             $post->is_published->toBeTrue();
@@ -69,13 +69,13 @@ it('works with objects', function () {
 });
 
 it('works with nested properties', function () {
-    expect(new HasProperties())
+    expect(new HasProperties)
         ->nested->foo->bar->toBeString()->toEqual('baz')
         ->posts->toBeArray()->toHaveCount(2);
 });
 
 it('works with higher order tests')
-    ->expect(new HasProperties())
+    ->expect(new HasProperties)
     ->nested->foo->bar->toBeString()->toEqual('baz')
     ->posts->toBeArray()->toHaveCount(2);
 

tests/Features/Expect/pipes.php

@@ -56,7 +56,7 @@ class State
     }
 }
 
-$state = new State();
+$state = new State;
 
 /*
  * Overrides toBe to assert two Characters are the same

tests/Features/Expect/toBe.php

@@ -5,8 +5,8 @@ use PHPUnit\Framework\ExpectationFailedException;
 expect(true)->toBeTrue()->and(false)->toBeFalse();
 
 test('strict comparisons', function () {
-    $nuno = new stdClass();
-    $dries = new stdClass();
+    $nuno = new stdClass;
+    $dries = new stdClass;
 
     expect($nuno)->toBe($nuno)->not->toBe($dries);
 });

tests/Features/Expect/toBeCallable.php

@@ -3,8 +3,7 @@
 use PHPUnit\Framework\ExpectationFailedException;
 
 test('pass', function () {
-    expect(function () {
-    })->toBeCallable();
+    expect(function () {})->toBeCallable();
     expect(null)->not->toBeCallable();
 });
 

tests/Features/Expect/toBeGreaterThan.php

@@ -8,14 +8,19 @@ test('passes', function () {
 });
 
 test('passes with DateTime and DateTimeImmutable', function () {
-    $now = new DateTime();
-    $past = (new DateTimeImmutable())->modify('-1 day');
+    $now = new DateTime;
+    $past = (new DateTimeImmutable)->modify('-1 day');
 
     expect($now)->toBeGreaterThan($past);
 
     expect($past)->not->toBeGreaterThan($now);
 });
 
+test('passes with strings', function () {
+    expect('b')->toBeGreaterThan('a');
+    expect('a')->not->toBeGreaterThan('a');
+});
+
 test('failures', function () {
     expect(4)->toBeGreaterThan(4);
 })->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeGreaterThanOrEqual.php

@@ -8,8 +8,8 @@ test('passes', function () {
 });
 
 test('passes with DateTime and DateTimeImmutable', function () {
-    $now = new DateTime();
-    $past = (new DateTimeImmutable())->modify('-1 day');
+    $now = new DateTime;
+    $past = (new DateTimeImmutable)->modify('-1 day');
 
     expect($now)->toBeGreaterThanOrEqual($now);
 
@@ -18,6 +18,11 @@ test('passes with DateTime and DateTimeImmutable', function () {
     expect($past)->not->toBeGreaterThanOrEqual($now);
 });
 
+test('passes with strings', function () {
+    expect('b')->toBeGreaterThanOrEqual('a');
+    expect('a')->toBeGreaterThanOrEqual('a');
+});
+
 test('failures', function () {
     expect(4)->toBeGreaterThanOrEqual(4.1);
 })->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeInstanceOf.php

@@ -3,18 +3,18 @@
 use PHPUnit\Framework\ExpectationFailedException;
 
 test('pass', function () {
-    expect(new Exception())->toBeInstanceOf(Exception::class);
-    expect(new Exception())->not->toBeInstanceOf(RuntimeException::class);
+    expect(new Exception)->toBeInstanceOf(Exception::class);
+    expect(new Exception)->not->toBeInstanceOf(RuntimeException::class);
 });
 
 test('failures', function () {
-    expect(new Exception())->toBeInstanceOf(RuntimeException::class);
+    expect(new Exception)->toBeInstanceOf(RuntimeException::class);
 })->throws(ExpectationFailedException::class);
 
 test('failures with custom message', function () {
-    expect(new Exception())->toBeInstanceOf(RuntimeException::class, 'oh no!');
+    expect(new Exception)->toBeInstanceOf(RuntimeException::class, 'oh no!');
 })->throws(ExpectationFailedException::class, 'oh no!');
 
 test('not failures', function () {
-    expect(new Exception())->not->toBeInstanceOf(Exception::class);
+    expect(new Exception)->not->toBeInstanceOf(Exception::class);
 })->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeIntBackedEnum.php

@@ -0,0 +1,9 @@
+<?php
+
+test('enum is backed by int')
+    ->expect('Tests\Fixtures\Arch\ToBeIntBackedEnum\HasIntBacking')
+    ->toBeIntBackedEnum();
+
+test('enum is not backed by int')
+    ->expect('Tests\Fixtures\Arch\ToBeIntBackedEnum\HasStringBacking')
+    ->not->toBeIntBackedEnum();

tests/Features/Expect/toBeLessThan.php

@@ -8,14 +8,19 @@ test('passes', function () {
 });
 
 test('passes with DateTime and DateTimeImmutable', function () {
-    $now = new DateTime();
-    $past = (new DateTimeImmutable())->modify('-1 day');
+    $now = new DateTime;
+    $past = (new DateTimeImmutable)->modify('-1 day');
 
     expect($past)->toBeLessThan($now);
 
     expect($now)->not->toBeLessThan($now);
 });
 
+test('passes with strings', function () {
+    expect('a')->toBeLessThan('b');
+    expect('a')->not->toBeLessThan('a');
+});
+
 test('failures', function () {
     expect(4)->toBeLessThan(4);
 })->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeLessThanOrEqual.php

@@ -8,8 +8,8 @@ test('passes', function () {
 });
 
 test('passes with DateTime and DateTimeImmutable', function () {
-    $now = new DateTime();
-    $past = (new DateTimeImmutable())->modify('-1 day');
+    $now = new DateTime;
+    $past = (new DateTimeImmutable)->modify('-1 day');
 
     expect($now)->toBeLessThanOrEqual($now);
 
@@ -18,6 +18,11 @@ test('passes with DateTime and DateTimeImmutable', function () {
     expect($now)->not->toBeLessThanOrEqual($past);
 });
 
+test('passes with strings', function () {
+    expect('a')->toBeLessThanOrEqual('b');
+    expect('a')->toBeLessThanOrEqual('a');
+});
+
 test('failures', function () {
     expect(4)->toBeLessThanOrEqual(3.9);
 })->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeList.php

@@ -0,0 +1,21 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect([1, 2, 3])->toBeList();
+    expect(['a' => 1, 'b' => 2, 'c' => 3])->not->toBeList();
+    expect('1, 2, 3')->not->toBeList();
+});
+
+test('failures', function () {
+    expect(null)->toBeList();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect(null)->toBeList('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect(['a', 'b', 'c'])->not->toBeList();
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toBeStringBackedEnum.php

@@ -0,0 +1,9 @@
+<?php
+
+test('enum is backed by string')
+    ->expect('Tests\Fixtures\Arch\ToBeStringBackedEnum\HasStringBacking')
+    ->toBeStringBackedEnum();
+
+test('enum is not backed by string')
+    ->expect('Tests\Fixtures\Arch\ToBeStringBackedEnum\HasIntBacking')
+    ->not->toBeStringBackedEnum();

tests/Features/Expect/toContainEqual.php

@@ -0,0 +1,35 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('passes arrays', function () {
+    expect([1, 2, 42])->toContainEqual('42');
+});
+
+test('passes arrays with multiple needles', function () {
+    expect([1, 2, 42])->toContainEqual('42', '2');
+});
+
+test('failures', function () {
+    expect([1, 2, 42])->toContainEqual('3');
+})->throws(ExpectationFailedException::class);
+
+test('failures with multiple needles (all failing)', function () {
+    expect([1, 2, 42])->toContainEqual('3', '4');
+})->throws(ExpectationFailedException::class);
+
+test('failures with multiple needles (some failing)', function () {
+    expect([1, 2, 42])->toContainEqual('1', '3', '4');
+})->throws(ExpectationFailedException::class);
+
+test('not failures', function () {
+    expect([1, 2, 42])->not->toContainEqual('42');
+})->throws(ExpectationFailedException::class);
+
+test('not failures with multiple needles (all failing)', function () {
+    expect([1, 2, 42])->not->toContainEqual('42', '2');
+})->throws(ExpectationFailedException::class);
+
+test('not failures with multiple needles (some failing)', function () {
+    expect([1, 2, 42])->not->toContainEqual('42', '1');
+})->throws(ExpectationFailedException::class);

tests/Features/Expect/toContainOnlyInstancesOf.php

@@ -3,7 +3,7 @@
 use PHPUnit\Framework\ExpectationFailedException;
 
 beforeEach(function () {
-    $this->times = [new DateTimeImmutable(), new DateTimeImmutable()];
+    $this->times = [new DateTimeImmutable, new DateTimeImmutable];
 });
 
 test('pass', function () {

tests/Features/Expect/toHaveMethods.php

@@ -4,13 +4,9 @@ use PHPUnit\Framework\ExpectationFailedException;
 
 $object = new class
 {
-    public function foo(): void
-    {
-    }
+    public function foo(): void {}
 
-    public function bar(): void
-    {
-    }
+    public function bar(): void {}
 };
 
 test('pass', function () use ($object) {

tests/Features/Expect/toHaveProperties.php

@@ -3,7 +3,7 @@
 use PHPUnit\Framework\ExpectationFailedException;
 
 test('pass', function () {
-    $object = new stdClass();
+    $object = new stdClass;
     $object->name = 'John';
     $object->age = 21;
 
@@ -16,7 +16,7 @@ test('pass', function () {
 });
 
 test('failures', function () {
-    $object = new stdClass();
+    $object = new stdClass;
     $object->name = 'John';
 
     expect($object)
@@ -28,7 +28,7 @@ test('failures', function () {
 })->throws(ExpectationFailedException::class);
 
 test('failures with custom message', function () {
-    $object = new stdClass();
+    $object = new stdClass;
     $object->name = 'John';
 
     expect($object)
@@ -40,7 +40,7 @@ test('failures with custom message', function () {
 })->throws(ExpectationFailedException::class, 'oh no!');
 
 test('not failures', function () {
-    $object = new stdClass();
+    $object = new stdClass;
     $object->name = 'John';
     $object->age = 21;