release: v2.18.2

chore: adds phpunit 10.3.4 support
Merge pull request #957 from adevade/patch-1
2026-03-06 07:47:22 +01:00 · 2023-09-13 23:14:31 +01:00 · 2023-09-13 23:14:22 +01:00 · 2023-09-12 16:15:39 +01:00 · 2023-09-12 09:04:30 +02:00 · 2023-09-12 09:03:41 +02:00
130 changed files with 2255 additions and 288 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@ -0,0 +1,66 @@
+name: Bug Report
+description: Report an Issue or Bug with the Pest
+title: "[Bug]: "
+labels: ["bug"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        We're sorry to hear you have a problem. Can you help us solve it by providing the following details.
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: What Happened
+      description: What did you expect to happen?
+      placeholder: When I use expect()->toBeTrue() in my tests, I get an error
+    validations:
+      required: true
+  - type: textarea
+    id: how-to-reproduce
+    attributes:
+      label: How to Reproduce
+      description: How did this occur, please add any config values used and provide a set of reliable steps if possible.
+      placeholder: Install a fresh Laravel app, add Pest, add a test that uses expect()->toBeTrue()
+    validations:
+      required: true
+  - type: input
+    id: repository-sample
+    attributes:
+      label: Sample Repository
+      description: If possible, please provide a sample repository that reproduces the issue.
+      placeholder: https://github.com.br/your-username/your-repository
+  - type: input
+    id: pest-version
+    attributes:
+      label: Pest Version
+      description: What version of our Package are you running? Please be as specific as possible
+      placeholder: 2.14.1
+    validations:
+      required: true
+  - type: input
+    id: php-version
+    attributes:
+      label: PHP Version
+      description: What version of PHP are you running? Please be as specific as possible
+      placeholder: 8.1.20
+    validations:
+      required: true
+  - type: dropdown
+    id: operating-systems
+    attributes:
+      label: Operation System
+      description: On which operating systems does the problem occur? You can select more than one.
+      multiple: true
+      options:
+        - macOS
+        - Windows
+        - Linux
+    validations:
+      required: true
+  - type: textarea
+    id: notes
+    attributes:
+      label: Notes
+      description: Use this field to provide any other notes that you feel might be relevant to the issue.
+    validations:
+      required: false
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@ -1,10 +1,16 @@
-| Q             | A
-| ------------- | ---
-| Bug fix?      | yes/no
-| New feature?  | yes/no
-| Fixed tickets | #... <!-- #-prefixed issue number(s), if any -->
-
 <!--
- Replace this comment by a description of what your PR is solving.
+- Fill in the form below correctly. This will help the Pest team to understand the PR and also work on it.
 -->

+### What:
+
+- [ ] Bug Fix
+- [ ] New Feature
+
+### Description:
+
+<!-- describe what your PR is solving -->
+
+### Related:
+
+<!-- link to the issue(s) your PR is solving. If it doesn't exist, remove the "Related" section. -->
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@ -14,7 +14,7 @@ jobs:
    strategy:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
-        php: ['8.1', '8.2']
+        php: ['8.1', '8.2', '8.3']
        dependency-version: [prefer-lowest, prefer-stable]

    name: PHP ${{ matrix.php }} - ${{ matrix.os }} - ${{ matrix.dependency-version }}
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -2,6 +2,108 @@

 ## Unreleased

+## [v2.17.0 (2023-09-04)](https://github.com/pestphp/pest/compare/v2.16.1...v2.17.0)
+
+### Added
+
+- `toHaveMethod` expectation ([#947](https://github.com/pestphp/pest/pull/947))
+- `toHaveAttribute` expectation ([#934](https://github.com/pestphp/pest/pull/934))
+
+## [v2.16.1 (2023-08-29)](https://github.com/pestphp/pest/compare/v2.16.0...v2.16.1)
+
+> New changelog format starting this release.
+
+### Added
+* `toHaveSameSize` expectation by @hungthai1401 in https://github.com/pestphp/pest/pull/924, https://github.com/pestphp/pest/pull/930
+
+### Fixed
+* Inconsistent type have count exception by @hungthai1401 in https://github.com/pestphp/pest/pull/923
+* Datasets defined in `Pest.php` 
+
+## [v2.16.0 (2023-08-21)](https://github.com/pestphp/pest/compare/v2.15.0...v2.16.0)
+
+### Added
+
+- `toBeDigits` ([#911](https://github.com/pestphp/pest/pull/911))
+- `toBeCamelCase`, `toBeKebabCase`, `toBeSnakeCase`, `toBeStudlyCase`, `toHaveSnakeCaseKeys`, `toHaveKebabCaseKeys`, `toHaveCamelCaseKeys`, `toHaveStudlyCaseKeys`` ([#921](https://github.com/pestphp/pest/pull/921))
+- native functions support on `arch` expectations, e.g: `expect('sleep')->toBeUsed();` ([#4](https://github.com/pestphp/pest-plugin-arch/pull/4))
+
+### Changed
+
+- `phpunit.xml` stub ([#915](https://github.com/pestphp/pest/pull/915))
+
+### Fixed
+
+- Nested sequences ([#895](https://github.com/pestphp/pest/pull/895))
+
+## [v2.15.0 (2023-08-17)](https://github.com/pestphp/pest/compare/v2.14.1...v2.15.0)
+
+### Added
+
+- PHP 8.3 support ([0b261ef](https://github.com/pestphp/pest/commit/0b261ef97b7ceed20cbeeb2b0b41e08e0a8fcaa1))
+
+## [v2.14.1 (2023-08-16)](https://github.com/pestphp/pest/compare/v2.14.0...v2.14.1)
+
+### Changed
+
+- Bumps PHPUnit to `^10.3.2` ([e012517](https://github.com/pestphp/pest/commit/e012517b1643002b36a68096f4a5e26682b1e175))
+
+## [v2.14.0 (2023-08-14)](https://github.com/pestphp/pest/compare/v2.13.0...v2.14.0)
+
+### Added
+
+- `toBeUppercase()`, `toBeLowercase()`, `toBeAlphaNumeric()`, `toBeAlpha()` ([#906](https://github.com/pestphp/pest/pull/906))
+
+## [v2.13.0 (2023-08-09)](https://github.com/pestphp/pest/compare/v2.12.2...v2.13.0)
+
+### Added
+
+- `expect()->ddWhen` and `expect()->ddUnless` ([306b7eb](https://github.com/pestphp/pest/commit/306b7eb2a6a57e570d58228b46501ad9ba4062b4))
+
+## [v2.12.2 (2023-08-07)](https://github.com/pestphp/pest/compare/v2.12.0...v2.12.2)
+
+### Fixed
+
+- Running tests from `uses` parent class ([#898](https://github.com/pestphp/pest/pull/898))
+
+## [v2.12.0 (2023-08-02)](https://github.com/pestphp/pest/compare/v2.11.0...v2.12.0)
+
+### Added
+
+- Allows multiple `toMatchSnapshot` per test ([#881](https://github.com/pestphp/pest/pull/881))
+
+### Changed
+
+- Bumps PHPUnit to `^10.2.7` ([43107c1](https://github.com/pestphp/pest/commit/43107c17436e41e23018ae31705c688168c14784))
+
+## [v2.11.0 (2023-08-01)](https://github.com/pestphp/pest/compare/v2.10.1...v2.11.0)
+
+### Added
+
+- `toBeInvokable`expectation ([#891](https://github.com/pestphp/pest/pull/891))
+
+## [v2.10.1 (2023-07-31)](https://github.com/pestphp/pest/compare/v2.10.0...v2.10.1)
+
+### Fixed
+
+- `not->toHaveSuffix` and `toHavePrefix` expectations ([#888](https://github.com/pestphp/pest/pull/888))
+
+## [v2.10.0 (2023-07-31)](https://github.com/pestphp/pest/compare/v2.9.5...v2.10.0)
+
+### Added
+
+- `repeat` feature ([f3f35a2](https://github.com/pestphp/pest/commit/f3f35a2ed119f63eefd323a8c66d3387e908df3f))
+
+### Fixed
+
+- `-v` option ([86a6b32](https://github.com/pestphp/pest/commit/86a6b3271518742dc39761228687a5107551d279))
+
+## [v2.9.5 (2023-07-22)](https://github.com/pestphp/pest/compare/v2.9.4...v2.9.5)
+
+### Fixed
+
+- Assertions count on arch expectations ([632ffc2](https://github.com/pestphp/pest/commit/632ffc2f8e1fe45f739b12b818426ae14700079e))
+
 ## [v2.9.4 (2023-07-22)](https://github.com/pestphp/pest/compare/v2.9.3...v2.9.4)

 ### Fixed
--- a/bin/worker.php
+++ b/bin/worker.php
@ -46,6 +46,7 @@ $bootPest = (static function (): void {
    ];

    foreach ($composerAutoloadFiles as $file) {
+
        if (file_exists($file)) {
            require_once $file;
            define('PHPUNIT_COMPOSER_INSTALL', $file);
--- a/composer.json
+++ b/composer.json
@ -18,16 +18,16 @@
    ],
    "require": {
        "php": "^8.1.0",
-        "brianium/paratest": "^7.2.3",
-        "nunomaduro/collision": "^7.7.0",
+        "brianium/paratest": "^7.2.6",
+        "nunomaduro/collision": "^7.8.1",
        "nunomaduro/termwind": "^1.15.1",
-        "pestphp/pest-plugin": "^2.0.1",
-        "pestphp/pest-plugin-arch": "^2.2.2",
-        "phpunit/phpunit": "^10.2.6"
+        "pestphp/pest-plugin": "^2.1.1",
+        "pestphp/pest-plugin-arch": "^2.3.3",
+        "phpunit/phpunit": "^10.3.4"
    },
    "conflict": {
        "webmozart/assert": "<1.11.0",
-        "phpunit/phpunit": ">10.2.6"
+        "phpunit/phpunit": ">10.3.4"
    },
    "autoload": {
        "psr-4": {
@ -42,6 +42,7 @@
        "psr-4": {
            "Tests\\Fixtures\\Covers\\": "tests/Fixtures/Covers",
            "Tests\\Fixtures\\Inheritance\\": "tests/Fixtures/Inheritance",
+            "Tests\\Fixtures\\Arch\\": "tests/Fixtures/Arch",
            "Tests\\": "tests/PHPUnit/"
        },
        "files": [
@ -49,9 +50,9 @@
        ]
    },
    "require-dev": {
-        "pestphp/pest-dev-tools": "^2.12.0",
-        "pestphp/pest-plugin-type-coverage": "^2.0.0",
-        "symfony/process": "^6.3.0"
+        "pestphp/pest-dev-tools": "^2.16.0",
+        "pestphp/pest-plugin-type-coverage": "^2.2.0",
+        "symfony/process": "^6.3.4"
    },
    "minimum-stability": "dev",
    "prefer-stable": true,
@ -103,6 +104,7 @@
                "Pest\\Plugins\\Profile",
                "Pest\\Plugins\\Retry",
                "Pest\\Plugins\\Snapshot",
+                "Pest\\Plugins\\Verbose",
                "Pest\\Plugins\\Version",
                "Pest\\Plugins\\Parallel"
            ]
--- a/overrides/Runner/Filter/NameFilterIterator.php
+++ b/overrides/Runner/Filter/NameFilterIterator.php
@ -34,17 +34,18 @@

 namespace PHPUnit\Runner\Filter;

-use function end;
 use Exception;
-use function implode;
 use Pest\Contracts\HasPrintableTestCaseName;
 use PHPUnit\Framework\SelfDescribing;
 use PHPUnit\Framework\Test;
 use PHPUnit\Framework\TestCase;
 use PHPUnit\Framework\TestSuite;
-use function preg_match;
 use RecursiveFilterIterator;
 use RecursiveIterator;
+
+use function end;
+use function implode;
+use function preg_match;
 use function sprintf;
 use function str_replace;

--- a/overrides/Runner/ResultCache/DefaultResultCache.php
+++ b/overrides/Runner/ResultCache/DefaultResultCache.php
@ -45,9 +45,15 @@ declare(strict_types=1);

 namespace PHPUnit\Runner\ResultCache;

+use const DIRECTORY_SEPARATOR;
+
+use PHPUnit\Framework\TestStatus\TestStatus;
+use PHPUnit\Runner\DirectoryCannotBeCreatedException;
+use PHPUnit\Runner\Exception;
+use PHPUnit\Util\Filesystem;
+
 use function array_keys;
 use function assert;
-use const DIRECTORY_SEPARATOR;
 use function dirname;
 use function file_get_contents;
 use function file_put_contents;
@ -57,10 +63,6 @@ use function is_file;
 use function json_decode;
 use function json_encode;
 use function Pest\version;
-use PHPUnit\Framework\TestStatus\TestStatus;
-use PHPUnit\Runner\DirectoryCannotBeCreatedException;
-use PHPUnit\Runner\Exception;
-use PHPUnit\Util\Filesystem;

 /**
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
--- a/overrides/Runner/TestSuiteLoader.php
+++ b/overrides/Runner/TestSuiteLoader.php
@ -36,18 +36,19 @@ declare(strict_types=1);

 namespace PHPUnit\Runner;

-use function array_diff;
-use function array_values;
-use function basename;
-use function class_exists;
 use Exception;
-use function get_declared_classes;
 use Pest\Contracts\HasPrintableTestCaseName;
 use Pest\TestCases\IgnorableTestCase;
 use Pest\TestSuite;
 use PHPUnit\Framework\TestCase;
 use ReflectionClass;
 use ReflectionException;
+
+use function array_diff;
+use function array_values;
+use function basename;
+use function class_exists;
+use function get_declared_classes;
 use function substr;

 /**
@ -60,6 +61,11 @@ final class TestSuiteLoader
     */
    private static array $loadedClasses = [];

+    /**
+     * @psalm-var array<string, array<class-string>>
+     */
+    private static array $loadedClassesByFilename = [];
+
    /**
     * @psalm-var list<class-string>
     */
@ -97,6 +103,17 @@ final class TestSuiteLoader

        self::$loadedClasses = array_merge($loadedClasses, self::$loadedClasses);

+        foreach ($loadedClasses as $loadedClass) {
+            $reflection = new ReflectionClass($loadedClass);
+            $filename = $reflection->getFileName();
+            self::$loadedClassesByFilename[$filename] = [
+                $loadedClass,
+                ...self::$loadedClassesByFilename[$filename] ?? [],
+            ];
+        }
+
+        $loadedClasses = array_merge(self::$loadedClassesByFilename[$suiteClassFile] ?? [], $loadedClasses);
+
        if (empty($loadedClasses)) {
            return $this->exceptionFor($suiteClassName, $suiteClassFile);
        }
@ -115,7 +132,7 @@ final class TestSuiteLoader
                    continue;
                }

-                if ($class->isAbstract() || ($class->getFileName() !== $suiteClassFile)) {
+                if ($class->isAbstract() || ($suiteClassFile !== $class->getFileName())) {
                    if (! str_contains($class->getFileName(), 'TestCaseFactory.php')) {
                        continue;
                    }
--- a/overrides/TextUI/TestSuiteFilterProcessor.php
+++ b/overrides/TextUI/TestSuiteFilterProcessor.php
@ -45,7 +45,6 @@ declare(strict_types=1);

 namespace PHPUnit\TextUI;

-use function array_map;
 use Pest\Plugins\Only;
 use PHPUnit\Event;
 use PHPUnit\Framework\TestSuite;
@ -53,6 +52,8 @@ use PHPUnit\Runner\Filter\Factory;
 use PHPUnit\TextUI\Configuration\Configuration;
 use PHPUnit\TextUI\Configuration\FilterNotConfiguredException;

+use function array_map;
+
 /**
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
 */
--- a/src/Bootstrappers/BootFiles.php
+++ b/src/Bootstrappers/BootFiles.php
@ -7,12 +7,13 @@ namespace Pest\Bootstrappers;
 use Pest\Contracts\Bootstrapper;
 use Pest\Support\DatasetInfo;
 use Pest\Support\Str;
-use function Pest\testDirectory;
 use Pest\TestSuite;
 use RecursiveDirectoryIterator;
 use RecursiveIteratorIterator;
 use SebastianBergmann\FileIterator\Facade as PhpUnitFileIterator;

+use function Pest\testDirectory;
+
 /**
 * @internal
 */
@ -77,6 +78,8 @@ final class BootFiles implements Bootstrapper

    private function bootDatasets(string $testsPath): void
    {
+        assert(strlen($testsPath) > 0);
+
        $files = (new PhpUnitFileIterator)->getFilesAsArray($testsPath, '.php');

        foreach ($files as $file) {
--- a/src/Concerns/Testable.php
+++ b/src/Concerns/Testable.php
@ -62,6 +62,11 @@ trait Testable
     */
    private static ?Closure $__afterAll = null;

+    /**
+     * The list of snapshot changes, if any.
+     */
+    private array $__snapshotChanges = [];
+
    /**
     * Resets the test case static properties.
     */
@ -187,7 +192,24 @@ trait Testable

        $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());

-        $this->__description = self::$__latestDescription = $this->dataName() ? $method->description.' with '.$this->dataName() : $method->description;
+        $description = $this->dataName() ? $method->description.' with '.$this->dataName() : $method->description;
+
+        if ($method->repetitions > 1) {
+            $matches = [];
+            preg_match('/\((.*?)\)/', $description, $matches);
+
+            if (count($matches) > 1) {
+                if (str_contains($description, 'with '.$matches[0].' /')) {
+                    $description = str_replace('with '.$matches[0].' /', '', $description);
+                } else {
+                    $description = str_replace('with '.$matches[0], '', $description);
+                }
+            }
+
+            $description .= ' @ repetition '.($matches[1].' of '.$method->repetitions);
+        }
+
+        $this->__description = self::$__latestDescription = $description;

        parent::setUp();

@ -238,6 +260,12 @@ trait Testable
     */
    private function __resolveTestArguments(array $arguments): array
    {
+        $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
+
+        if ($method->repetitions > 1) {
+            array_shift($arguments);
+        }
+
        $underlyingTest = Reflection::getFunctionVariable($this->__test, 'closure');
        $testParameterTypes = array_values(Reflection::getFunctionArguments($underlyingTest));

@ -308,6 +336,24 @@ trait Testable
        return ExceptionTrace::ensure(fn (): mixed => call_user_func_array(Closure::bind($closure, $this, $this::class), $arguments));
    }

+    /** @postCondition */
+    protected function __MarkTestIncompleteIfSnapshotHaveChanged(): void
+    {
+        if (count($this->__snapshotChanges) === 0) {
+            return;
+        }
+
+        if (count($this->__snapshotChanges) === 1) {
+            $this->markTestIncomplete($this->__snapshotChanges[0]);
+
+            return;
+        }
+
+        $messages = implode(PHP_EOL, array_map(static fn (string $message): string => '- $message', $this->__snapshotChanges));
+
+        $this->markTestIncomplete($messages);
+    }
+
    /**
     * The printable test case name.
     */
--- a/src/Exceptions/InvalidArgumentException.php
+++ b/src/Exceptions/InvalidArgumentException.php
@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Exceptions;
+
+use InvalidArgumentException as BaseInvalidArgumentException;
+use NunoMaduro\Collision\Contracts\RenderlessEditor;
+use NunoMaduro\Collision\Contracts\RenderlessTrace;
+use Symfony\Component\Console\Exception\ExceptionInterface;
+
+/**
+ * @internal
+ */
+final class InvalidArgumentException extends BaseInvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace
+{
+    /**
+     * Creates a new Exception instance.
+     */
+    public function __construct(string $message)
+    {
+        parent::__construct($message, 1);
+    }
+}
--- a/src/Exceptions/NoDirtyTestsFound.php
+++ b/src/Exceptions/NoDirtyTestsFound.php
@ -14,7 +14,7 @@ use Symfony\Component\Console\Output\OutputInterface;
 /**
 * @internal
 */
-final class NoDirtyTestsFound extends InvalidArgumentException implements ExceptionInterface, RenderlessEditor, RenderlessTrace, Panicable
+final class NoDirtyTestsFound extends InvalidArgumentException implements ExceptionInterface, Panicable, RenderlessEditor, RenderlessTrace
 {
    /**
     * Renders the panic on the given output.
--- a/src/Expectation.php
+++ b/src/Expectation.php
@ -4,8 +4,11 @@ declare(strict_types=1);

 namespace Pest;

+use Attribute;
 use BadMethodCallException;
 use Closure;
+use InvalidArgumentException;
+use OutOfRangeException;
 use Pest\Arch\Contracts\ArchExpectation;
 use Pest\Arch\Expectations\Targeted;
 use Pest\Arch\Expectations\ToBeUsedIn;
@ -28,7 +31,6 @@ use Pest\Expectations\OppositeExpectation;
 use Pest\Matchers\Any;
 use Pest\Support\ExpectationPipeline;
 use PHPUnit\Architecture\Elements\ObjectDescription;
-use PHPUnit\Framework\Assert;
 use PHPUnit\Framework\ExpectationFailedException;

 /**
@ -127,6 +129,40 @@ final class Expectation
        exit(1);
    }

+    /**
+     * Dump the expectation value when the result of the condition is truthy.
+     *
+     * @param  (\Closure(TValue): bool)|bool  $condition
+     * @return self<TValue>
+     */
+    public function ddWhen(Closure|bool $condition, mixed ...$arguments): Expectation
+    {
+        $condition = $condition instanceof Closure ? $condition($this->value) : $condition;
+
+        if (! $condition) {
+            return $this;
+        }
+
+        $this->dd(...$arguments);
+    }
+
+    /**
+     * Dump the expectation value when the result of the condition is falsy.
+     *
+     * @param  (\Closure(TValue): bool)|bool  $condition
+     * @return self<TValue>
+     */
+    public function ddUnless(Closure|bool $condition, mixed ...$arguments): Expectation
+    {
+        $condition = $condition instanceof Closure ? $condition($this->value) : $condition;
+
+        if ($condition) {
+            return $this;
+        }
+
+        $this->dd(...$arguments);
+    }
+
    /**
     * Send the expectation value to Ray along with all given arguments.
     *
@ -185,30 +221,26 @@ final class Expectation
            throw new BadMethodCallException('Expectation value is not iterable.');
        }

-        $value = is_array($this->value) ? $this->value : iterator_to_array($this->value);
-        $keys = array_keys($value);
-        $values = array_values($value);
-        $callbacksCount = count($callbacks);
-
-        $index = 0;
-
-        while (count($callbacks) < count($values)) {
-            $callbacks[] = $callbacks[$index];
-            $index = $index < count($values) - 1 ? $index + 1 : 0;
+        if (count($callbacks) == 0) {
+            throw new InvalidArgumentException('No sequence expectations defined.');
        }

-        if ($callbacksCount > count($values)) {
-            Assert::assertLessThanOrEqual(count($value), count($callbacks));
-        }
+        $index = $valuesCount = 0;

-        foreach ($values as $key => $item) {
-            if ($callbacks[$key] instanceof Closure) {
-                call_user_func($callbacks[$key], new self($item), new self($keys[$key]));
+        foreach ($this->value as $key => $value) {
+            $valuesCount++;

-                continue;
+            if ($callbacks[$index] instanceof Closure) {
+                $callbacks[$index](new self($value), new self($key));
+            } else {
+                (new self($value))->toEqual($callbacks[$index]);
            }

-            (new self($item))->toEqual($callbacks[$key]);
+            $index = isset($callbacks[$index + 1]) ? $index + 1 : 0;
+        }
+
+        if ($valuesCount < count($callbacks)) {
+            throw new OutOfRangeException('Sequence expectations are more than the iterable items.');
        }

        return $this;
@ -417,7 +449,7 @@ final class Expectation
    {
        return Targeted::make(
            $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->isFinal(),
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && $object->reflectionClass->isFinal(),
            'to be final',
            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
        );
@ -430,7 +462,7 @@ final class Expectation
    {
        return Targeted::make(
            $this,
-            fn (ObjectDescription $object): bool => $object->reflectionClass->isReadOnly() && assert(true), // @phpstan-ignore-line,
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && $object->reflectionClass->isReadOnly() && assert(true), // @phpstan-ignore-line
            'to be readonly',
            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
        );
@ -470,6 +502,19 @@ final class Expectation
        );
    }

+    /**
+     * Asserts that the given expectation target has a specific method.
+     */
+    public function toHaveMethod(string $method): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->hasMethod($method),
+            'to have method',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
    /**
     * Asserts that the given expectation target is enum.
     */
@ -498,7 +543,7 @@ final class Expectation
    {
        return Targeted::make(
            $this,
-            fn (ObjectDescription $object): bool => class_exists($object->name),
+            fn (ObjectDescription $object): bool => class_exists($object->name) && ! enum_exists($object->name),
            'to be class',
            FileLineFinder::where(fn (string $line): bool => true),
        );
@ -592,6 +637,19 @@ final class Expectation
        );
    }

+    /**
+     * Asserts that the given expectation target to have the given prefix.
+     */
+    public function toHavePrefix(string $prefix): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => str_starts_with($object->reflectionClass->getShortName(), $prefix),
+            "to have prefix '{$prefix}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
    /**
     * Asserts that the given expectation target to have the given suffix.
     */
@ -605,19 +663,6 @@ final class Expectation
        );
    }

-    /**
-     * Asserts that the given expectation target to have the given suffix.
-     */
-    public function toHavePrefix(string $suffix): ArchExpectation
-    {
-        return Targeted::make(
-            $this,
-            fn (ObjectDescription $object): bool => str_starts_with($object->reflectionClass->getName(), $suffix),
-            "to have prefix '{$suffix}'",
-            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
-        );
-    }
-
    /**
     * Asserts that the given expectation target to implement the given interfaces.
     *
@ -693,4 +738,128 @@ final class Expectation
    {
        return ToBeUsedInNothing::make($this);
    }
+
+    /**
+     * Asserts that the given expectation dependency is an invokable class.
+     */
+    public function toBeInvokable(): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->hasMethod('__invoke'),
+            'to be invokable',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
+        );
+    }
+
+    /**
+     * Asserts that the given expectation is iterable and contains snake_case keys.
+     *
+     * @return self<TValue>
+     */
+    public function toHaveSnakeCaseKeys(string $message = ''): self
+    {
+        if (! is_iterable($this->value)) {
+            InvalidExpectationValue::expected('iterable');
+        }
+
+        foreach ($this->value as $k => $item) {
+            if (is_string($k)) {
+                $this->and($k)->toBeSnakeCase($message);
+            }
+
+            if (is_array($item)) {
+                $this->and($item)->toHaveSnakeCaseKeys($message);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the given expectation is iterable and contains kebab-case keys.
+     *
+     * @return self<TValue>
+     */
+    public function toHaveKebabCaseKeys(string $message = ''): self
+    {
+        if (! is_iterable($this->value)) {
+            InvalidExpectationValue::expected('iterable');
+        }
+
+        foreach ($this->value as $k => $item) {
+            if (is_string($k)) {
+                $this->and($k)->toBeKebabCase($message);
+            }
+
+            if (is_array($item)) {
+                $this->and($item)->toHaveKebabCaseKeys($message);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the given expectation is iterable and contains camelCase keys.
+     *
+     * @return self<TValue>
+     */
+    public function toHaveCamelCaseKeys(string $message = ''): self
+    {
+        if (! is_iterable($this->value)) {
+            InvalidExpectationValue::expected('iterable');
+        }
+
+        foreach ($this->value as $k => $item) {
+            if (is_string($k)) {
+                $this->and($k)->toBeCamelCase($message);
+            }
+
+            if (is_array($item)) {
+                $this->and($item)->toHaveCamelCaseKeys($message);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the given expectation is iterable and contains StudlyCase keys.
+     *
+     * @return self<TValue>
+     */
+    public function toHaveStudlyCaseKeys(string $message = ''): self
+    {
+        if (! is_iterable($this->value)) {
+            InvalidExpectationValue::expected('iterable');
+        }
+
+        foreach ($this->value as $k => $item) {
+            if (is_string($k)) {
+                $this->and($k)->toBeStudlyCase($message);
+            }
+
+            if (is_array($item)) {
+                $this->and($item)->toHaveStudlyCaseKeys($message);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the given expectation target to have the given attribute.
+     *
+     * @param  class-string<Attribute>  $attribute
+     */
+    public function toHaveAttribute(string $attribute): ArchExpectation
+    {
+        return Targeted::make(
+            $this,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->getAttributes($attribute) !== [],
+            "to have attribute '{$attribute}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
 }
--- a/src/Expectations/EachExpectation.php
+++ b/src/Expectations/EachExpectation.php
@ -4,9 +4,10 @@ declare(strict_types=1);

 namespace Pest\Expectations;

-use function expect;
 use Pest\Expectation;

+use function expect;
+
 /**
 * @internal
 *
--- a/src/Expectations/OppositeExpectation.php
+++ b/src/Expectations/OppositeExpectation.php
@ -4,6 +4,7 @@ declare(strict_types=1);

 namespace Pest\Expectations;

+use Attribute;
 use Pest\Arch\Contracts\ArchExpectation;
 use Pest\Arch\Expectations\Targeted;
 use Pest\Arch\Expectations\ToBeUsedIn;
@ -96,7 +97,7 @@ final class OppositeExpectation
    {
        return Targeted::make(
            $this->original,
-            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isFinal(),
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && ! $object->reflectionClass->isFinal(),
            'not to be final',
            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
        );
@ -109,7 +110,7 @@ final class OppositeExpectation
    {
        return Targeted::make(
            $this->original,
-            fn (ObjectDescription $object): bool => ! $object->reflectionClass->isReadOnly() && assert(true), // @phpstan-ignore-line
+            fn (ObjectDescription $object): bool => ! enum_exists($object->name) && ! $object->reflectionClass->isReadOnly() && assert(true), // @phpstan-ignore-line
            'not to be readonly',
            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
        );
@ -128,6 +129,14 @@ final class OppositeExpectation
        );
    }

+    /**
+     * Asserts that the given expectation targets are not traits.
+     */
+    public function toBeTraits(): ArchExpectation
+    {
+        return $this->toBeTrait();
+    }
+
    /**
     * Asserts that the given expectation target is not abstract.
     */
@ -141,6 +150,19 @@ final class OppositeExpectation
        );
    }

+    /**
+     * Asserts that the given expectation target does not have a specific method.
+     */
+    public function toHaveMethod(string $method): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! $object->reflectionClass->hasMethod($method),
+            'to not have method',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
+    }
+
    /**
     * Asserts that the given expectation target is not enum.
     */
@ -154,6 +176,35 @@ final class OppositeExpectation
        );
    }

+    /**
+     * Asserts that the given expectation targets are not enums.
+     */
+    public function toBeEnums(): ArchExpectation
+    {
+        return $this->toBeEnum();
+    }
+
+    /**
+     * Asserts that the given expectation targets is not class.
+     */
+    public function toBeClass(): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! class_exists($object->name),
+            'not to be class',
+            FileLineFinder::where(fn (string $line): bool => true),
+        );
+    }
+
+    /**
+     * Asserts that the given expectation targets are not classes.
+     */
+    public function toBeClasses(): ArchExpectation
+    {
+        return $this->toBeClass();
+    }
+
    /**
     * Asserts that the given expectation target is not interface.
     */
@ -168,7 +219,15 @@ final class OppositeExpectation
    }

    /**
-     * Asserts that the given expectation target to be subclass of the given class.
+     * Asserts that the given expectation targets are not interfaces.
+     */
+    public function toBeInterfaces(): ArchExpectation
+    {
+        return $this->toBeInterface();
+    }
+
+    /**
+     * Asserts that the given expectation target to be not subclass of the given class.
     *
     * @param  class-string  $class
     */
@ -244,19 +303,29 @@ final class OppositeExpectation
    }

    /**
-     * Not supported.
+     * Asserts that the given expectation target to not have the given prefix.
     */
-    public function toHavePrefix(string $suffix): never
+    public function toHavePrefix(string $prefix): ArchExpectation
    {
-        throw InvalidExpectation::fromMethods(['not', 'toHavePrefix']);
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! str_starts_with($object->reflectionClass->getShortName(), $prefix),
+            "not to have prefix '{$prefix}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
    }

    /**
-     * Not supported.
+     * Asserts that the given expectation target to not have the given suffix.
     */
-    public function toHaveSuffix(string $suffix): never
+    public function toHaveSuffix(string $suffix): ArchExpectation
    {
-        throw InvalidExpectation::fromMethods(['not', 'toHaveSuffix']);
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! str_ends_with($object->reflectionClass->getName(), $suffix),
+            "not to have suffix '{$suffix}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class')),
+        );
    }

    /**
@ -310,6 +379,34 @@ final class OppositeExpectation
        throw InvalidExpectation::fromMethods(['not', 'toBeUsedInNothing']);
    }

+    /**
+     * Asserts that the given expectation dependency is not an invokable class.
+     */
+    public function toBeInvokable(): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => ! $object->reflectionClass->hasMethod('__invoke'),
+            'to not be invokable',
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
+        );
+    }
+
+    /**
+     * Asserts that the given expectation target not to have the given attribute.
+     *
+     * @param  class-string<Attribute>  $attribute
+     */
+    public function toHaveAttribute(string $attribute): ArchExpectation
+    {
+        return Targeted::make(
+            $this->original,
+            fn (ObjectDescription $object): bool => $object->reflectionClass->getAttributes($attribute) === [],
+            "to not have attribute '{$attribute}'",
+            FileLineFinder::where(fn (string $line): bool => str_contains($line, 'class'))
+        );
+    }
+
    /**
     * Handle dynamic method calls into the original expectation.
     *
--- a/src/Factories/Annotations/Depends.php
+++ b/src/Factories/Annotations/Depends.php
@ -19,7 +19,7 @@ final class Depends implements AddsAnnotations
    public function __invoke(TestCaseMethodFactory $method, array $annotations): array
    {
        foreach ($method->depends as $depend) {
-            $depend = Str::evaluable($depend);
+            $depend = Str::evaluable($method->describing !== null ? Str::describe($method->describing, $depend) : $depend);

            $annotations[] = "@depends $depend";
        }
--- a/src/Factories/Attributes/Attribute.php
+++ b/src/Factories/Attributes/Attribute.php
@ -20,7 +20,7 @@ abstract class Attribute
     * @param  array<int, string>  $attributes
     * @return array<int, string>
     */
-    public function __invoke(TestCaseMethodFactory $method, array $attributes): array // @phpstan-ignore-line
+    public function __invoke(TestCaseMethodFactory $method, array $attributes): array  // @phpstan-ignore-line
    {
        return $attributes;
    }
--- a/src/Factories/TestCaseFactory.php
+++ b/src/Factories/TestCaseFactory.php
@ -142,7 +142,7 @@ final class TestCaseFactory
        $namespace = implode('\\', $partsFQN);
        $baseClass = sprintf('\%s', $this->class);

-        if ('' === trim($className)) {
+        if (trim($className) === '') {
            $className = 'InvalidTestName'.Str::random();
        }

@ -241,7 +241,7 @@ final class TestCaseFactory
                throw ShouldNotHappen::fromMessage('The test description may not be empty.');
            }

-            if (Str::evaluable($method->description) === $methodName) {
+            if ($methodName === Str::evaluable($method->description)) {
                return true;
            }
        }
@ -259,7 +259,7 @@ final class TestCaseFactory
                throw ShouldNotHappen::fromMessage('The test description may not be empty.');
            }

-            if (Str::evaluable($method->description) === $methodName) {
+            if ($methodName === Str::evaluable($method->description)) {
                return $method;
            }
        }
--- a/src/Factories/TestCaseMethodFactory.php
+++ b/src/Factories/TestCaseMethodFactory.php
@ -26,6 +26,11 @@ final class TestCaseMethodFactory
     */
    public ?string $describing = null;

+    /**
+     * The test's number of repetitions.
+     */
+    public int $repetitions = 1;
+
    /**
     * Determines if the test is a "todo".
     */
@ -140,7 +145,7 @@ final class TestCaseMethodFactory
            $attributes = (new $attribute())->__invoke($this, $attributes);
        }

-        if ($this->datasets !== []) {
+        if ($this->datasets !== [] || $this->repetitions > 1) {
            $dataProviderName = $methodName.'_dataset';
            $annotations[] = "@dataProvider $dataProviderName";
            $datasetsCode = $this->buildDatasetForEvaluation($methodName, $dataProviderName);
@ -177,7 +182,13 @@ final class TestCaseMethodFactory
     */
    private function buildDatasetForEvaluation(string $methodName, string $dataProviderName): string
    {
-        DatasetsRepository::with($this->filename, $methodName, $this->datasets);
+        $datasets = $this->datasets;
+
+        if ($this->repetitions > 1) {
+            $datasets = [range(1, $this->repetitions), ...$datasets];
+        }
+
+        DatasetsRepository::with($this->filename, $methodName, $datasets);

        return <<<EOF

--- a/src/Mixins/Expectation.php
+++ b/src/Mixins/Expectation.php
@ -6,6 +6,7 @@ namespace Pest\Mixins;

 use BadMethodCallException;
 use Closure;
+use Countable;
 use DateTimeInterface;
 use Error;
 use InvalidArgumentException;
@ -15,6 +16,7 @@ use Pest\Matchers\Any;
 use Pest\Support\Arr;
 use Pest\Support\Exporter;
 use Pest\Support\NullClosure;
+use Pest\Support\Str;
 use Pest\TestSuite;
 use PHPUnit\Framework\Assert;
 use PHPUnit\Framework\Constraint\Constraint;
@ -264,7 +266,7 @@ final class Expectation
    public function toHaveCount(int $count, string $message = ''): self
    {
        if (! is_countable($this->value) && ! is_iterable($this->value)) {
-            InvalidExpectationValue::expected('string');
+            InvalidExpectationValue::expected('countable|iterable');
        }

        Assert::assertCount($count, $this->value, $message);
@ -272,6 +274,23 @@ final class Expectation
        return $this;
    }

+    /**
+     * Asserts that the size of the value and $expected are the same.
+     *
+     * @param  Countable|iterable<mixed>  $expected
+     * @return self<TValue>
+     */
+    public function toHaveSameSize(Countable|iterable $expected, string $message = ''): self
+    {
+        if (! is_countable($this->value) && ! is_iterable($this->value)) {
+            InvalidExpectationValue::expected('countable|iterable');
+        }
+
+        Assert::assertSameSize($expected, $this->value, $message);
+
+        return $this;
+    }
+
    /**
     * Asserts that the value contains the property $name.
     *
@ -502,6 +521,18 @@ final class Expectation
        return $this;
    }

+    /**
+     * Asserts that the value contains only digits.
+     *
+     * @return self<TValue>
+     */
+    public function toBeDigits(string $message = ''): self
+    {
+        Assert::assertTrue(ctype_digit((string) $this->value), $message);
+
+        return $this;
+    }
+
    /**
     * Asserts that the value is of type object.
     *
@ -805,6 +836,12 @@ final class Expectation
     */
    public function toMatchSnapshot(string $message = ''): self
    {
+        $snapshots = TestSuite::getInstance()->snapshots;
+        $snapshots->startNewExpectation();
+
+        $testCase = TestSuite::getInstance()->test;
+        assert($testCase instanceof TestCase);
+
        $string = match (true) {
            is_string($this->value) => $this->value,
            is_object($this->value) && method_exists($this->value, '__toString') => $this->value->__toString(),
@ -817,22 +854,18 @@ final class Expectation
            default => InvalidExpectationValue::expected('array|object|string'),
        };

-        $testCase = TestSuite::getInstance()->test;
-        assert($testCase instanceof TestCase);
-        $snapshots = TestSuite::getInstance()->snapshots;
-
-        if ($snapshots->has($testCase, $string)) {
-            [$filename, $content] = $snapshots->get($testCase, $string);
+        if ($snapshots->has()) {
+            [$filename, $content] = $snapshots->get();

            Assert::assertSame(
-                $content,
-                $string,
+                strtr($content, ["\r\n" => "\n", "\r" => "\n"]),
+                strtr($string, ["\r\n" => "\n", "\r" => "\n"]),
                $message === '' ? "Failed asserting that the string value matches its snapshot ($filename)." : $message
            );
        } else {
-            $filename = $snapshots->save($testCase, $string);
+            $filename = $snapshots->save($string);

-            $testCase::markTestIncomplete('Snapshot created at ['.$filename.'].');
+            TestSuite::getInstance()->registerSnapshotChange("Snapshot created at [$filename]");
        }

        return $this;
@ -894,7 +927,7 @@ final class Expectation
            $callback = $exception;
            $parameters = (new ReflectionFunction($exception))->getParameters();

-            if (1 !== count($parameters)) {
+            if (count($parameters) !== 1) {
                throw new InvalidArgumentException('The given closure must have a single parameter type-hinted as the class string.');
            }

@ -918,7 +951,7 @@ final class Expectation
            }

            if (! class_exists($exception)) {
-                if ($e instanceof Error && $e->getMessage() === "Class \"$exception\" not found") {
+                if ($e instanceof Error && "Class \"$exception\" not found" === $e->getMessage()) {
                    Assert::assertTrue(true);

                    throw $e;
@ -959,4 +992,140 @@ final class Expectation

        return $this->exporter->shortenedExport($value);
    }
+
+    /**
+     * Asserts that the value is uppercase.
+     *
+     * @return self<TValue>
+     */
+    public function toBeUppercase(string $message = ''): self
+    {
+        Assert::assertTrue(ctype_upper((string) $this->value), $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is lowercase.
+     *
+     * @return self<TValue>
+     */
+    public function toBeLowercase(string $message = ''): self
+    {
+        Assert::assertTrue(ctype_lower((string) $this->value), $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is alphanumeric.
+     *
+     * @return self<TValue>
+     */
+    public function toBeAlphaNumeric(string $message = ''): self
+    {
+        Assert::assertTrue(ctype_alnum((string) $this->value), $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is alpha.
+     *
+     * @return self<TValue>
+     */
+    public function toBeAlpha(string $message = ''): self
+    {
+        Assert::assertTrue(ctype_alpha((string) $this->value), $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is snake_case.
+     *
+     * @return self<TValue>
+     */
+    public function toBeSnakeCase(string $message = ''): self
+    {
+        $value = (string) $this->value;
+
+        if ($message === '') {
+            $message = "Failed asserting that {$value} is snake_case.";
+        }
+
+        Assert::assertTrue((bool) preg_match('/^[\p{Ll}_]+$/u', $value), $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is kebab-case.
+     *
+     * @return self<TValue>
+     */
+    public function toBeKebabCase(string $message = ''): self
+    {
+        $value = (string) $this->value;
+
+        if ($message === '') {
+            $message = "Failed asserting that {$value} is kebab-case.";
+        }
+
+        Assert::assertTrue((bool) preg_match('/^[\p{Ll}-]+$/u', $value), $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is camelCase.
+     *
+     * @return self<TValue>
+     */
+    public function toBeCamelCase(string $message = ''): self
+    {
+        $value = (string) $this->value;
+
+        if ($message === '') {
+            $message = "Failed asserting that {$value} is camelCase.";
+        }
+
+        Assert::assertTrue((bool) preg_match('/^\p{Ll}[\p{Ll}\p{Lu}]+$/u', $value), $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is StudlyCase.
+     *
+     * @return self<TValue>
+     */
+    public function toBeStudlyCase(string $message = ''): self
+    {
+        $value = (string) $this->value;
+
+        if ($message === '') {
+            $message = "Failed asserting that {$value} is StudlyCase.";
+        }
+
+        Assert::assertTrue((bool) preg_match('/^\p{Lu}+\p{Ll}[\p{Ll}\p{Lu}]+$/u', $value), $message);
+
+        return $this;
+    }
+
+    /**
+     * Asserts that the value is UUID.
+     *
+     * @return self<TValue>
+     */
+    public function toBeUuid(string $message = ''): self
+    {
+        if (! is_string($this->value)) {
+            InvalidExpectationValue::expected('string');
+        }
+
+        Assert::assertTrue(Str::isUuid($this->value), $message);
+
+        return $this;
+    }
 }
--- a/src/PendingCalls/TestCall.php
+++ b/src/PendingCalls/TestCall.php
@ -5,7 +5,7 @@ declare(strict_types=1);
 namespace Pest\PendingCalls;

 use Closure;
-use InvalidArgumentException;
+use Pest\Exceptions\InvalidArgumentException;
 use Pest\Factories\Covers\CoversClass;
 use Pest\Factories\Covers\CoversFunction;
 use Pest\Factories\Covers\CoversNothing;
@ -16,6 +16,7 @@ use Pest\Support\Backtrace;
 use Pest\Support\Exporter;
 use Pest\Support\HigherOrderCallables;
 use Pest\Support\NullClosure;
+use Pest\Support\Str;
 use Pest\TestSuite;
 use PHPUnit\Framework\TestCase;

@ -209,11 +210,25 @@ final class TestCall
     */
    private function skipOn(string $osFamily, string $message): self
    {
-        return PHP_OS_FAMILY === $osFamily
+        return $osFamily === PHP_OS_FAMILY
            ? $this->skip($message)
            : $this;
    }

+    /**
+     * Repeats the current test the given number of times.
+     */
+    public function repeat(int $times): self
+    {
+        if ($times < 1) {
+            throw new InvalidArgumentException('The number of repetitions must be greater than 0.');
+        }
+
+        $this->testCaseMethod->repetitions = $times;
+
+        return $this;
+    }
+
    /**
     * Sets the test as "todo".
     */
@ -347,7 +362,7 @@ final class TestCall
    {
        if (! is_null($this->describing)) {
            $this->testCaseMethod->describing = $this->describing;
-            $this->testCaseMethod->description = sprintf('`%s` → %s', $this->describing, $this->testCaseMethod->description);
+            $this->testCaseMethod->description = Str::describe($this->describing, $this->testCaseMethod->description); // @phpstan-ignore-line
        }

        $this->testSuite->tests->set($this->testCaseMethod);
--- a/src/Pest.php
+++ b/src/Pest.php
@ -6,10 +6,10 @@ namespace Pest;

 function version(): string
 {
-    return '2.9.4';
+    return '2.18.2';
 }

 function testDirectory(string $file = ''): string
 {
-    return TestSuite::getInstance()->testPath.'/'.$file;
+    return TestSuite::getInstance()->testPath.DIRECTORY_SEPARATOR.$file;
 }
--- a/src/Plugins/Help.php
+++ b/src/Plugins/Help.php
@ -6,10 +6,11 @@ namespace Pest\Plugins;

 use Pest\Contracts\Plugins\HandlesArguments;
 use Pest\Support\View;
-use function Pest\version;
 use PHPUnit\TextUI\Help as PHPUnitHelp;
 use Symfony\Component\Console\Output\OutputInterface;

+use function Pest\version;
+
 /**
 * @internal
 */
--- a/src/Plugins/Parallel.php
+++ b/src/Plugins/Parallel.php
@ -13,11 +13,12 @@ use Pest\Plugins\Parallel\Paratest\CleanConsoleOutput;
 use Pest\Support\Arr;
 use Pest\Support\Container;
 use Pest\TestSuite;
-use function Pest\version;
 use Stringable;
 use Symfony\Component\Console\Application;
 use Symfony\Component\Console\Input\ArgvInput;

+use function Pest\version;
+
 final class Parallel implements HandlesArguments
 {
    use HandleArguments;
--- a/src/Plugins/Parallel/Paratest/ResultPrinter.php
+++ b/src/Plugins/Parallel/Paratest/ResultPrinter.php
@ -4,6 +4,16 @@ declare(strict_types=1);

 namespace Pest\Plugins\Parallel\Paratest;

+use ParaTest\Options;
+use Pest\Plugins\Parallel\Support\CompactPrinter;
+use Pest\Support\StateGenerator;
+use PHPUnit\TestRunner\TestResult\TestResult;
+use PHPUnit\TextUI\Output\Printer;
+use SebastianBergmann\Timer\Duration;
+use SplFileInfo;
+use Symfony\Component\Console\Formatter\OutputFormatter;
+use Symfony\Component\Console\Output\OutputInterface;
+
 use function assert;
 use function fclose;
 use function feof;
@ -12,16 +22,7 @@ use function fread;
 use function fseek;
 use function ftell;
 use function fwrite;
-use ParaTest\Options;
-use Pest\Plugins\Parallel\Support\CompactPrinter;
-use Pest\Support\StateGenerator;
-use PHPUnit\TestRunner\TestResult\TestResult;
-use PHPUnit\TextUI\Output\Printer;
-use SebastianBergmann\Timer\Duration;
-use SplFileInfo;
 use function strlen;
-use Symfony\Component\Console\Formatter\OutputFormatter;
-use Symfony\Component\Console\Output\OutputInterface;

 /**
 * @internal
--- a/src/Plugins/Parallel/Paratest/WrapperRunner.php
+++ b/src/Plugins/Parallel/Paratest/WrapperRunner.php
@ -4,15 +4,9 @@ declare(strict_types=1);

 namespace Pest\Plugins\Parallel\Paratest;

-use function array_merge;
-use function array_merge_recursive;
-use function array_shift;
-use function assert;
-use function count;
 use const DIRECTORY_SEPARATOR;
-use function dirname;
-use function file_get_contents;
-use function max;
+
+use NunoMaduro\Collision\Adapters\Phpunit\Support\ResultReflection;
 use ParaTest\Coverage\CoverageMerger;
 use ParaTest\JUnit\LogMerger;
 use ParaTest\JUnit\Writer;
@ -29,11 +23,20 @@ use PHPUnit\TestRunner\TestResult\Facade as TestResultFacade;
 use PHPUnit\TestRunner\TestResult\TestResult;
 use PHPUnit\TextUI\Configuration\CodeCoverageFilterRegistry;
 use PHPUnit\Util\ExcludeList;
-use function realpath;
 use SebastianBergmann\Timer\Timer;
 use SplFileInfo;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Process\PhpExecutableFinder;
+
+use function array_merge;
+use function array_merge_recursive;
+use function array_shift;
+use function assert;
+use function count;
+use function dirname;
+use function file_get_contents;
+use function max;
+use function realpath;
 use function unlink;
 use function unserialize;
 use function usleep;
@ -273,7 +276,7 @@ final class WrapperRunner implements RunnerInterface
            assert($testResult instanceof TestResult);

            $testResultSum = new TestResult(
-                $testResultSum->numberOfTests() + $testResult->numberOfTests(),
+                (int) $testResultSum->hasTests() + (int) $testResult->hasTests(),
                $testResultSum->numberOfTestsRun() + $testResult->numberOfTestsRun(),
                $testResultSum->numberOfAssertions() + $testResult->numberOfAssertions(),
                array_merge_recursive($testResultSum->testErroredEvents(), $testResult->testErroredEvents()),
@ -282,23 +285,23 @@ final class WrapperRunner implements RunnerInterface
                array_merge_recursive($testResultSum->testSuiteSkippedEvents(), $testResult->testSuiteSkippedEvents()),
                array_merge_recursive($testResultSum->testSkippedEvents(), $testResult->testSkippedEvents()),
                array_merge_recursive($testResultSum->testMarkedIncompleteEvents(), $testResult->testMarkedIncompleteEvents()),
-                array_merge_recursive($testResultSum->testTriggeredDeprecationEvents(), $testResult->testTriggeredDeprecationEvents()),
-                array_merge_recursive($testResultSum->testTriggeredPhpDeprecationEvents(), $testResult->testTriggeredPhpDeprecationEvents()),
                array_merge_recursive($testResultSum->testTriggeredPhpunitDeprecationEvents(), $testResult->testTriggeredPhpunitDeprecationEvents()),
-                array_merge_recursive($testResultSum->testTriggeredErrorEvents(), $testResult->testTriggeredErrorEvents()),
-                array_merge_recursive($testResultSum->testTriggeredNoticeEvents(), $testResult->testTriggeredNoticeEvents()),
-                array_merge_recursive($testResultSum->testTriggeredPhpNoticeEvents(), $testResult->testTriggeredPhpNoticeEvents()),
-                array_merge_recursive($testResultSum->testTriggeredWarningEvents(), $testResult->testTriggeredWarningEvents()),
-                array_merge_recursive($testResultSum->testTriggeredPhpWarningEvents(), $testResult->testTriggeredPhpWarningEvents()),
                array_merge_recursive($testResultSum->testTriggeredPhpunitErrorEvents(), $testResult->testTriggeredPhpunitErrorEvents()),
                array_merge_recursive($testResultSum->testTriggeredPhpunitWarningEvents(), $testResult->testTriggeredPhpunitWarningEvents()),
                array_merge_recursive($testResultSum->testRunnerTriggeredDeprecationEvents(), $testResult->testRunnerTriggeredDeprecationEvents()),
                array_merge_recursive($testResultSum->testRunnerTriggeredWarningEvents(), $testResult->testRunnerTriggeredWarningEvents()),
+                array_merge_recursive($testResultSum->errors(), $testResult->errors()),
+                array_merge_recursive($testResultSum->deprecations(), $testResult->deprecations()),
+                array_merge_recursive($testResultSum->notices(), $testResult->notices()),
+                array_merge_recursive($testResultSum->warnings(), $testResult->warnings()),
+                array_merge_recursive($testResultSum->phpDeprecations(), $testResult->phpDeprecations()),
+                array_merge_recursive($testResultSum->phpNotices(), $testResult->phpNotices()),
+                array_merge_recursive($testResultSum->phpWarnings(), $testResult->phpWarnings()),
            );
        }

        $testResultSum = new TestResult(
-            $testResultSum->numberOfTests(),
+            ResultReflection::numberOfTests($testResultSum),
            $testResultSum->numberOfTestsRun(),
            $testResultSum->numberOfAssertions(),
            $testResultSum->testErroredEvents(),
@ -307,14 +310,7 @@ final class WrapperRunner implements RunnerInterface
            $testResultSum->testSuiteSkippedEvents(),
            $testResultSum->testSkippedEvents(),
            $testResultSum->testMarkedIncompleteEvents(),
-            $testResultSum->testTriggeredDeprecationEvents(),
-            $testResultSum->testTriggeredPhpDeprecationEvents(),
            $testResultSum->testTriggeredPhpunitDeprecationEvents(),
-            $testResultSum->testTriggeredErrorEvents(),
-            $testResultSum->testTriggeredNoticeEvents(),
-            $testResultSum->testTriggeredPhpNoticeEvents(),
-            $testResultSum->testTriggeredWarningEvents(),
-            $testResultSum->testTriggeredPhpWarningEvents(),
            $testResultSum->testTriggeredPhpunitErrorEvents(),
            $testResultSum->testTriggeredPhpunitWarningEvents(),
            $testResultSum->testRunnerTriggeredDeprecationEvents(),
@ -322,6 +318,13 @@ final class WrapperRunner implements RunnerInterface
                $testResultSum->testRunnerTriggeredWarningEvents(),
                fn (WarningTriggered $event): bool => ! str_contains($event->message(), 'No tests found')
            )),
+            $testResultSum->errors(),
+            $testResultSum->deprecations(),
+            $testResultSum->notices(),
+            $testResultSum->warnings(),
+            $testResultSum->phpDeprecations(),
+            $testResultSum->phpNotices(),
+            $testResultSum->phpWarnings(),
        );

        $this->printer->printResults(
--- a/src/Plugins/Parallel/Support/CompactPrinter.php
+++ b/src/Plugins/Parallel/Support/CompactPrinter.php
@ -16,8 +16,9 @@ use PHPUnit\TestRunner\TestResult\TestResult as PHPUnitTestResult;
 use SebastianBergmann\Timer\Duration;
 use Symfony\Component\Console\Output\ConsoleOutput;
 use Symfony\Component\Console\Output\OutputInterface;
-use function Termwind\render;
 use Termwind\Terminal;
+
+use function Termwind\render;
 use function Termwind\terminal;

 /**
@ -134,6 +135,10 @@ final class CompactPrinter
            null,
            null,
            null,
+            null,
+            null,
+            null,
+            null,
        );

        $telemetry = new Info(
--- a/src/Plugins/Verbose.php
+++ b/src/Plugins/Verbose.php
@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins;
+
+use Pest\Contracts\Plugins\HandlesArguments;
+
+/**
+ * @internal
+ */
+final class Verbose implements HandlesArguments
+{
+    use Concerns\HandleArguments;
+
+    /**
+     * The list of verbosity levels.
+     */
+    private const VERBOSITY_LEVELS = ['v', 'vv', 'vvv', 'q'];
+
+    /**
+     * {@inheritDoc}
+     */
+    public function handleArguments(array $arguments): array
+    {
+        foreach (self::VERBOSITY_LEVELS as $level) {
+            if ($this->hasArgument('-'.$level, $arguments)) {
+                $arguments = $this->popArgument('-'.$level, $arguments);
+            }
+        }
+
+        if ($this->hasArgument('--quiet', $arguments)) {
+            return $this->popArgument('--quiet', $arguments);
+        }
+
+        return $arguments;
+    }
+}
--- a/src/Plugins/Version.php
+++ b/src/Plugins/Version.php
@ -6,6 +6,7 @@ namespace Pest\Plugins;

 use Pest\Contracts\Plugins\HandlesArguments;
 use Pest\Support\View;
+
 use function Pest\version;

 /**
--- a/src/Repositories/DatasetsRepository.php
+++ b/src/Repositories/DatasetsRepository.php
@ -10,9 +10,10 @@ use Pest\Exceptions\DatasetAlreadyExists;
 use Pest\Exceptions\DatasetDoesNotExist;
 use Pest\Exceptions\ShouldNotHappen;
 use Pest\Support\Exporter;
-use function sprintf;
 use Traversable;

+use function sprintf;
+
 /**
 * @internal
 */
--- a/src/Repositories/SnapshotRepository.php
+++ b/src/Repositories/SnapshotRepository.php
@ -5,14 +5,16 @@ declare(strict_types=1);
 namespace Pest\Repositories;

 use Pest\Exceptions\ShouldNotHappen;
-use Pest\Support\Str;
-use PHPUnit\Framework\TestCase;
+use Pest\TestSuite;

 /**
 * @internal
 */
 final class SnapshotRepository
 {
+    /** @var array<string, int> */
+    private static array $expectationsCounter = [];
+
    /**
     * Creates a snapshot repository instance.
     */
@ -25,11 +27,9 @@ final class SnapshotRepository
    /**
     * Checks if the snapshot exists.
     */
-    public function has(TestCase $testCase, string $description): bool
+    public function has(): bool
    {
-        [$filename, $description] = $this->getFilenameAndDescription($testCase);
-
-        return file_exists($this->getSnapshotFilename($filename, $description));
+        return file_exists($this->getSnapshotFilename());
    }

    /**
@ -39,11 +39,9 @@ final class SnapshotRepository
     *
     * @throws ShouldNotHappen
     */
-    public function get(TestCase $testCase, string $description): array
+    public function get(): array
    {
-        [$filename, $description] = $this->getFilenameAndDescription($testCase);
-
-        $contents = file_get_contents($snapshotFilename = $this->getSnapshotFilename($filename, $description));
+        $contents = file_get_contents($snapshotFilename = $this->getSnapshotFilename());

        if ($contents === false) {
            throw ShouldNotHappen::fromMessage('Snapshot file could not be read.');
@ -57,11 +55,9 @@ final class SnapshotRepository
    /**
     * Saves the given snapshot for the given test case.
     */
-    public function save(TestCase $testCase, string $snapshot): string
+    public function save(string $snapshot): string
    {
-        [$filename, $description] = $this->getFilenameAndDescription($testCase);
-
-        $snapshotFilename = $this->getSnapshotFilename($filename, $description);
+        $snapshotFilename = $this->getSnapshotFilename();

        if (! file_exists(dirname($snapshotFilename))) {
            mkdir(dirname($snapshotFilename), 0755, true);
@ -103,33 +99,43 @@ final class SnapshotRepository
        }
    }

-    /**
-     * Gets the snapshot's "filename" and "description".
-     *
-     * @return array{0: string, 1: string}
-     */
-    private function getFilenameAndDescription(TestCase $testCase): array
-    {
-        $filename = (fn () => self::$__filename)->call($testCase, $testCase::class); // @phpstan-ignore-line
-
-        $description = str_replace('__pest_evaluable_', '', $testCase->name());
-        $datasetAsString = str_replace('__pest_evaluable_', '', Str::evaluable($testCase->dataSetAsStringWithData()));
-
-        $description = str_replace(' ', '_', $description.$datasetAsString);
-
-        return [$filename, $description];
-    }
-
    /**
     * Gets the snapshot's "filename".
     */
-    private function getSnapshotFilename(string $filename, string $description): string
+    private function getSnapshotFilename(): string
    {
-        $relativePath = str_replace($this->testsPath, '', $filename);
+        $relativePath = str_replace($this->testsPath, '', TestSuite::getInstance()->getFilename());

        // remove extension from filename
        $relativePath = substr($relativePath, 0, (int) strrpos($relativePath, '.'));

+        $description = TestSuite::getInstance()->getDescription();
+
+        if ($this->getCurrentSnapshotCounter() > 1) {
+            $description .= '__'.$this->getCurrentSnapshotCounter();
+        }
+
        return sprintf('%s/%s.snap', $this->testsPath.'/'.$this->snapshotsPath.$relativePath, $description);
    }
+
+    private function getCurrentSnapshotKey(): string
+    {
+        return TestSuite::getInstance()->getFilename().'###'.TestSuite::getInstance()->getDescription();
+    }
+
+    private function getCurrentSnapshotCounter(): int
+    {
+        return self::$expectationsCounter[$this->getCurrentSnapshotKey()] ?? 0;
+    }
+
+    public function startNewExpectation(): void
+    {
+        $key = $this->getCurrentSnapshotKey();
+
+        if (! isset(self::$expectationsCounter[$key])) {
+            self::$expectationsCounter[$key] = 0;
+        }
+
+        self::$expectationsCounter[$key]++;
+    }
 }
--- a/src/Result.php
+++ b/src/Result.php
@ -4,6 +4,7 @@ declare(strict_types=1);

 namespace Pest;

+use NunoMaduro\Collision\Adapters\Phpunit\Support\ResultReflection;
 use PHPUnit\TestRunner\TestResult\TestResult;
 use PHPUnit\TextUI\Configuration\Configuration;

@ -44,7 +45,7 @@ final class Result
            return self::SUCCESS_EXIT;
        }

-        if ($configuration->failOnEmptyTestSuite() && $result->numberOfTests() === 0) {
+        if ($configuration->failOnEmptyTestSuite() && ResultReflection::numberOfTests($result) === 0) {
            return self::FAILURE_EXIT;
        }

@ -53,9 +54,9 @@ final class Result
                $returnCode = self::FAILURE_EXIT;
            }

-            $warnings = $result->numberOfTestsWithTestTriggeredPhpunitWarningEvents()
-                + $result->numberOfTestsWithTestTriggeredWarningEvents()
-                + $result->numberOfTestsWithTestTriggeredPhpWarningEvents();
+            $warnings = $result->numberOfTestsWithTestTriggeredPhpunitWarningEvents() +
+                +count($result->warnings())
+                + count($result->phpWarnings());

            if ($configuration->failOnWarning() && $warnings > 0) {
                $returnCode = self::FAILURE_EXIT;
--- a/src/Support/Coverage.php
+++ b/src/Support/Coverage.php
@ -10,6 +10,7 @@ use SebastianBergmann\CodeCoverage\Node\Directory;
 use SebastianBergmann\CodeCoverage\Node\File;
 use SebastianBergmann\Environment\Runtime;
 use Symfony\Component\Console\Output\OutputInterface;
+
 use function Termwind\render;
 use function Termwind\renderUsing;
 use function Termwind\terminal;
--- a/src/Support/DatasetInfo.php
+++ b/src/Support/DatasetInfo.php
@ -4,6 +4,8 @@ declare(strict_types=1);

 namespace Pest\Support;

+use function Pest\testDirectory;
+
 /**
 * @internal
 */
@ -25,6 +27,10 @@ final class DatasetInfo

    public static function scope(string $file): string
    {
+        if (Str::endsWith($file, testDirectory('Pest.php'))) {
+            return dirname($file);
+        }
+
        if (self::isInsideADatasetsDirectory($file)) {
            return dirname($file, 2);
        }
--- a/src/Support/StateGenerator.php
+++ b/src/Support/StateGenerator.php
@ -74,64 +74,76 @@ final class StateGenerator
            ));
        }

-        foreach ($testResult->testTriggeredDeprecationEvents() as $testResultEvent) {
-            $testResultEvent = $testResultEvent[0];
+        foreach ($testResult->deprecations() as $testResultEvent) {
+            foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
+                ['test' => $test] = $triggeringTest;

-            $state->add(TestResult::fromPestParallelTestCase(
-                $testResultEvent->test(),
-                TestResult::DEPRECATED,
-                ThrowableBuilder::from(new TestOutcome($testResultEvent->message()))
-            ));
+                $state->add(TestResult::fromPestParallelTestCase(
+                    $test,
+                    TestResult::DEPRECATED,
+                    ThrowableBuilder::from(new TestOutcome($testResultEvent->description()))
+                ));
+            }
        }

-        foreach ($testResult->testTriggeredPhpDeprecationEvents() as $testResultEvent) {
-            $testResultEvent = $testResultEvent[0];
+        foreach ($testResult->phpDeprecations() as $testResultEvent) {
+            foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
+                ['test' => $test] = $triggeringTest;

-            $state->add(TestResult::fromPestParallelTestCase(
-                $testResultEvent->test(),
-                TestResult::DEPRECATED,
-                ThrowableBuilder::from(new TestOutcome($testResultEvent->message()))
-            ));
+                $state->add(TestResult::fromPestParallelTestCase(
+                    $test,
+                    TestResult::DEPRECATED,
+                    ThrowableBuilder::from(new TestOutcome($testResultEvent->description()))
+                ));
+            }
        }

-        foreach ($testResult->testTriggeredNoticeEvents() as $testResultEvent) {
-            $testResultEvent = $testResultEvent[0];
+        foreach ($testResult->notices() as $testResultEvent) {
+            foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
+                ['test' => $test] = $triggeringTest;

-            $state->add(TestResult::fromPestParallelTestCase(
-                $testResultEvent->test(),
-                TestResult::NOTICE,
-                ThrowableBuilder::from(new TestOutcome($testResultEvent->message()))
-            ));
+                $state->add(TestResult::fromPestParallelTestCase(
+                    $test,
+                    TestResult::NOTICE,
+                    ThrowableBuilder::from(new TestOutcome($testResultEvent->description()))
+                ));
+            }
        }

-        foreach ($testResult->testTriggeredPhpNoticeEvents() as $testResultEvent) {
-            $testResultEvent = $testResultEvent[0];
+        foreach ($testResult->phpNotices() as $testResultEvent) {
+            foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
+                ['test' => $test] = $triggeringTest;

-            $state->add(TestResult::fromPestParallelTestCase(
-                $testResultEvent->test(),
-                TestResult::NOTICE,
-                ThrowableBuilder::from(new TestOutcome($testResultEvent->message()))
-            ));
+                $state->add(TestResult::fromPestParallelTestCase(
+                    $test,
+                    TestResult::NOTICE,
+                    ThrowableBuilder::from(new TestOutcome($testResultEvent->description()))
+                ));
+            }
        }

-        foreach ($testResult->testTriggeredWarningEvents() as $testResultEvent) {
-            $testResultEvent = $testResultEvent[0];
+        foreach ($testResult->warnings() as $testResultEvent) {
+            foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
+                ['test' => $test] = $triggeringTest;

-            $state->add(TestResult::fromPestParallelTestCase(
-                $testResultEvent->test(),
-                TestResult::WARN,
-                ThrowableBuilder::from(new TestOutcome($testResultEvent->message()))
-            ));
+                $state->add(TestResult::fromPestParallelTestCase(
+                    $test,
+                    TestResult::WARN,
+                    ThrowableBuilder::from(new TestOutcome($testResultEvent->description()))
+                ));
+            }
        }

-        foreach ($testResult->testTriggeredPhpWarningEvents() as $testResultEvent) {
-            $testResultEvent = $testResultEvent[0];
+        foreach ($testResult->phpWarnings() as $testResultEvent) {
+            foreach ($testResultEvent->triggeringTests() as $triggeringTest) {
+                ['test' => $test] = $triggeringTest;

-            $state->add(TestResult::fromPestParallelTestCase(
-                $testResultEvent->test(),
-                TestResult::WARN,
-                ThrowableBuilder::from(new TestOutcome($testResultEvent->message()))
-            ));
+                $state->add(TestResult::fromPestParallelTestCase(
+                    $test,
+                    TestResult::WARN,
+                    ThrowableBuilder::from(new TestOutcome($testResultEvent->description()))
+                ));
+            }
        }

        // for each test that passed, we need to add it to the state
@ -140,7 +152,7 @@ final class StateGenerator
                new TestMethod(
                    "$i", // @phpstan-ignore-line
                    '', // @phpstan-ignore-line
-                    '',
+                    '', // @phpstan-ignore-line
                    1,
                    TestDoxBuilder::fromClassNameAndMethodName('', ''), // @phpstan-ignore-line
                    MetadataCollection::fromArray([]),
--- a/src/Support/Str.php
+++ b/src/Support/Str.php
@ -51,7 +51,7 @@ final class Str
            return true;
        }

-        return substr($target, -$length) === $search;
+        return $search === substr($target, -$length);
    }

    /**
@ -92,4 +92,20 @@ final class Str
    {
        return $search === '' ? $subject : array_reverse(explode($search, $subject, 2))[0];
    }
+
+    /**
+     * Determine if a given value is a valid UUID.
+     */
+    public static function isUuid(string $value): bool
+    {
+        return preg_match('/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iD', $value) > 0;
+    }
+
+    /**
+     * Creates a describe block as `$describeDescription` → `$testDescription` format.
+     */
+    public static function describe(string $describeDescription, string $testDescription): string
+    {
+        return sprintf('`%s` → %s', $describeDescription, $testDescription);
+    }
 }
--- a/src/Support/View.php
+++ b/src/Support/View.php
@ -5,9 +5,10 @@ declare(strict_types=1);
 namespace Pest\Support;

 use Symfony\Component\Console\Output\OutputInterface;
+use Termwind\Termwind;
+
 use function Termwind\render;
 use function Termwind\renderUsing;
-use Termwind\Termwind;

 /**
 * @internal
--- a/src/TestSuite.php
+++ b/src/TestSuite.php
@ -11,6 +11,7 @@ use Pest\Repositories\BeforeAllRepository;
 use Pest\Repositories\BeforeEachRepository;
 use Pest\Repositories\SnapshotRepository;
 use Pest\Repositories\TestRepository;
+use Pest\Support\Str;
 use PHPUnit\Framework\TestCase;

 /**
@ -105,4 +106,28 @@ final class TestSuite

        return self::$instance;
    }
+
+    public function getFilename(): string
+    {
+        assert($this->test instanceof TestCase);
+
+        return (fn () => self::$__filename)->call($this->test, $this->test::class); // @phpstan-ignore-line
+    }
+
+    public function getDescription(): string
+    {
+        assert($this->test instanceof TestCase);
+
+        $description = str_replace('__pest_evaluable_', '', $this->test->name());
+        $datasetAsString = str_replace('__pest_evaluable_', '', Str::evaluable($this->test->dataSetAsStringWithData()));
+
+        return str_replace(' ', '_', $description.$datasetAsString);
+    }
+
+    public function registerSnapshotChange(string $message): void
+    {
+        assert($this->test instanceof TestCase);
+
+        (fn (): string => $this->__snapshotChanges[] = $message)->call($this->test, $this->test::class); // @phpstan-ignore-line
+    }
 }
--- a/stubs/init-laravel/phpunit.xml.stub
+++ b/stubs/init-laravel/phpunit.xml.stub
@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:noNamespaceSchemaLocation="./vendor/phpunit/phpunit/phpunit.xsd"
+         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.3/phpunit.xsd"
         bootstrap="vendor/autoload.php"
         colors="true"
 >
@ -12,11 +12,6 @@
            <directory suffix="Test.php">./tests/Feature</directory>
        </testsuite>
    </testsuites>
-    <coverage>
-        <include>
-            <directory suffix=".php">./app</directory>
-        </include>
-    </coverage>
    <php>
        <env name="APP_ENV" value="testing"/>
        <env name="BCRYPT_ROUNDS" value="4"/>
@ -28,4 +23,9 @@
        <env name="SESSION_DRIVER" value="array"/>
        <env name="TELESCOPE_ENABLED" value="false"/>
    </php>
+    <source>
+        <include>
+            <directory suffix=".php">./app</directory>
+        </include>
+    </source>
 </phpunit>
--- a/stubs/init/phpunit.xml.stub
+++ b/stubs/init/phpunit.xml.stub
@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:noNamespaceSchemaLocation="./vendor/phpunit/phpunit/phpunit.xsd"
+         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.3/phpunit.xsd"
         bootstrap="vendor/autoload.php"
         colors="true"
 >
@ -9,10 +9,10 @@
            <directory suffix="Test.php">./tests</directory>
        </testsuite>
    </testsuites>
-    <coverage>
+    <source>
        <include>
            <directory suffix=".php">./app</directory>
            <directory suffix=".php">./src</directory>
        </include>
-    </coverage>
+    </source>
 </phpunit>
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/_describable__→_multiple_snapshot_expectations_with_describe.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/_describable__→_multiple_snapshot_expectations_with_describe.snap
@ -0,0 +1 @@
+foo bar 1
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/_describable__→_multiple_snapshot_expectations_with_describe__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/_describable__→_multiple_snapshot_expectations_with_describe__2.snap
@ -0,0 +1 @@
+foo bar 2
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations.snap
@ -0,0 +1 @@
+foo bar 1
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations__2.snap
@ -0,0 +1 @@
+foo bar 2
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set_1__1_.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set_1__1_.snap
@ -0,0 +1 @@
+foo bar 1
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set_11_2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_set_11_2.snap
@ -0,0 +1 @@
+foo bar 2
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_setbarbar.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_setbarbar.snap
@ -0,0 +1 @@
+foo bar 1
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_setbarbar__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_setbarbar__2.snap
@ -0,0 +1 @@
+foo bar 2
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_setbazbaz.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_setbazbaz.snap
@ -0,0 +1 @@
+foo bar 1
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_setbazbaz__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_setbazbaz__2.snap
@ -0,0 +1 @@
+foo bar 2
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_setfoofoo.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_setfoofoo.snap
@ -0,0 +1 @@
+foo bar 1
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_setfoofoo__2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_datasets_with_data_setfoofoo__2.snap
@ -0,0 +1 @@
+foo bar 2
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_10__10_.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_10__10_.snap
@ -0,0 +1 @@
+foo bar 1
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_1010_2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_1010_2.snap
@ -0,0 +1 @@
+foo bar 2
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_1__1_.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_1__1_.snap
@ -0,0 +1 @@
+foo bar 1
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_11_2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_11_2.snap
@ -0,0 +1 @@
+foo bar 2
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_2__2_.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_2__2_.snap
@ -0,0 +1 @@
+foo bar 1
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_22_2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_22_2.snap
@ -0,0 +1 @@
+foo bar 2
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_3__3_.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_3__3_.snap
@ -0,0 +1 @@
+foo bar 1
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_33_2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_33_2.snap
@ -0,0 +1 @@
+foo bar 2
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_4__4_.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_4__4_.snap
@ -0,0 +1 @@
+foo bar 1
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_44_2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_44_2.snap
@ -0,0 +1 @@
+foo bar 2
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_5__5_.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_5__5_.snap
@ -0,0 +1 @@
+foo bar 1
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_55_2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_55_2.snap
@ -0,0 +1 @@
+foo bar 2
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_6__6_.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_6__6_.snap
@ -0,0 +1 @@
+foo bar 1
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_66_2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_66_2.snap
@ -0,0 +1 @@
+foo bar 2
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_7__7_.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_7__7_.snap
@ -0,0 +1 @@
+foo bar 1
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_77_2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_77_2.snap
@ -0,0 +1 @@
+foo bar 2
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_8__8_.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_8__8_.snap
@ -0,0 +1 @@
+foo bar 1
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_88_2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_88_2.snap
@ -0,0 +1 @@
+foo bar 2
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_9__9_.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_9__9_.snap
@ -0,0 +1 @@
+foo bar 1
--- a/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_99_2.snap
+++ b/tests/.pest/snapshots/Features/Expect/toMatchSnapshot/multiple_snapshot_expectations_with_repeat_with_data_set_99_2.snap
@ -0,0 +1 @@
+foo bar 2
--- a/tests/.pest/snapshots/Visual/Help/visual_snapshot_of_help_command_output.snap
+++ b/tests/.pest/snapshots/Visual/Help/visual_snapshot_of_help_command_output.snap
@ -1,5 +1,5 @@

-  Pest Testing Framework 2.9.4.  
+  Pest Testing Framework 2.18.2.  

  USAGE: pest <file> [options]  

--- a/tests/.pest/snapshots/Visual/Version/visual_snapshot_of_help_command_output.snap
+++ b/tests/.pest/snapshots/Visual/Version/visual_snapshot_of_help_command_output.snap
@ -1,3 +1,3 @@

-  Pest Testing Framework 2.9.4.  
+  Pest Testing Framework 2.18.2.  

--- a/tests/.snapshots/success.txt
+++ b/tests/.snapshots/success.txt
@ -187,6 +187,10 @@
  ✓ with with (1)
  ✓ with on hook → value with (2)
  ✓ with on describe → value with (3)
+  ✓ depends on describe → foo
+  ✓ depends on describe → bar
+  ✓ depends on describe using with → foo with (3)
+  ✓ depends on describe using with → bar with (3)

   PASS  Tests\Features\DescriptionLess
  ✓ get 'foo'
@ -297,17 +301,31 @@

   PASS  Tests\Features\Expect\sequence
  ✓ an exception is thrown if the the type is not iterable
+  ✓ an exception is thrown if there are no expectations
  ✓ allows for sequences of checks to be run on iterable data
  ✓ loops back to the start if it runs out of sequence items
-  ✓ fails if the number of iterable items is greater than the number of expectations
+  ✓ fails if the number of iterable items is less than the number of expectations
  ✓ it works with associative arrays
  ✓ it can be passed non-callable values
  ✓ it can be passed a mixture of value types
+  ✓ it works with traversables

   PASS  Tests\Features\Expect\toBe
  ✓ strict comparisons
  ✓ failures
  ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeAlpha
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeAlphaNumeric
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
  ✓ not failures

   PASS  Tests\Features\Expect\toBeArray
@ -326,6 +344,18 @@
  ✓ pass
  ✓ failures
  ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeCamelCase
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeDigits
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
  ✓ not failures

   PASS  Tests\Features\Expect\toBeDirectory
@ -411,6 +441,14 @@
  ✓ failures with custom message
  ✓ not failures

+   PASS  Tests\Features\Expect\toBeInvokable
+  ✓ class is invokable
+  ✓ opposite class is invokable
+  ✓ class is invokable via a parent class
+  ✓ class is invokable via a trait
+  ✓ failure when the class is not invokable
+  ✓ class is not invokable
+
   PASS  Tests\Features\Expect\toBeIterable
  ✓ pass
  ✓ failures
@ -421,6 +459,12 @@
  ✓ pass
  ✓ failures
  ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeKebabCase
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
  ✓ not failures

   PASS  Tests\Features\Expect\toBeLessThan
@ -435,6 +479,12 @@
  ✓ passes with DateTime and DateTimeImmutable
  ✓ failures
  ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeLowercase
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
  ✓ not failures

   PASS  Tests\Features\Expect\toBeNAN
@ -483,12 +533,24 @@
  ✓ pass
  ✓ failures
  ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeSnakeCase
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
  ✓ not failures

   PASS  Tests\Features\Expect\toBeString
  ✓ pass
  ✓ failures
  ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeStudlyCase
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
  ✓ not failures

   PASS  Tests\Features\Expect\toBeTrue
@ -510,6 +572,19 @@
  ✓ passes as not truthy with ('0')
  ✓ failures
  ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeUppercase
+  ✓ pass
+  ✓ failures
+  ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toBeUuid
+  ✓ failures with wrong type
+  ✓ pass
+  ✓ failures
+  ✓ failures with message
  ✓ not failures

   PASS  Tests\Features\Expect\toBeWritableDirectory
@ -564,10 +639,28 @@
   PASS  Tests\Features\Expect\toEqualWithDelta
  ✓ pass
  ✓ failures with custom message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toHaveAttribute
+  ✓ class has attribute
+  ✓ opposite class has attribute
+  ✓ class not has attribute
+
+   PASS  Tests\Features\Expect\toHaveCamelCaseKeys
+  ✓ pass
+  ✓ failures
+  ✓ failures with message
  ✓ not failures

   PASS  Tests\Features\Expect\toHaveCount
  ✓ pass
+  ✓ failures with invalid type
+  ✓ failures
+  ✓ failures with message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toHaveKebabCaseKeys
+  ✓ pass
  ✓ failures
  ✓ failures with message
  ✓ not failures
@ -618,10 +711,12 @@
  ✓ it fails with message

   PASS  Tests\Features\Expect\toHaveMethod
-  ✓ pass
-  ✓ failures
-  ✓ failures with message
-  ✓ not failures
+  ✓ class has method
+  ✓ opposite class has method
+  ✓ class has method via a parent class
+  ✓ class has method via a trait
+  ✓ failure when the class has no method
+  ✓ class has no method

   PASS  Tests\Features\Expect\toHaveMethods
  ✓ pass
@ -629,6 +724,12 @@
  ✓ failures with custom message
  ✓ not failures

+   PASS  Tests\Features\Expect\toHavePrefix
+  ✓ missing prefix
+  ✓ has prefix
+  ✓ opposite missing prefix
+  ✓ opposite has prefix
+
   PASS  Tests\Features\Expect\toHaveProperties
  ✓ pass
  ✓ failures
@ -642,6 +743,31 @@
  ✓ failures with message and Any matcher
  ✓ not failures

+   PASS  Tests\Features\Expect\toHaveSameSize
+  ✓ failures with wrong type
+  ✓ pass
+  ✓ failures
+  ✓ failures with message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toHaveSnakeCaseKeys
+  ✓ pass
+  ✓ failures
+  ✓ failures with message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toHaveStudlyCaseKeys
+  ✓ pass
+  ✓ failures
+  ✓ failures with message
+  ✓ not failures
+
+   PASS  Tests\Features\Expect\toHaveSuffix
+  ✓ missing suffix
+  ✓ has suffix
+  ✓ opposite missing suffix
+  ✓ opposite has suffix
+
   PASS  Tests\Features\Expect\toMatch
  ✓ pass
  ✓ failures
@ -678,6 +804,22 @@
  ✓ failures
  ✓ failures with custom message
  ✓ not failures
+  ✓ multiple snapshot expectations
+  ✓ multiple snapshot expectations with datasets with (1)
+  ✓ multiple snapshot expectations with datasets with ('foo')
+  ✓ multiple snapshot expectations with datasets with ('bar')
+  ✓ multiple snapshot expectations with datasets with ('baz')
+  ✓ describable → multiple snapshot expectations with describe
+  ✓ multiple snapshot expectations with repeat @ repetition 1 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 2 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 3 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 4 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 5 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 6 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 7 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 8 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 9 of 10
+  ✓ multiple snapshot expectations with repeat @ repetition 10 of 10

   PASS  Tests\Features\Expect\toStartWith
  ✓ pass
@ -762,6 +904,95 @@
  ! notice → This is a notice description // tests/Features/Notices.php:4
  ! a "describe" group of tests → notice → This is a notice description // tests/Features/Notices.php:11

+   PASS  Tests\Features\Repeat
+  ✓ once
+  ✓ multiple times @ repetition 1 of 5
+  ✓ multiple times @ repetition 2 of 5
+  ✓ multiple times @ repetition 3 of 5
+  ✓ multiple times @ repetition 4 of 5
+  ✓ multiple times @ repetition 5 of 5
+  ✓ multiple times with single dataset dataset "a" @ repetition 1 of 6
+  ✓ multiple times with single dataset dataset "b" @ repetition 1 of 6
+  ✓ multiple times with single dataset dataset "c" @ repetition 1 of 6
+  ✓ multiple times with single dataset dataset "a" @ repetition 2 of 6
+  ✓ multiple times with single dataset dataset "b" @ repetition 2 of 6
+  ✓ multiple times with single dataset dataset "c" @ repetition 2 of 6
+  ✓ multiple times with single dataset dataset "a" @ repetition 3 of 6
+  ✓ multiple times with single dataset dataset "b" @ repetition 3 of 6
+  ✓ multiple times with single dataset dataset "c" @ repetition 3 of 6
+  ✓ multiple times with single dataset dataset "a" @ repetition 4 of 6
+  ✓ multiple times with single dataset dataset "b" @ repetition 4 of 6
+  ✓ multiple times with single dataset dataset "c" @ repetition 4 of 6
+  ✓ multiple times with single dataset dataset "a" @ repetition 5 of 6
+  ✓ multiple times with single dataset dataset "b" @ repetition 5 of 6
+  ✓ multiple times with single dataset dataset "c" @ repetition 5 of 6
+  ✓ multiple times with single dataset dataset "a" @ repetition 6 of 6
+  ✓ multiple times with single dataset dataset "b" @ repetition 6 of 6
+  ✓ multiple times with single dataset dataset "c" @ repetition 6 of 6
+  ✓ multiple times with multiple dataset dataset "a" / (4) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (5) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (6) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (4) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (5) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (6) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (4) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (5) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (6) @ repetition 1 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (4) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (5) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (6) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (4) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (5) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (6) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (4) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (5) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (6) @ repetition 2 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (4) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (5) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (6) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (4) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (5) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (6) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (4) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (5) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (6) @ repetition 3 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (4) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (5) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (6) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (4) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (5) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (6) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (4) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (5) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (6) @ repetition 4 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (4) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (5) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (6) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (4) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (5) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (6) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (4) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (5) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (6) @ repetition 5 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (4) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (5) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (6) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (4) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (5) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (6) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (4) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (5) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (6) @ repetition 6 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (4) @ repetition 7 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (5) @ repetition 7 of 7
+  ✓ multiple times with multiple dataset dataset "a" / (6) @ repetition 7 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (4) @ repetition 7 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (5) @ repetition 7 of 7
+  ✓ multiple times with multiple dataset dataset "b" / (6) @ repetition 7 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (4) @ repetition 7 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (5) @ repetition 7 of 7
+  ✓ multiple times with multiple dataset dataset "c" / (6) @ repetition 7 of 7
+
   PASS  Tests\Features\ScopedDatasets\Directory\NestedDirectory1\TestFileInNestedDirectoryWithDatasetsFile
  ✓ uses dataset with (1)
  ✓ uses dataset with (2)
@ -802,6 +1033,9 @@
  ✓ uses dataset with (1)
  ✓ uses dataset with (2)
  ✓ the right dataset is taken
+  ✓ it can see datasets defined in Pest.php file with ('A')
+  ✓ it can see datasets defined in Pest.php file with ('B')
+  ✓ Pest.php dataset is taken

   WARN  Tests\Features\Skip
  ✓ it do not skips
@ -890,9 +1124,15 @@
   PASS  Tests\PHPUnit\CustomAffixes\snakecasespec
  ✓ it runs file names like snake_case_spec.php

+   PASS  Tests\CustomTestCase\ChildTest
+  ✓ override method
+
   PASS  Tests\CustomTestCase\ExecutedTest
  ✓ that gets executed

+   PASS  Tests\CustomTestCase\ParentTest
+  ✓ override method
+
   PASS  Tests\PHPUnit\CustomTestCase\UsesPerDirectory
  ✓ closure was bound to CustomTestCase

@ -1085,4 +1325,4 @@
   WARN  Tests\Visual\Version
  - visual snapshot of help command output

-  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 13 todos, 19 skipped, 743 passed (1788 assertions)
+  Tests:    2 deprecated, 4 warnings, 5 incomplete, 2 notices, 13 todos, 19 skipped, 939 passed (2220 assertions)
--- a/tests/.snapshots/todo.txt
+++ b/tests/.snapshots/todo.txt
@ -19,7 +19,13 @@
  ↓ 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

-  Tests:    13 todos, 1 passed (1 assertions)
+   PASS  Tests\CustomTestCase\ParentTest
+  ✓ override method
+
+  Tests:    13 todos, 3 passed (3 assertions)
--- a/tests/Arch.php
+++ b/tests/Arch.php
@ -3,7 +3,7 @@
 use Pest\Expectation;

 test('globals')
-    ->expect(['dd', 'dump', 'ray'])
+    ->expect(['dd', 'dump', 'ray', 'die', 'var_dump', 'sleep'])
    ->not->toBeUsed()
    ->ignoring(Expectation::class);

--- a/tests/Features/Describe.php
+++ b/tests/Features/Describe.php
@ -76,3 +76,23 @@ describe('with on describe', function () {
        expect($foo)->toBe(3);
    });
 })->with([3]);
+
+describe('depends on describe', function () {
+    test('foo', function () {
+        expect('foo')->toBe('foo');
+    });
+
+    test('bar', function () {
+        expect('bar')->toBe('bar');
+    })->depends('foo');
+});
+
+describe('depends on describe using with', function () {
+    test('foo', function ($foo) {
+        expect($foo)->toBe(3);
+    });
+
+    test('bar', function ($foo) {
+        expect($foo + $foo)->toBe(6);
+    })->depends('foo');
+})->with([3]);
--- a/tests/Features/Expect/sequence.php
+++ b/tests/Features/Expect/sequence.php
@ -1,11 +1,13 @@
 <?php

-use PHPUnit\Framework\ExpectationFailedException;
-
 test('an exception is thrown if the the type is not iterable', function () {
    expect('Foobar')->each->sequence();
 })->throws(BadMethodCallException::class, 'Expectation value is not iterable.');

+test('an exception is thrown if there are no expectations', function () {
+    expect(['Foobar'])->sequence();
+})->throws(InvalidArgumentException::class, 'No sequence expectations defined.');
+
 test('allows for sequences of checks to be run on iterable data', function () {
    expect([1, 2, 3])
        ->sequence(
@ -40,7 +42,7 @@ test('loops back to the start if it runs out of sequence items', function () {
    expect(static::getCount())->toBe(16);
 });

-test('fails if the number of iterable items is greater than the number of expectations', function () {
+test('fails if the number of iterable items is less than the number of expectations', function () {
    expect([1, 2])
        ->sequence(
            function ($expectation) {
@ -53,7 +55,7 @@ test('fails if the number of iterable items is greater than the number of expect
                $expectation->toBeInt()->toEqual(3);
            },
        );
-})->throws(ExpectationFailedException::class);
+})->throws(OutOfRangeException::class, 'Sequence expectations are more than the iterable items.');

 test('it works with associative arrays', function () {
    expect(['foo' => 'bar', 'baz' => 'boom'])
@ -86,3 +88,26 @@ test('it can be passed a mixture of value types', function () {

    expect(static::getCount())->toBe(4);
 });
+
+test('it works with traversables', function () {
+    $generator = (function () {
+        yield 'one' => (fn () => yield from [1, 2, 3])();
+        yield 'two' => (fn () => yield from [4, 5, 6])();
+        yield 'three' => (fn () => yield from [7, 8, 9])();
+    })();
+
+    expect($generator)->sequence(
+        fn ($value, $key) => $key->toBe('one')
+            ->and($value)
+            ->toBeInstanceOf(Generator::class)
+            ->sequence(1, 2, 3),
+        fn ($value, $key) => $key->toBe('two')
+            ->and($value)
+            ->toBeInstanceOf(Generator::class)
+            ->sequence(4, 5, 6),
+        fn ($value, $key) => $key->toBe('three')
+            ->and($value)
+            ->toBeInstanceOf(Generator::class)
+            ->sequence(7, 8, 9),
+    );
+});
--- a/tests/Features/Expect/toBeAlpha.php
+++ b/tests/Features/Expect/toBeAlpha.php
@ -0,0 +1,20 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('abc')->toBeAlpha();
+    expect('123')->not->toBeAlpha();
+});
+
+test('failures', function () {
+    expect('123')->toBeAlpha();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('123')->toBeAlpha('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('abc')->not->toBeAlpha();
+})->throws(ExpectationFailedException::class);
--- a/tests/Features/Expect/toBeAlphaNumeric.php
+++ b/tests/Features/Expect/toBeAlphaNumeric.php
@ -0,0 +1,20 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('abc123')->toBeAlphaNumeric();
+    expect('-')->not->toBeAlphaNumeric();
+});
+
+test('failures', function () {
+    expect('-')->toBeAlphaNumeric();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('-')->toBeAlphaNumeric('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('abc123')->not->toBeAlphaNumeric();
+})->throws(ExpectationFailedException::class);
--- a/tests/Features/Expect/toBeCamelCase.php
+++ b/tests/Features/Expect/toBeCamelCase.php
@ -0,0 +1,23 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('abc')->toBeCamelCase();
+    expect('abcDef')->toBeCamelCase();
+    expect('abc-def')->not->toBeCamelCase();
+    expect('abc-def')->not->toBeCamelCase();
+    expect('AbcDef')->not->toBeCamelCase();
+});
+
+test('failures', function () {
+    expect('Abc')->toBeCamelCase();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('Abc')->toBeCamelCase('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('abcDef')->not->toBeCamelCase();
+})->throws(ExpectationFailedException::class);
--- a/tests/Features/Expect/toBeDigits.php
+++ b/tests/Features/Expect/toBeDigits.php
@ -0,0 +1,20 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('123')->toBeDigits();
+    expect('123.14')->not->toBeDigits();
+});
+
+test('failures', function () {
+    expect('123.14')->toBeDigits();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('123.14')->toBeDigits('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('445')->not->toBeDigits();
+})->throws(ExpectationFailedException::class);
--- a/tests/Features/Expect/toBeInvokable.php
+++ b/tests/Features/Expect/toBeInvokable.php
@ -0,0 +1,29 @@
+<?php
+
+use Pest\Arch\Exceptions\ArchExpectationFailedException;
+
+test('class is invokable')
+    ->expect('Tests\\Fixtures\\Arch\\ToBeInvokable\\IsInvokable\\InvokableClass')
+    ->toBeInvokable();
+
+test('opposite class is invokable')
+    ->throws(ArchExpectationFailedException::class)
+    ->expect('Tests\\Fixtures\\Arch\\ToBeInvokable\\IsInvokable\\InvokableClass')
+    ->not->toBeInvokable();
+
+test('class is invokable via a parent class')
+    ->expect('Tests\\Fixtures\\Arch\\ToBeInvokable\\IsInvokable\\InvokableClassViaParent')
+    ->toBeInvokable();
+
+test('class is invokable via a trait')
+    ->expect('Tests\\Fixtures\\Arch\\ToBeInvokable\\IsInvokable\\InvokableClassViaTrait')
+    ->toBeInvokable();
+
+test('failure when the class is not invokable')
+    ->throws(ArchExpectationFailedException::class)
+    ->expect('Tests\\Fixtures\\Arch\\ToBeInvokable\\IsNotInvokable\\IsNotInvokableClass')
+    ->toBeInvokable();
+
+test('class is not invokable')
+    ->expect('Tests\\Fixtures\\Arch\\ToBeInvokable\\IsNotInvokable\\IsNotInvokableClass')
+    ->not->toBeInvokable();
--- a/tests/Features/Expect/toBeKebabCase.php
+++ b/tests/Features/Expect/toBeKebabCase.php
@ -0,0 +1,23 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('abc')->toBeKebabCase();
+    expect('abc-def')->toBeKebabCase();
+    expect('abc_def')->not->toBeKebabCase();
+    expect('abcDef')->not->toBeKebabCase();
+    expect('AbcDef')->not->toBeKebabCase();
+});
+
+test('failures', function () {
+    expect('Abc')->toBeKebabCase();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('Abc')->toBeKebabCase('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('abc-def')->not->toBeKebabCase();
+})->throws(ExpectationFailedException::class);
--- a/tests/Features/Expect/toBeLowercase.php
+++ b/tests/Features/Expect/toBeLowercase.php
@ -0,0 +1,20 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('lowercase')->toBeLowercase();
+    expect('UPPERCASE')->not->toBeLowercase();
+});
+
+test('failures', function () {
+    expect('UPPERCASE')->toBeLowercase();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('UPPERCASE')->toBeLowercase('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('lowercase')->not->toBeLowercase();
+})->throws(ExpectationFailedException::class);
--- a/tests/Features/Expect/toBeSnakeCase.php
+++ b/tests/Features/Expect/toBeSnakeCase.php
@ -0,0 +1,23 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('abc')->toBeSnakeCase();
+    expect('abc_def')->toBeSnakeCase();
+    expect('abc-def')->not->toBeSnakeCase();
+    expect('abcDef')->not->toBeSnakeCase();
+    expect('AbcDef')->not->toBeSnakeCase();
+});
+
+test('failures', function () {
+    expect('Abc')->toBeSnakeCase();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('Abc')->toBeSnakeCase('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('abc_def')->not->toBeSnakeCase();
+})->throws(ExpectationFailedException::class);
--- a/tests/Features/Expect/toBeStudlyCase.php
+++ b/tests/Features/Expect/toBeStudlyCase.php
@ -0,0 +1,23 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('Abc')->toBeStudlyCase();
+    expect('AbcDef')->toBeStudlyCase();
+    expect('abc-def')->not->toBeStudlyCase();
+    expect('abc-def')->not->toBeStudlyCase();
+    expect('abc')->not->toBeStudlyCase();
+});
+
+test('failures', function () {
+    expect('abc')->toBeStudlyCase();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('abc')->toBeStudlyCase('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('AbcDef')->not->toBeStudlyCase();
+})->throws(ExpectationFailedException::class);
--- a/tests/Features/Expect/toBeUppercase.php
+++ b/tests/Features/Expect/toBeUppercase.php
@ -0,0 +1,20 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('pass', function () {
+    expect('UPPERCASE')->toBeUppercase();
+    expect('lowercase')->not->toBeUppercase();
+});
+
+test('failures', function () {
+    expect('lowercase')->toBeUppercase();
+})->throws(ExpectationFailedException::class);
+
+test('failures with custom message', function () {
+    expect('lowercase')->toBeUppercase('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('UPPERCASE')->not->toBeUppercase();
+})->throws(ExpectationFailedException::class);
--- a/tests/Features/Expect/toBeUuid.php
+++ b/tests/Features/Expect/toBeUuid.php
@ -0,0 +1,31 @@
+<?php
+
+use Pest\Exceptions\InvalidExpectationValue;
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('failures with wrong type', function () {
+    expect([])->toBeUuid();
+})->throws(InvalidExpectationValue::class, 'Invalid expectation value type. Expected [string].');
+
+test('pass', function () {
+    expect('3cafb226-4326-11ee-a516-846993788c86')->toBeUuid(); // version 1
+    expect('0000415c-4326-21ee-a700-846993788c86')->toBeUuid(); // version 2
+    expect('3f703955-aaba-3e70-a3cb-baff6aa3b28f')->toBeUuid(); // version 3
+    expect('ca0a8228-cdf6-41db-b34b-c2f31485796c')->toBeUuid(); // version 4
+    expect('a35477ae-bfb1-5f2e-b5a4-4711594d855f')->toBeUuid(); // version 5
+    expect('1ee43263-cf5a-6fd8-8f47-846993788c86')->toBeUuid(); // version 6
+    expect('018a2bef-09f2-728c-becb-c3f569d91486')->toBeUuid(); // version 7
+    expect('00112233-4455-8677-8899-aabbccddeeff')->toBeUuid(); // version 8
+});
+
+test('failures', function () {
+    expect('foo')->toBeUuid();
+})->throws(ExpectationFailedException::class);
+
+test('failures with message', function () {
+    expect('bar')->toBeUuid('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect('foo')->not->toBeUuid();
+});
--- a/tests/Features/Expect/toHaveAttribute.php
+++ b/tests/Features/Expect/toHaveAttribute.php
@ -0,0 +1,18 @@
+<?php
+
+use Pest\Arch\Exceptions\ArchExpectationFailedException;
+
+test('class has attribute')
+    ->expect('Tests\\Fixtures\\Arch\\ToHaveAttribute\\HaveAttribute')
+    ->toHaveAttribute('Tests\\Fixtures\\Arch\\ToHaveAttribute\\Attributes\\AsAttribute');
+
+test('opposite class has attribute')
+    ->throws(ArchExpectationFailedException::class)
+    ->expect('Tests\\Fixtures\\Arch\\ToHaveAttribute\\HaveAttribute')
+    ->not
+    ->toHaveAttribute('Tests\\Fixtures\\Arch\\ToHaveAttribute\\Attributes\\AsAttribute');
+
+test('class not has attribute')
+    ->expect('Tests\\Fixtures\\Arch\\ToHaveAttribute\\NotHaveAttribute')
+    ->not
+    ->toHaveAttribute('Tests\\Fixtures\\Arch\\ToHaveAttribute\\Attributes\\AsAttribute');
--- a/tests/Features/Expect/toHaveCamelCaseKeys.php
+++ b/tests/Features/Expect/toHaveCamelCaseKeys.php
@ -0,0 +1,36 @@
+<?php
+
+use Pest\Exceptions\InvalidExpectationValue;
+use PHPUnit\Framework\ExpectationFailedException;
+
+$array = [
+    'camel' => true,
+    'camelCase' => [
+        'camel' => true,
+        'camelCase' => [
+            'camel' => true,
+            'camelCase' => true,
+        ],
+        'list' => [
+            'abc',
+            'def',
+            'ghi',
+        ],
+    ],
+];
+
+test('pass', function () use ($array) {
+    expect($array)->toHaveCamelCaseKeys();
+});
+
+test('failures', function () {
+    expect('not-an-array')->toHaveCamelCaseKeys();
+})->throws(InvalidExpectationValue::class);
+
+test('failures with message', function () use ($array) {
+    expect($array)->not->toHaveCamelCaseKeys('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () use ($array) {
+    expect($array)->not->toHaveCamelCaseKeys();
+})->throws(ExpectationFailedException::class);
--- a/tests/Features/Expect/toHaveCount.php
+++ b/tests/Features/Expect/toHaveCount.php
@ -1,11 +1,16 @@
 <?php

+use Pest\Exceptions\InvalidExpectationValue;
 use PHPUnit\Framework\ExpectationFailedException;

 test('pass', function () {
    expect([1, 2, 3])->toHaveCount(3);
 });

+test('failures with invalid type', function () {
+    expect('foo')->toHaveCount(3);
+})->throws(InvalidExpectationValue::class, 'Invalid expectation value type. Expected [countable|iterable]');
+
 test('failures', function () {
    expect([1, 2, 3])->toHaveCount(4);
 })->throws(ExpectationFailedException::class);
--- a/tests/Features/Expect/toHaveKebabCaseKeys.php
+++ b/tests/Features/Expect/toHaveKebabCaseKeys.php
@ -0,0 +1,36 @@
+<?php
+
+use Pest\Exceptions\InvalidExpectationValue;
+use PHPUnit\Framework\ExpectationFailedException;
+
+$array = [
+    'kebab' => true,
+    'kebab-case' => [
+        'kebab' => true,
+        'kebab-case' => [
+            'kebab' => true,
+            'kebab-case' => true,
+        ],
+        'list' => [
+            'abc',
+            'def',
+            'ghi',
+        ],
+    ],
+];
+
+test('pass', function () use ($array) {
+    expect($array)->toHaveKebabCaseKeys();
+});
+
+test('failures', function () {
+    expect('not-an-array')->toHaveKebabCaseKeys();
+})->throws(InvalidExpectationValue::class);
+
+test('failures with message', function () use ($array) {
+    expect($array)->not->toHaveKebabCaseKeys('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () use ($array) {
+    expect($array)->not->toHaveKebabCaseKeys();
+})->throws(ExpectationFailedException::class);
--- a/tests/Features/Expect/toHaveMethod.php
+++ b/tests/Features/Expect/toHaveMethod.php
@ -1,28 +1,29 @@
 <?php

-use PHPUnit\Framework\ExpectationFailedException;
+use Pest\Arch\Exceptions\ArchExpectationFailedException;

-$object = new class
-{
-    public function foo(): void
-    {
-    }
-};
+test('class has method')
+    ->expect('Tests\Fixtures\Arch\ToHaveMethod\HasMethod\HasMethod')
+    ->toHaveMethod('foo');

-test('pass', function () use ($object) {
-    expect($object)->toHaveMethod('foo')
-        ->and($object)->toHaveMethod('foo')
-        ->and($object)->not->toHaveMethod('fooNull');
-});
+test('opposite class has method')
+    ->throws(ArchExpectationFailedException::class)
+    ->expect('Tests\Fixtures\Arch\ToHaveMethod\HasMethod\HasMethod')
+    ->not->toHaveMethod('foo');

-test('failures', function () use ($object) {
-    expect($object)->toHaveMethod('bar');
-})->throws(ExpectationFailedException::class);
+test('class has method via a parent class')
+    ->expect('Tests\Fixtures\Arch\ToHaveMethod\HasMethod\HasMethodViaParent')
+    ->toHaveMethod('foo');

-test('failures with message', function () use ($object) {
-    expect($object)->toHaveMethod(name: 'bar', message: 'oh no!');
-})->throws(ExpectationFailedException::class, 'oh no!');
+test('class has method via a trait')
+    ->expect('Tests\Fixtures\Arch\ToHaveMethod\HasMethod\HasMethodViaTrait')
+    ->toHaveMethod('foo');

-test('not failures', function () use ($object) {
-    expect($object)->not->toHaveMethod('foo');
-})->throws(ExpectationFailedException::class);
+test('failure when the class has no method')
+    ->throws(ArchExpectationFailedException::class)
+    ->expect('Tests\Fixtures\Arch\ToHaveMethod\HasNoMethod\HasNoMethodClass')
+    ->toHaveMethod('foo');
+
+test('class has no method')
+    ->expect('Tests\Fixtures\Arch\ToHaveMethod\HasNoMethod\HasNoMethodClass')
+    ->not->toHaveMethod('foo');
--- a/tests/Features/Expect/toHavePrefix.php
+++ b/tests/Features/Expect/toHavePrefix.php
@ -0,0 +1,21 @@
+<?php
+
+use Pest\Arch\Exceptions\ArchExpectationFailedException;
+
+test('missing prefix')
+    ->throws(ArchExpectationFailedException::class)
+    ->expect('Tests\\Fixtures\\Arch\\ToHavePrefix\\HasNoPrefix')
+    ->toHavePrefix('Prefix');
+
+test('has prefix')
+    ->expect('Tests\\Fixtures\\Arch\\ToHavePrefix\\HasPrefix')
+    ->toHavePrefix('Prefix');
+
+test('opposite missing prefix')
+    ->throws(ArchExpectationFailedException::class)
+    ->expect('Tests\\Fixtures\\Arch\\ToHavePrefix\\HasPrefix')
+    ->not->toHavePrefix('Prefix');
+
+test('opposite has prefix')
+    ->expect('Tests\\Fixtures\\Arch\\ToHavePrefix\\HasNoPrefix')
+    ->not->toHavePrefix('Prefix');
--- a/tests/Features/Expect/toHaveSameSize.php
+++ b/tests/Features/Expect/toHaveSameSize.php
@ -0,0 +1,24 @@
+<?php
+
+use Pest\Exceptions\InvalidExpectationValue;
+use PHPUnit\Framework\ExpectationFailedException;
+
+test('failures with wrong type', function () {
+    expect('foo')->toHaveSameSize([1]);
+})->throws(InvalidExpectationValue::class, 'Invalid expectation value type. Expected [countable|iterable].');
+
+test('pass', function () {
+    expect([1, 2, 3])->toHaveSameSize([4, 5, 6]);
+});
+
+test('failures', function () {
+    expect([1, 2, 3])->toHaveSameSize([1]);
+})->throws(ExpectationFailedException::class);
+
+test('failures with message', function () {
+    expect([1, 2, 3])->toHaveSameSize([1], 'oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () {
+    expect([1, 2, 3])->not->toHaveSameSize([1]);
+});
--- a/tests/Features/Expect/toHaveSnakeCaseKeys.php
+++ b/tests/Features/Expect/toHaveSnakeCaseKeys.php
@ -0,0 +1,36 @@
+<?php
+
+use Pest\Exceptions\InvalidExpectationValue;
+use PHPUnit\Framework\ExpectationFailedException;
+
+$array = [
+    'snake' => true,
+    'snake_case' => [
+        'snake' => true,
+        'snake_case' => [
+            'snake' => true,
+            'snake_case' => true,
+        ],
+        'list' => [
+            'abc',
+            'def',
+            'ghi',
+        ],
+    ],
+];
+
+test('pass', function () use ($array) {
+    expect($array)->toHaveSnakeCaseKeys();
+});
+
+test('failures', function () {
+    expect('not-an-array')->toHaveSnakeCaseKeys();
+})->throws(InvalidExpectationValue::class);
+
+test('failures with message', function () use ($array) {
+    expect($array)->not->toHaveSnakeCaseKeys('oh no!');
+})->throws(ExpectationFailedException::class, 'oh no!');
+
+test('not failures', function () use ($array) {
+    expect($array)->not->toHaveSnakeCaseKeys();
+})->throws(ExpectationFailedException::class);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Nuno Maduro	b53e396aac	release: v2.18.2	2023-09-13 23:14:31 +01:00
Nuno Maduro	8b327aa8b4	chore: adds phpunit `10.3.4` support	2023-09-13 23:14:22 +01:00
Nuno Maduro	d0c6f9bc60	Merge pull request #957 from adevade/patch-1 Switch mixed indentation to spaces only in Laravel stub for `phpunit.xml.stub`	2023-09-12 16:15:39 +01:00
Andréas Lundgren	b5e066939b	Whoops	2023-09-12 09:04:30 +02:00
Andréas Lundgren	7892237408	Update Laravel phpunit.xml.stub indentation	2023-09-12 09:03:41 +02:00
Nuno Maduro	74df53c72b	release: v2.18.1	2023-09-11 11:38:47 +01:00
Nuno Maduro	ee26457705	Merge pull request #956 from Itemshopp/phpunit-xml-stub-update [2.x] Update phpunit.xml stub file	2023-09-11 11:32:34 +01:00
MHO	09e6a0944a	Removed self closing coverage tag from phpunit xml stub files	2023-09-11 11:03:25 +02:00
MHO	bdee46043a	Reformatted php unit xml tag attributes in both init stubs files	2023-09-10 13:37:26 +02:00
MHO	3e25168777	Corrected incorrect indentation in laravel phpunit xml slug	2023-09-10 13:00:55 +02:00
MHO	21b8507252	Updated Laravel init phpunit.xml stub file	2023-09-08 16:40:25 +02:00
MHO	d8e283777e	Updated phpunit.xml stub file	2023-09-08 15:39:44 +02:00
Nuno Maduro	2b0aa4b9c9	release: v2.18.0	2023-09-07 19:00:46 +01:00
Nuno Maduro	040eb8142d	chore: phpunit 10.3.3 support	2023-09-07 19:00:26 +01:00
Nuno Maduro	d1aeabc9da	chore: style changes	2023-09-06 12:19:27 +01:00
Nuno Maduro	e4ec2b3efa	chore: updates snapshots	2023-09-06 11:58:48 +01:00
Nuno Maduro	dedcc6b887	Merge pull request #950 from hungthai1401/wrong_comment [2.x] Correct some comment messages in `OppositeExpectation`	2023-09-06 11:55:17 +01:00
Nuno Maduro	2b0ed2bc45	Merge pull request #948 from hungthai1401/to_be_uuid [2.x] Add `toBeUuid` expectation	2023-09-06 11:54:05 +01:00
Nuno Maduro	9c859ae7c4	Merge branch '2.x' into to_be_uuid	2023-09-06 11:53:58 +01:00
Nuno Maduro	ae0a230046	chore: improves readability	2023-09-06 11:48:53 +01:00
Nuno Maduro	644fade478	Merge pull request #949 from pestphp/fix-depends-with-describe [2.x] Fix the Usage of `depends` With `describe`	2023-09-06 11:47:34 +01:00
Thai Nguyen Hung	c9e919dd40	fix: correct comment message in `OppositeExpectation`	2023-09-06 08:34:48 +07:00
Thai Nguyen Hung	42323e27b1	fix: correct method name	2023-09-06 08:21:42 +07:00
AJ Meireles	3927177b23	finishing the code	2023-09-05 20:36:18 -03:00
Thai Nguyen Hung	038fd80428	feat: `toBeUUID` expectation	2023-09-05 08:25:02 +07:00
Nuno Maduro	cc6c5bf199	docs: updates changelog	2023-09-04 00:20:57 +01:00
Nuno Maduro	b88d9e8ff2	tests: update snapshots	2023-09-03 23:24:52 +01:00
Nuno Maduro	0fc232bbc7	Merge pull request #934 from hungthai1401/to_have_attribute_expectation [2.x] Add `toHaveAttribute` expectation	2023-09-03 23:18:47 +01:00
Nuno Maduro	7dcd42d113	chore: prepares release	2023-09-03 21:39:21 +01:00
Nuno Maduro	e79ffc6bad	tests: adjusts snapshots	2023-09-03 21:36:48 +01:00
Nuno Maduro	8ea425b266	Merge pull request #947 from ludoguenet/2.x [2.x] Add `toHaveMethod` arch expectation	2023-09-03 21:32:01 +01:00
Nuno Maduro	3a0f6a1d09	chore: prepares release	2023-09-03 13:37:26 +01:00
Ludovic Guénet	b9b90295fa	Update Expectation.php Typo	2023-09-01 18:39:37 +02:00
ludoguenet	9dabecacbf	Add toHaveMethod arch expectation	2023-09-01 18:32:40 +02:00
Nuno Maduro	04fa6b6372	Merge pull request #943 from fabio-ivona/datasets-in-pest-file fix directory separator for windows	2023-08-29 10:36:58 +01:00
Nuno Maduro	a0d2856f51	docs: update changelog	2023-08-29 10:36:06 +01:00
Nuno Maduro	55b9266648	release: v2.16.1	2023-08-29 10:30:36 +01:00
Nuno Maduro	4313a1ef20	chore: bump dependencies	2023-08-29 10:30:28 +01:00
Nuno Maduro	005ef03845	chore: bumps dependencies	2023-08-29 10:17:07 +01:00
Fabio Ivona	bbac28c9f4	fix directory separator for windows	2023-08-29 11:14:23 +02:00
Nuno Maduro	eb56483ba2	Merge pull request #942 from fabio-ivona/datasets-in-pest-file [fix] missing datasets when defined in Pest.php file	2023-08-29 09:54:09 +01:00
Fabio Ivona	5d6b717c9a	fix missing datasets when defined in Pest.php file	2023-08-29 10:49:17 +02:00
Thai Nguyen Hung	e69899559d	refactor: generic attribute	2023-08-24 15:23:13 +07:00
Thai Nguyen Hung	e6fe968d44	fix: pint	2023-08-24 14:45:11 +07:00
Thai Nguyen Hung	678898efe7	feat: `toHaveAttribute` expectation	2023-08-24 14:26:54 +07:00
Nuno Maduro	14859a4c89	Merge pull request #930 from pestphp/feature/same-size-arg [2.x] chore: resolve `toHaveSameSize` parameter	2023-08-23 12:01:34 +01:00
Owen Voke	8a44d3f136	chore: resolve `toHaveSameSize` parameter	2023-08-23 11:28:41 +01:00
Nuno Maduro	be71d6918d	chore: bump dependencies	2023-08-23 10:35:06 +01:00
Nuno Maduro	afb3dd459a	Merge pull request #924 from hungthai1401/to_have_same_size_expectation [2.x] Add `toHaveSameSize` expectation	2023-08-23 10:14:17 +01:00
Thai Nguyen Hung	b6e3ffafa7	fix: phpstan	2023-08-23 08:14:27 +07:00
Nuno Maduro	6c95f3d8cf	Merge pull request #923 from hungthai1401/inconsistent_type_have_count_exception [2.x] Inconsistent type have count exception	2023-08-22 10:37:59 +01:00
Thai Nguyen Hung	2192373bec	test: `toHaveSameSize`	2023-08-22 11:10:38 +07:00
Thai Nguyen Hung	dfcdaa3f8e	feat: `toHaveSameSize` expectation	2023-08-22 11:10:25 +07:00
Thai Nguyen Hung	79bc9e677f	test: `toHaveCount` with invalid type	2023-08-22 10:36:10 +07:00
Thai Nguyen Hung	60b615ea6a	fix: inconsistent type in `InvalidExpectationValue` exception at `toHaveCount` expectation	2023-08-22 10:35:07 +07:00
Nuno Maduro	8787481e40	docs: updates changelog	2023-08-21 09:53:42 +01:00
Nuno Maduro	c24406259f	docs: updates changelog	2023-08-21 09:51:12 +01:00
Nuno Maduro	cbd6a65057	release: v2.16.0	2023-08-21 09:42:07 +01:00
Nuno Maduro	175004baf3	chore: adds testing on native functions	2023-08-21 09:40:04 +01:00
Nuno Maduro	6d9c0483a6	chore: improves type checking	2023-08-21 09:39:55 +01:00
Nuno Maduro	2dc413cba0	tests: update snapshots	2023-08-19 10:42:42 +01:00
Nuno Maduro	206548af2b	Merge pull request #895 from cerbero90/feature/traversable-sequence [2.x] Add support for nested traversable in sequence	2023-08-19 09:38:46 +00:00
Nuno Maduro	af6de422e9	Merge pull request #921 from leMaur/feat/string-case-expectations feat: add string case expectations	2023-08-19 09:38:31 +00:00
Maurizio	1c7b254395	Merge branch '2.x' into feat/string-case-expectations	2023-08-19 10:28:48 +02:00
Maurizio	de1c721cd9	chore: improve error messages	2023-08-19 10:27:21 +02:00
Maurizio	f8dd286213	chore: skip array list	2023-08-19 10:27:02 +02:00
Andrea Marco Sartori	e11337df2d	Merge branch '2.x' into feature/traversable-sequence	2023-08-19 00:34:30 +02:00
Nuno Maduro	2f90d4ccd7	tests: update snapshots	2023-08-18 12:16:15 +01:00
Andrea Marco Sartori	2db15af24a	Merge branch '2.x' into feature/traversable-sequence	2023-08-18 12:33:09 +02:00
Nuno Maduro	c9e3932637	Merge pull request #911 from devajmeireles/feature/add-to-be-digits-expectation [2.x] Introducing `toBeDigits` Expectation	2023-08-18 03:13:59 +00:00
AJ Meireles	d218afaf77	introducing new proposal of the PR template	2023-08-17 18:50:23 -03:00
Nuno Maduro	19739ff814	Merge pull request #915 from pestphp/adapting-phpunit-xml-stubs [2.x] Adapting `phpunit.xml` stubs with PhpUnit	2023-08-17 18:56:50 +00:00
Maurizio	478144fb35	feat: add `toHaveStudlyCaseKeys`	2023-08-17 20:51:26 +02:00
Maurizio	5d81cf0d4c	feat: add `toHaveCamelCaseKeys`	2023-08-17 20:51:14 +02:00
Maurizio	0b115230f9	feat: add `toHaveKebabCaseKeys`	2023-08-17 20:50:51 +02:00
Maurizio	0b246f7a76	feat: add `toHaveSnakeCaseKeys`	2023-08-17 20:50:26 +02:00
AJ Meireles	7914224ff7	introducing https://schema.phpunit.de/10.3/phpunit.xsd	2023-08-17 15:50:15 -03:00
Maurizio	997b0e9368	feat: add `toBeStudlyCase`	2023-08-17 20:49:40 +02:00
Maurizio	a76414aeee	feat: add `toBeCamelCase`	2023-08-17 20:49:21 +02:00
Maurizio	d2096df82a	feat: add `toBeKebabCase`	2023-08-17 20:48:51 +02:00
Maurizio	4951b1b0f9	feat: add `toBeSnakeCase`	2023-08-17 20:48:18 +02:00
AJ Meireles	f2e31452f2	Merge pull request #912 from devajmeireles/issue-template Introducing Issue Template	2023-08-17 11:04:27 -03:00
Nuno Maduro	c2985ffb31	release: v2.15.0	2023-08-17 11:28:55 +01:00
Nuno Maduro	492f797dd5	chore: style changes	2023-08-17 11:24:16 +01:00
Nuno Maduro	0b261ef97b	feat: adds `php@8.3` support	2023-08-17 11:19:43 +01:00
Nuno Maduro	f19692a72f	chore: changes phpstan settings	2023-08-17 11:19:11 +01:00
Nuno Maduro	0787b37f2c	chore: style changes	2023-08-17 11:18:59 +01:00
AJ Meireles	f0223b50d0	introducing sample repository input	2023-08-16 15:50:40 -03:00
AJ Meireles	0263fcb2ac	wip	2023-08-16 14:18:09 -03:00
AJ Meireles	c0a234317b	introducing issue template	2023-08-16 14:16:18 -03:00
Nuno Maduro	72100075d2	docs: updates changelog	2023-08-16 09:49:07 +01:00
Nuno Maduro	a7aa923241	release: v2.14.1	2023-08-16 09:47:05 +01:00
Nuno Maduro	e012517b16	chore: bumps phpunit	2023-08-16 09:46:51 +01:00
Nuno Maduro	b1dd18af8a	chore: style changes	2023-08-16 09:46:31 +01:00
AJ Meireles	398e3ff3b5	introducing toBeDigits	2023-08-14 17:10:58 -03:00
Nuno Maduro	03648f580c	docs: update changelog	2023-08-14 09:44:14 +01:00
Nuno Maduro	df2212055b	release: v2.14.0	2023-08-14 09:41:14 +01:00
Nuno Maduro	b1a137c513	chore: updates snapshot tests	2023-08-14 09:41:05 +01:00
Nuno Maduro	62267dfd3e	Merge pull request #906 from JonPurvis/extra-expectations add expectations for uppercase, lowercase, alpha and alphanumeric	2023-08-13 08:44:17 +00:00
JonPurvis	f996a48dfa	fix refacto check	2023-08-12 18:14:38 +01:00
JonPurvis	54e00dd4dc	add expectations for uppercase, lowercase, alpha and alphanumeric	2023-08-12 16:41:15 +01:00
Nuno Maduro	f1414a0beb	docs: changelog	2023-08-09 12:16:21 +01:00
Nuno Maduro	47f2ae32c1	release: v2.13.0	2023-08-09 12:14:39 +01:00
Nuno Maduro	306b7eb2a6	feat: adds `ddWhen` and `ddUnless`	2023-08-09 12:14:32 +01:00
Nuno Maduro	02f72aabb2	Merge pull request #860 from devajmeireles/feature/add-dd-conditionally Feature: Introducing The Ability to Dump Conditionally	2023-08-09 10:50:53 +00:00
Nuno Maduro	e3a21384e6	release: v2.12.2	2023-08-07 10:29:25 +01:00
Nuno Maduro	331381eed5	release: v2.12.1	2023-08-07 10:26:55 +01:00
Nuno Maduro	75a7d77a80	Updates snapshots	2023-08-07 10:22:58 +01:00
Nuno Maduro	cc242a50d1	chore: bump dependencies	2023-08-07 09:39:13 +01:00
Nuno Maduro	704acbf6de	Merge pull request #898 from dylanbr/allow_tests_to_be_extended TestSuiteLoader will always consider classes from the current file	2023-08-06 22:59:52 +00:00
Dylan Bridgman	7baa48e068	TestSuiteLoader will always consider classes from the current file	2023-08-05 13:06:00 +02:00
Nuno Maduro	3742e74adf	feat: adds `"phpunit/phpunit": "^10.3.1"` support	2023-08-04 11:23:55 +01:00
Nuno Maduro	cbcea04768	tests: update snapshots	2023-08-03 10:35:38 +01:00
Nuno Maduro	f0581f87c6	Merge pull request #896 from fabio-ivona/windows-tests-fix fix tests	2023-08-03 09:33:17 +00:00
Fabio Ivona	60763f2223	fix tests	2023-08-03 11:27:01 +02:00
Nuno Maduro	8a589022d9	release: v2.12.0	2023-08-02 23:04:35 +01:00
Nuno Maduro	00109e9976	tests: adds more tests regarding snapshots multiple	2023-08-02 23:02:00 +01:00
Nuno Maduro	43107c1743	chore: bumps phpunit	2023-08-02 23:01:36 +01:00
Nuno Maduro	546253d591	Merge pull request #881 from fabio-ivona/snaphsots-cleanup [2.x] Multiple snapshots	2023-08-02 21:43:56 +00:00
Andrea Marco Sartori	d94a6580f5	fix: type check	2023-08-02 20:49:27 +02:00
Andrea Marco Sartori	fb75b712d3	chore: update snapshot	2023-08-02 20:49:05 +02:00
Andrea Marco Sartori	6ead2a4e8b	feat(sequence): Add support for nested traversable	2023-08-02 20:31:53 +02:00
Fabio Ivona	9afe2296a6	fix line endings on Windows	2023-08-02 10:45:30 +02:00
Fabio Ivona	0221c2a643	refactor	2023-08-01 17:18:55 +02:00
Fabio Ivona	0518971d2f	refactor	2023-08-01 17:16:50 +02:00
Fabio Ivona	fe3747f850	lint	2023-08-01 17:15:44 +02:00
Fabio Ivona	844d175981	refactor	2023-08-01 17:14:49 +02:00
Fabio Ivona	4e719214c6	fix incomplete tests while updating snapshots	2023-08-01 17:13:15 +02:00
Fabio Ivona	2f6b99885e	Merge branch '2.x' into snaphsots-cleanup # Conflicts: # src/Expectation.php # src/Expectations/OppositeExpectation.php	2023-08-01 17:04:11 +02:00
Fabio Ivona	4b24da1a58	Merge pull request #892 from ash-jc-allen/comment-updates Updated comments	2023-08-01 16:35:42 +02:00
Nuno Maduro	72d482de28	docs: update changelog	2023-08-01 14:49:00 +01:00
Nuno Maduro	049da041b2	release: v2.11.0	2023-08-01 14:43:50 +01:00
Nuno Maduro	4d7aa2b98f	Merge pull request #891 from ash-jc-allen/feature/invokable-arch-expectation Add `toBeInvokable` arch expectation	2023-08-01 13:23:05 +00:00
Ash Allen	2e352c0084	Updated comments.	2023-08-01 13:09:53 +01:00
Ash Allen	3f854713e6	Style updates.	2023-08-01 12:12:41 +01:00
Ash Allen	011bd3ba82	Added "toBeInvokable" arch expectation.	2023-08-01 12:09:18 +01:00
Nuno Maduro	4de70da0a0	release: v2.10.1	2023-07-31 11:58:13 +01:00
Nuno Maduro	6820d8b7aa	Merge pull request #888 from pestphp/feat_opposite_suffix_prefix feat(arch): Adds support for opposite expectations of `toHavePrefix` and `toHaveSuffix`	2023-07-31 10:48:58 +00:00
Luke Downing	6886558ed1	feat(arch): Adds support for opposite expectations of `toHavePrefix` and `toHaveSuffix`.	2023-07-31 11:28:53 +01:00
Nuno Maduro	b795a92840	docs: updates changelog	2023-07-31 00:11:24 +01:00
Nuno Maduro	2e622f6fd4	chore: fixes type checkign	2023-07-31 00:06:36 +01:00
Nuno Maduro	5f7a1663dd	release: v2.10.0	2023-07-30 23:52:43 +01:00
Nuno Maduro	f3f35a2ed1	feat: adds `repeat`	2023-07-30 23:49:20 +01:00
Nuno Maduro	86a6b32715	fix: `-v` option	2023-07-30 23:49:11 +01:00
Fabio Ivona	1efb9de043	multiple snapshots	2023-07-27 11:46:22 +02:00
Fabio Ivona	b60d21dfe2	snapshots code cleanup	2023-07-27 11:16:27 +02:00
Fabio Ivona	39e0d61dec	phpstan fix	2023-07-27 11:10:42 +02:00
Nuno Maduro	be41181b43	release: v2.9.5	2023-07-24 19:13:17 +01:00
Nuno Maduro	632ffc2f8e	fix: arch assertions counter	2023-07-24 19:13:09 +01:00
AJ Meireles	b00bc4d5ea	applying enhancement to use single dd function	2023-07-17 19:11:06 -03:00
AJ Meireles	8abc0d1920	applying enhancement to use ddWhen inside ddUnless	2023-07-17 14:12:54 -03:00
AJ Meireles	ea967b439f	Feature: Introducing The Ability to Dump Conditionally	2023-07-17 11:08:00 -03:00