Merge remote-tracking branch 'origin/master' into add-new-ci-option-to-pest-bin

# Conflicts:
#	tests/.snapshots/success.txt

src/Expectation.php

@@ -154,9 +154,10 @@ 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);
+        $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;
 
@@ -165,6 +166,10 @@ final class Expectation
             $index       = $index < count($values) - 1 ? $index + 1 : 0;
         }
 
+        if ($callbacksCount > count($values)) {
+            Assert::assertLessThanOrEqual(count($value), count($callbacks));
+        }
+
         foreach ($values as $key => $item) {
             if (is_callable($callbacks[$key])) {
                 call_user_func($callbacks[$key], new self($item), new self($keys[$key]));
@@ -177,6 +182,88 @@ final class Expectation
         return $this;
     }
 
+    /**
+     * If the subject matches one of the given "expressions", the expression callback will run.
+     *
+     * @template TMatchSubject of array-key
+     *
+     * @param callable(): TMatchSubject|TMatchSubject $subject
+     * @param array<TMatchSubject, (callable(Expectation<TValue>): mixed)|TValue> $expressions
+     */
+    public function match($subject, array $expressions): Expectation
+    {
+        $subject = is_callable($subject)
+            ? $subject
+            : function () use ($subject) {
+                return $subject;
+            };
+
+        $subject   = $subject();
+
+        $matched = false;
+
+        foreach ($expressions as $key => $callback) {
+            if ($subject != $key) {
+                continue;
+            }
+
+            $matched = true;
+
+            if (is_callable($callback)) {
+                $callback(new self($this->value));
+                continue;
+            }
+
+            $this->and($this->value)->toEqual($callback);
+
+            break;
+        }
+
+        if ($matched === false) {
+            throw new ExpectationFailedException('Unhandled match value.');
+        }
+
+        return $this;
+    }
+
+    /**
+     * Apply the callback if the given "condition" is falsy.
+     *
+     * @param  (callable(): bool)|bool $condition
+     * @param callable(Expectation<TValue>): mixed $callback
+     */
+    public function unless($condition, callable $callback): Expectation
+    {
+        $condition = is_callable($condition)
+            ? $condition
+            : static function () use ($condition): mixed {
+                return $condition;
+            };
+
+        return $this->when(!$condition(), $callback);
+    }
+
+    /**
+     * Apply the callback if the given "condition" is truthy.
+     *
+     * @param  (callable(): bool)|bool $condition
+     * @param callable(Expectation<TValue>): mixed $callback
+     */
+    public function when($condition, callable $callback): Expectation
+    {
+        $condition = is_callable($condition)
+            ? $condition
+            : static function () use ($condition): mixed {
+                return $condition;
+            };
+
+        if ($condition()) {
+            $callback($this->and($this->value));
+        }
+
+        return $this;
+    }
+
     /**
      * Asserts that two variables have the same type and
      * value. Used on objects, it asserts that two

src/PendingObjects/TestCall.php

@@ -78,6 +78,26 @@ final class TestCall
         return $this;
     }
 
+    /**
+     * Asserts that the test throws the given `$exceptionClass` when called if the given condition is true.
+     *
+     * @param (callable(): bool)|bool $condition
+     */
+    public function throwsIf($condition, string $exception, string $exceptionMessage = null): TestCall
+    {
+        $condition = is_callable($condition)
+            ? $condition
+            : static function () use ($condition): mixed {
+                return $condition;
+            };
+
+        if ($condition()) {
+            return $this->throws($exception, $exceptionMessage);
+        }
+
+        return $this;
+    }
+
     /**
      * Runs the current test multiple times with
      * each item of the given `iterable`.