chore: fixes constrains no workflow

[2.x] Junit support

.github/workflows/integration-tests.yml

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

.github/workflows/static.yml

@@ -13,6 +13,7 @@ jobs:
 
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: true
       matrix:
         dependency-version: [prefer-lowest, prefer-stable]
 

.github/workflows/tests.yml

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

README.md

@@ -22,17 +22,17 @@ We cannot thank our sponsors enough for their incredible support in funding Pest
 ### Platinum Sponsors
 
 - **[Forge](https://forge.laravel.com)**
-- **[LoadForge](https://loadforge.com)**
 - **[Spatie](https://spatie.be)**
 - **[Worksome](https://www.worksome.com/)**
 
 ### Premium Sponsors
 
-- [Akaunting](https://akaunting.com)
-- [Codecourse](https://codecourse.com/)
-- [Laracasts](https://laracasts.com/)
-- [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)
+- [Laracasts](https://laracasts.com/?ref=pestphp)
+- [Laradir](https://laradir.com/?ref=pestphp)
+- [Localazy](https://localazy.com/?ref=pestphp)
+- [Stormlikes](https://www.stormlikes.net/?ref=pestphp)
+- [Zapiet](https://www.zapiet.com/?ref=pestphp)
 
 Pest is an open-sourced software licensed under the **[MIT license](https://opensource.org/licenses/MIT)**.

bin/pest

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

composer.json

@@ -19,14 +19,14 @@
     "require": {
         "php": "^8.1.0",
         "brianium/paratest": "^7.3.1",
-        "nunomaduro/collision": "^7.10.0|^8.0.0",
+        "nunomaduro/collision": "^7.10.0|^8.1.0",
         "nunomaduro/termwind": "^1.15.1|^2.0.0",
         "pestphp/pest-plugin": "^2.1.1",
-        "pestphp/pest-plugin-arch": "^2.4.1",
-        "phpunit/phpunit": "^10.4.2"
+        "pestphp/pest-plugin-arch": "^2.6.1",
+        "phpunit/phpunit": "^10.5.7"
     },
     "conflict": {
-        "phpunit/phpunit": ">10.4.2",
+        "phpunit/phpunit": ">10.5.7",
         "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.3.4"
+        "pestphp/pest-plugin-type-coverage": "^2.8.0",
+        "symfony/process": "^6.4.0|^7.0.2"
     },
     "minimum-stability": "dev",
     "prefer-stable": true,
@@ -107,7 +107,8 @@
                 "Pest\\Plugins\\Snapshot",
                 "Pest\\Plugins\\Verbose",
                 "Pest\\Plugins\\Version",
-                "Pest\\Plugins\\Parallel"
+                "Pest\\Plugins\\Parallel",
+                "Pest\\Plugins\\JUnit"
             ]
         },
         "phpstan": {

docker/Dockerfile

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

overrides/Logging/JUnit/JunitXmlLogger.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PHPUnit\Logging\JUnit;
+
+use PHPUnit\Event\Facade;
+use PHPUnit\TextUI\Output\Printer;
+
+final class JunitXmlLogger
+{
+    public function __construct(Printer $printer, Facade $facade)
+    {
+        /** @see \Pest\Logging\JUnit\JUnitLogger */
+    }
+}

overrides/Runner/ResultCache/DefaultResultCache.php

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

src/Bootstrappers/BootOverrides.php

@@ -25,6 +25,7 @@ final class BootOverrides implements Bootstrapper
         'TextUI/Output/Default/ProgressPrinter/TestSkippedSubscriber.php',
         'TextUI/TestSuiteFilterProcessor.php',
         'Event/Value/ThrowableBuilder.php',
+        'Logging/JUnit/JunitXmlLogger.php',
     ];
 
     /**

src/Bootstrappers/BootSubscribers.php

@@ -25,6 +25,7 @@ final class BootSubscribers implements Bootstrapper
         Subscribers\EnsureIgnorableTestCasesAreIgnored::class,
         Subscribers\EnsureKernelDumpIsFlushed::class,
         Subscribers\EnsureTeamCityEnabled::class,
+        Subscribers\EnsureJunitEnabled::class,
     ];
 
     /**

src/Expectation.php

@@ -34,8 +34,6 @@ use PHPUnit\Architecture\Elements\ObjectDescription;
 use PHPUnit\Framework\ExpectationFailedException;
 
 /**
- * @internal
- *
  * @template TValue
  *
  * @property OppositeExpectation $not Creates the opposite expectation.
@@ -192,7 +190,7 @@ final class Expectation
      *
      * @return EachExpectation<TValue>
      */
-    public function each(callable $callback = null): EachExpectation
+    public function each(?callable $callback = null): EachExpectation
     {
         if (! is_iterable($this->value)) {
             throw new BadMethodCallException('Expectation value is not iterable.');
@@ -537,7 +535,7 @@ final class Expectation
     }
 
     /**
-     * Asserts that the given expectation targets is an class.
+     * Asserts that the given expectation target is a class.
      */
     public function toBeClass(): ArchExpectation
     {

src/Functions.php

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

src/Logging/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;
@@ -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/JUnit/JUnitLogger.php

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

src/Logging/JUnit/Subscriber/Subscriber.php

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

src/Logging/JUnit/Subscriber/TestErroredSubscriber.php

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

src/Logging/JUnit/Subscriber/TestFailedSubscriber.php

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

src/Logging/JUnit/Subscriber/TestFinishedSubscriber.php

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

src/Logging/JUnit/Subscriber/TestMarkedIncompleteSubscriber.php

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

src/Logging/JUnit/Subscriber/TestPreparedSubscriber.php

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

src/Logging/JUnit/Subscriber/TestRunnerExecutionFinishedSubscriber.php

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

src/Logging/JUnit/Subscriber/TestSkippedSubscriber.php

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

src/Logging/JUnit/Subscriber/TestSuiteFinishedSubscriber.php

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

src/Logging/JUnit/Subscriber/TestSuiteStartedSubscriber.php

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

src/Logging/TeamCity/ServiceMessage.php

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

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

@@ -314,13 +314,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;
@@ -844,6 +844,7 @@ final class Expectation
 
         $string = match (true) {
             is_string($this->value) => $this->value,
+            is_object($this->value) && method_exists($this->value, 'toSnapshot') => $this->value->toSnapshot(),
             is_object($this->value) && method_exists($this->value, '__toString') => $this->value->__toString(),
             is_object($this->value) && method_exists($this->value, 'toString') => $this->value->toString(),
             $this->value instanceof \Illuminate\Testing\TestResponse => $this->value->getContent(), // @phpstan-ignore-line
@@ -919,7 +920,7 @@ final class Expectation
      * @param  (Closure(Throwable): mixed)|string  $exception
      * @return self<TValue>
      */
-    public function toThrow(callable|string|Throwable $exception, string $exceptionMessage = null, string $message = ''): self
+    public function toThrow(callable|string|Throwable $exception, ?string $exceptionMessage = null, string $message = ''): self
     {
         $callback = NullClosure::create();
 

src/PendingCalls/AfterEachCall.php

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

src/PendingCalls/BeforeEachCall.php

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

src/PendingCalls/TestCall.php

@@ -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)
@@ -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.25.0';
+    return '2.32.0';
 }
 
 function testDirectory(string $file = ''): string

src/Plugins/Cache.php

@@ -30,10 +30,11 @@ 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)) {
+            $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/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/JUnit.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins;
+
+use Pest\Contracts\Plugins\HandlesArguments;
+use Pest\Plugins\Concerns\HandleArguments;
+
+/**
+ * @internal
+ */
+final class JUnit implements HandlesArguments
+{
+    use HandleArguments;
+
+    /**
+     * Handles the arguments, adding the cache directory and the cache result arguments.
+     */
+    public function handleArguments(array $arguments): array
+    {
+        if (! $this->hasArgument('--log-junit', $arguments)) {
+            return $arguments;
+        }
+
+        $logUnitArgument = null;
+
+        $arguments = array_filter($arguments, function (string $argument) use (&$logUnitArgument): bool {
+            if (str_starts_with($argument, '--log-junit')) {
+                $logUnitArgument = $argument;
+
+                return false;
+            }
+
+            return true;
+        });
+
+        assert(is_string($logUnitArgument));
+
+        $arguments[] = $logUnitArgument;
+
+        return array_values($arguments);
+    }
+}

src/Plugins/Parallel.php

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

src/Repositories/TestRepository.php

@@ -30,12 +30,12 @@ final class TestRepository
     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 = [];
 

src/Subscribers/EnsureJunitEnabled.php

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Logging\Converter;
+use Pest\Logging\JUnit\JUnitLogger;
+use Pest\Support\Container;
+use Pest\TestSuite;
+use PHPUnit\Event\TestRunner\Configured;
+use PHPUnit\Event\TestRunner\ConfiguredSubscriber;
+use PHPUnit\TextUI\Configuration\Configuration;
+use PHPUnit\TextUI\Output\DefaultPrinter;
+use Symfony\Component\Console\Input\InputInterface;
+
+/**
+ * @internal
+ */
+final class EnsureJunitEnabled implements ConfiguredSubscriber
+{
+    /**
+     * Creates a new Configured Subscriber instance.
+     */
+    public function __construct(
+        private readonly InputInterface $input,
+        private readonly TestSuite $testSuite,
+    ) {
+    }
+
+    /**
+     * Runs the subscriber.
+     */
+    public function notify(Configured $event): void
+    {
+        if (! $this->input->hasParameterOption('--log-junit')) {
+            return;
+        }
+
+        $configuration = Container::getInstance()->get(Configuration::class);
+        assert($configuration instanceof Configuration);
+
+        new JUnitLogger(
+            DefaultPrinter::from($configuration->logfileJunit()),
+            new Converter($this->testSuite->rootPath),
+        );
+    }
+}

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;

src/Support/Exporter.php

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

src/Support/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/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/TestSuite.php

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

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

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

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

@@ -1,5 +1,5 @@
 
-  Pest Testing Framework 2.25.0.  
+  Pest Testing Framework 2.32.0.  
 
   USAGE: pest <file> [options]  
 
@@ -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.25.0.  
+  Pest Testing Framework 2.32.0.  
 

tests/.snapshots/success.txt

@@ -836,6 +836,7 @@
   ✓ within describe → pass with dataset with ('my-datas-set-value')
   ✓ pass with toArray
   ✓ pass with array
+  ✓ pass with toSnapshot
   ✓ failures
   ✓ failures with custom message
   ✓ not failures
@@ -897,6 +898,14 @@
   ✓ it skips with falsy closure condition
   ✓ it can be used in higher order tests
 
+   PASS  Tests\Features\Fail
+  ✓ it may fail
+  ✓ it may fail with the given message
+
+   PASS  Tests\Features\Fails
+  ✓ it may fail
+  ✓ it may fail with the given message
+
    WARN  Tests\Features\Helpers
   ✓ it can set/get properties on $this
   ! it gets null if property do not exist → Undefined property Tests\Features\Helpers::$wqdwqdqw
@@ -1084,6 +1093,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
@@ -1203,6 +1217,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
@@ -1347,10 +1369,12 @@
   - visual snapshot of team city with ('SuccessOnly.php')
 
    PASS  Tests\Visual\Todo
+  ✓ todos
+  ✓ todos in parallel
   ✓ todo
   ✓ todo in parallel
 
    WARN  Tests\Visual\Version
   - visual snapshot of help command output
 
-  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 13 todos, 19 skipped, 963 passed (2281 assertions)
+  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 13 todos, 20 skipped, 978 passed (2304 assertions)

tests/.snapshots/todos.txt

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

tests/Arch.php

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

tests/Features/Expect/toMatchSnapshot.php

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

tests/Features/Fail.php

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

tests/Features/Fails.php

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

tests/Features/SkipOnPhp.php

@@ -0,0 +1,13 @@
+<?php
+
+it('can run on php version')
+    ->skipOnPhp('<=7.4.0')
+    ->assertTrue(true);
+
+it('can run on specific php version')
+    ->skipOnPhp('7.4.0')
+    ->assertTrue(true);
+
+it('can skip on php versions depending on constraint')
+    ->skipOnPhp('>=7.4.0')
+    ->assertTrue(false);

tests/Unit/Plugins/Concerns/HandleArguments.php

@@ -0,0 +1,26 @@
+<?php
+
+use Pest\Plugins\Concerns\HandleArguments;
+
+test('method hasArgument', function (string $argument, bool $expectedResult) {
+    $obj = new class
+    {
+        use HandleArguments;
+    };
+
+    $arguments = [
+        '--long-argument',
+        'someValue',
+        '-a',
+        '--with-equal-sign=1337',
+    ];
+
+    expect($obj->hasArgument($argument, $arguments))->toBe($expectedResult);
+})->with([
+    ['--long-argument', true],
+    ['-a', true],
+    ['--with-equal-sign', true],
+    ['someValue', true],
+    ['--a', false],
+    ['--undefined-argument', false],
+]);

tests/Visual/Parallel.php

@@ -16,7 +16,7 @@ $run = function () {
 
 test('parallel', function () use ($run) {
     expect($run('--exclude-group=integration'))
-        ->toContain('Tests:    1 deprecated, 4 warnings, 5 incomplete, 2 notices, 13 todos, 15 skipped, 952 passed (2266 assertions)')
+        ->toContain('Tests:    1 deprecated, 4 warnings, 5 incomplete, 2 notices, 13 todos, 16 skipped, 965 passed (2285 assertions)')
         ->toContain('Parallel: 3 processes');
 })->skipOnWindows();
 

tests/Visual/Todo.php

@@ -26,10 +26,18 @@ $snapshot = function ($name) {
     ]));
 };
 
+test('todos', function () use ($run, $snapshot) {
+    expect($run('--todos', false))->toContain($snapshot('todos'));
+})->skipOnWindows();
+
+test('todos in parallel', function () use ($run, $snapshot) {
+    expect($run('--todos', true))->toContain($snapshot('todos'));
+})->skipOnWindows();
+
 test('todo', function () use ($run, $snapshot) {
-    expect($run('--todos', false))->toContain($snapshot('todo'));
+    expect($run('--todo', false))->toContain($snapshot('todo'));
 })->skipOnWindows();
 
 test('todo in parallel', function () use ($run, $snapshot) {
-    expect($run('--todos', true))->toContain($snapshot('todo'));
+    expect($run('--todo', true))->toContain($snapshot('todo'));
 })->skipOnWindows();