Merge pull request #7 from TheDragonCode/2.x

Added `prepare` method

Author: andrey-helldar

README.md

@@ -192,6 +192,35 @@ Result example:
  ------- ------------------ ------------------ 
 ```
 
+### Prepare Data
+
+In some cases, it becomes necessary to call some action before starting each check cycle so that its time does not fall into the result of the runtime check.
+There is a `prepare` method for this:
+
+```php
+use DragonCode\Benchmark\Benchmark;
+
+(new Benchmark())
+    ->prepare(fn () => /* some code */)
+    ->compare(
+        fn () => /* some code */,
+        fn () => /* some code */,
+    );
+```
+
+When calling a callback, the name and iteration parameters are passed to it. If necessary, you can use this information inside the callback function.
+
+```php
+use DragonCode\Benchmark\Benchmark;
+
+(new Benchmark())
+    ->prepare(fn (mixed $name, int $iteration) => /* some code */)
+    ->compare(
+        fn () => /* some code */,
+        fn () => /* some code */,
+    );
+```
+
 ## Information
 
 ```

src/Benchmark.php

@@ -4,6 +4,7 @@
 
 namespace DragonCode\Benchmark;
 
+use Closure;
 use DragonCode\Benchmark\Exceptions\ValueIsNotCallableException;
 use DragonCode\Benchmark\Services\Runner;
 use DragonCode\Benchmark\Services\View;
@@ -21,6 +22,8 @@ class Benchmark
 
     protected bool $withData = true;
 
+    protected ?Closure $prepare = null;
+
     protected array $result = [
         'each'  => [],
         'total' => [],
@@ -36,6 +39,13 @@ public function __construct(
         ));
     }
 
+    public function prepare(callable $callback): self
+    {
+        $this->prepare = $callback;
+
+        return $this;
+    }
+
     public function iterations(int $count): self
     {
         $this->iterations = max(1, $count);
@@ -99,6 +109,8 @@ protected function each(mixed $name, callable $callback, ProgressBarService $pro
     protected function run(mixed $name, callable $callback, ProgressBarService $progressBar): void
     {
         for ($i = 1; $i <= $this->iterations; ++$i) {
+            $this->runPrepare($name, $i);
+
             [$time, $ram] = $this->call($callback);
 
             $this->push($name, $i, $time, $ram);
@@ -107,9 +119,16 @@ protected function run(mixed $name, callable $callback, ProgressBarService $prog
         }
     }
 
-    protected function call(callable $callback): array
+    protected function runPrepare(mixed $name, int $iteration): void
+    {
+        if ($callback = $this->prepare) {
+            $this->call($callback, [$name, $iteration]);
+        }
+    }
+
+    protected function call(callable $callback, array $parameters = []): array
     {
-        return $this->runner->call($callback);
+        return $this->runner->call($callback, $parameters);
     }
 
     protected function push(mixed $name, int $iteration, float $time, float $ram): void

src/Services/Runner.php

@@ -11,24 +11,24 @@ public function __construct(
     ) {
     }
 
-    public function call(callable $callback): array
+    public function call(callable $callback, array $parameters = []): array
     {
         $this->clean();
 
-        return $this->run($callback);
+        return $this->run($callback, $parameters);
     }
 
     protected function clean(): void
     {
         gc_collect_cycles();
     }
 
-    protected function run(callable $callback): array
+    protected function run(callable $callback, array $parameters = []): array
     {
         $ramFrom = $this->memory->now();
         $startAt = hrtime(true);
 
-        $callback();
+        $callback(...$parameters);
 
         $time = $this->diff(hrtime(true), $startAt);
         $ram  = $this->memory->diff($ramFrom);

tests/Benchmark/PrepareTest.php

@@ -0,0 +1,82 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Benchmark;
+
+use Tests\TestCase;
+
+class PrepareTest extends TestCase
+{
+    public function testCallback(): void
+    {
+        $result = [];
+
+        $this->benchmark()
+            ->iterations(3)
+            ->withoutData()
+            ->prepare(function () use (&$result) {
+                $result[] = 1;
+            })
+            ->compare([
+                'foo' => fn () => $this->work(),
+                'bar' => fn () => $this->work(),
+            ]);
+
+        $this->assertSame(6, count($result));
+    }
+
+    public function testParameters(): void
+    {
+        $result = [];
+
+        $this->benchmark()
+            ->iterations(3)
+            ->withoutData()
+            ->prepare(function (mixed $name, int $iteration) use (&$result) {
+                $result[] = sprintf('%s:%d', $name, $iteration);
+            })
+            ->compare([
+                'foo' => fn () => $this->work(),
+                'bar' => fn () => $this->work(),
+            ]);
+
+        $this->assertSame(6, count($result));
+
+        $this->assertSame([
+            'foo:1',
+            'foo:2',
+            'foo:3',
+            'bar:1',
+            'bar:2',
+            'bar:3',
+        ], $result);
+    }
+
+    public function testName(): void
+    {
+        $result = [];
+
+        $this->benchmark()
+            ->iterations(3)
+            ->withoutData()
+            ->prepare(function (mixed $name) use (&$result) {
+                $result[] = $name;
+            })
+            ->compare([
+                'foo' => fn () => $this->work(),
+                'bar' => fn () => $this->work(),
+            ]);
+
+        $this->assertSame(6, count($result));
+
+        $this->assertSame([
+            'foo',
+            'foo',
+            'foo',
+            'bar',
+            'bar',
+            'bar',
+        ], $result);
+    }
+}