Merge pull request #21 from Katalam/prod-of

Add product of expectation

Author: faissaloux

README.md

@@ -108,3 +108,16 @@ $$\sum\limits_n^k x * 2$$
     expect(2)->toBeSummationOf(fn (int $x) => $x * 2, from: 0, to: 1);
     expect(3)->not->toBeSummationOf(fn (int $x) => $x * 2, from: 0, to: 1);
 ```
+
+#### `toBeProdOf()`
+```php
+    expect(6)->toBeProdOf([1, 2, 3]);
+    expect(4)->not->toBeProdOf([2, 3]);
+```
+
+#### `toBeProductOf()`
+$$\prod\limits_n^k x * 2$$
+```php
+    expect(3715891200)->toBeProductOf(fn (int $x) => $x * 2, from: 1, to: 10);
+    expect(1)->not->toBeProductOf(fn (int $x) => $x * 2, from: 1, to: 10);
+```

src/Expectation.php

@@ -196,4 +196,41 @@ public function toBeSummationOf(callable $step, int $from, int $to): PestExpecta
 
         return expect($this->value === $sum)->toBeTrue("$this->value doesn't equal $sum");
     }
+
+    /**
+     * @param  array<int|float>  $numbers
+     * @return PestExpectation<TValue>
+     */
+    public function toBeProdOf(array $numbers): PestExpectation
+    {
+        if ($numbers === []) {
+            return expect($this->value === 0)->toBeTrue("$this->value doesn't equal 0");
+        }
+
+        $prod = 1;
+
+        foreach ($numbers as $number) {
+            expect($number)->toBeNumeric();
+
+            $prod *= $number;
+        }
+
+        return expect($this->value === $prod)->toBeTrue("$this->value doesn't equal $prod");
+    }
+
+    /**
+     * @return PestExpectation<TValue>
+     */
+    public function toBeProductOf(callable $step, int $from, int $to): PestExpectation
+    {
+        $product = 1;
+
+        foreach (range($from, $to) as $i) {
+            $stepProd = $step($i);
+            expect($stepProd)->toBeNumeric();
+            $product *= $stepProd;
+        }
+
+        return expect($this->value === $product)->toBeTrue("$this->value !== $product");
+    }
 }

tests/toBeProdOf.php

@@ -0,0 +1,40 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+it('passes', function (int $prod, array $numbers): void {
+    expect($prod)->toBeProdOf($numbers);
+})->with([
+    [0, []],
+    [0, [-1, 0, 1]],
+    [36, [3, '3', 4]],
+    [1024, [4, 4, 4, 4, 4]],
+    [1680, [-4, -30, 14]],
+    [15625, [5, 5, 5, 5, 5, 5]],
+    [186624, [6, 6, 6, 6, 6, 6, 4]],
+    [823543, [7, 7, 7, 7, 7, 7, 7, 1]],
+    [134217728, [8, 8, 8, 8, 8, 8, 8, 8, 8]],
+    [2711943423, [9, 9, 9, 9, 9, 9, 9, 9, 9, 7]],
+    [100000000000, [10, 10, 10, 10, 10, 10, '10', 10, 10, 10, 10]],
+]);
+
+it('passes not', function (array $numbers): void {
+    expect(1)->not->toBeProdOf($numbers);
+})->with([
+    [[2, 3]],
+    [[1, 2, 3]],
+    [[1, 2, 3, 4]],
+    [[1, 2, 3, 4, 5]],
+]);
+
+it('fails if not number on the list', function (): void {
+    expect(0)->toBeProdOf([2, 1, 3, 'not number', 78, 99]);
+})->throws(ExpectationFailedException::class);
+
+test('failures', function (): void {
+    expect(1)->toBeProdOf([1, 2]);
+})->throws(ExpectationFailedException::class);
+
+test('failures not', function (): void {
+    expect(2)->not->toBeProdOf([2]);
+})->throws(ExpectationFailedException::class);

tests/toBeProductOf.php

@@ -0,0 +1,34 @@
+<?php
+
+use PHPUnit\Framework\ExpectationFailedException;
+
+it('passes', function (int $prod, int $from, int $to, callable $step): void {
+    expect($prod)->toBeProductOf($step, $from, $to);
+})->with([
+    [0, -1, 0, fn (int $i): int => $i * 2],
+    [0, 0, 0, fn (int $i): int => $i * 2],
+    [3715891200, 1, 10, fn (int $i): int => $i * 2],
+    [3715891200, 10, 1, fn (int $i): int => $i * 2],
+    [362880, 2, 10, function (int $i): int {
+        return $i - 1;
+    }],
+]);
+
+it('passes not', function (callable $step, int $from, int $to): void {
+    expect(1)->not->toBeProductOf($step, $from, $to);
+})->with([
+    [fn (int $i): int => $i * 2, 1, 10],
+    [fn (int $i): int => $i * 2, 2, 20],
+]);
+
+it('fails if step does not return a number', function (): void {
+    expect(0)->toBeProductOf(fn (): string => 'not number', 0, 0);
+})->throws(ExpectationFailedException::class);
+
+test('failures', function (): void {
+    expect(1)->toBeProductOf(fn (int $i): int => $i * 2, 0, 1);
+})->throws(ExpectationFailedException::class);
+
+test('failures not', function (): void {
+    expect(2)->not->toBeProductOf(fn (int $i): int => $i * 2, 1, 1);
+})->throws(ExpectationFailedException::class);