[4.x] Update time and memory thresholds, rename services for consistency

andrey-helldar · andrey-helldar · commit 35b2cc2f255c · 2026-02-14T00:45:13.000+03:00
- Increase time thresholds in assertion tests (`100` -&gt; `1000`, `1000` -&gt; `10000`) and update related exception messages
- Adjust memory thresholds (`100` -&gt; `10000`) in tests and snapshots to reflect higher benchmarks
- Rename `ArrService` to `ArrayService` for naming consistency
- Refactor `filter` logic to delegate to `MeasurementErrorService`
- Enhance sort logic in `MeasurementErrorService` with numeric sorting using `asort`
- Update snapshots for `RoundTest`, `ToConsoleTest`, and other affected tests
diff --git a/src/Services/ArrayService.php b/src/Services/ArrayService.php
@@ -14,7 +14,7 @@
 use function is_array;
 use function usort;
 
-class ArrService
+class ArrayService
 {
     public function get(array $data, string $key): mixed
     {
diff --git a/src/Services/MeasurementErrorService.php b/src/Services/MeasurementErrorService.php
@@ -5,6 +5,7 @@
 namespace DragonCode\Benchmark\Services;
 
 use function array_slice;
+use function asort;
 use function count;
 
 class MeasurementErrorService
@@ -13,20 +14,25 @@ class MeasurementErrorService
 
     protected int $minCount = 10;
 
-    public function __construct(
-        protected ArrService $arr = new ArrService
-    ) {}
-
     public function filter(array $data): array
     {
         $count = $this->count($data);
 
-        return $this->disabled($count) ? $data : $this->partial($data, $count);
+        if ($this->disabled($count)) {
+            return $data;
+        }
+
+        return $this->partial($data, $count);
     }
 
     protected function partial(array $data, int $count): array
     {
-        return array_slice($this->sort($data), $this->take($count), $this->offset($count));
+        return array_slice(
+            array        : $this->sort($data),
+            offset       : $this->offset($count),
+            length       : $this->take($count),
+            preserve_keys: true
+        );
     }
 
     protected function offset(int $count): int
@@ -46,11 +52,13 @@ protected function count(array $values): int
 
     protected function disabled(int $count): bool
     {
-        return $count <= $this->minCount;
+        return $count < $this->minCount;
     }
 
     protected function sort(array $values): array
     {
-        return $this->arr->sort($values);
+        asort($values, SORT_NUMERIC);
+
+        return $values;
     }
 }
diff --git a/src/Services/ResultService.php b/src/Services/ResultService.php
@@ -9,7 +9,6 @@
 
 use function array_column;
 use function array_map;
-use function array_slice;
 use function array_sum;
 use function count;
 use function max;
@@ -19,6 +18,10 @@ class ResultService
 {
     protected ?array $data = null;
 
+    public function __construct(
+        protected MeasurementErrorService $measurement = new MeasurementErrorService,
+    ) {}
+
     /**
      * @return \DragonCode\Benchmark\Data\ResultData[]
      */
@@ -100,18 +103,6 @@ protected function metric(float $time, float $memory): MetricData
 
     protected function filter(array $values): array
     {
-        $count = count($values);
-
-        if ($count < 10) {
-            return $values;
-        }
-
-        $skip = (int) ($count * 0.1);
-
-        return array_slice(
-            array : $values,
-            offset: $skip + 1,
-            length: $count - ($skip - 1) * 2
-        );
+        return $this->measurement->filter($values);
     }
 }
diff --git a/tests/.pest/snapshots/Unit/Result/ToConsoleTest/output.snap b/tests/.pest/snapshots/Unit/Result/ToConsoleTest/output.snap
@@ -1,10 +1,10 @@
-+-------+----------------------------+--------------------------+
-| #     | 0                          | 1                        |
-+-------+----------------------------+--------------------------+
-| min   | 4.56789012 ms - 50 bytes   | 1.23456789 ms - 20 bytes |
-| max   | 6.78901234 ms - 70 bytes   | 3.45678901 ms - 40 bytes |
-| avg   | 5.67860123 ms - 60 bytes   | 2.3456786 ms - 30 bytes  |
-| total | 17.03580369 ms - 182 bytes | 7.0370358 ms - 90 bytes  |
-+-------+----------------------------+--------------------------+
-| order | 2                          | 1                        |
-+-------+----------------------------+--------------------------+
++-------+-------------------------------+------------------------------+
+| #     | 0                             | 1                            |
++-------+-------------------------------+------------------------------+
+| min   | 15.67890123 ms - 202 bytes    | 2.3456789 ms - 102 bytes     |
+| max   | 112.78901234 ms - 209 bytes   | 9.75678901 ms - 109 bytes    |
+| avg   | 53.02524845125 ms - 205 bytes | 5.94290024625 ms - 105 bytes |
+| total | 424.20198761 ms - 1.61 KB     | 47.54320197 ms - 844 bytes   |
++-------+-------------------------------+------------------------------+
+| order | 2                             | 1                            |
++-------+-------------------------------+------------------------------+
diff --git a/tests/.pest/snapshots/Unit/Round/RoundTest/default.snap b/tests/.pest/snapshots/Unit/Round/RoundTest/default.snap
@@ -1,10 +1,10 @@
-+-------+----------------------------+--------------------------+
-| #     | 0                          | 1                        |
-+-------+----------------------------+--------------------------+
-| min   | 4.56789012 ms - 50 bytes   | 1.23456789 ms - 20 bytes |
-| max   | 6.78901234 ms - 70 bytes   | 3.45678901 ms - 40 bytes |
-| avg   | 5.67860123 ms - 60 bytes   | 2.3456786 ms - 30 bytes  |
-| total | 17.03580369 ms - 182 bytes | 7.0370358 ms - 90 bytes  |
-+-------+----------------------------+--------------------------+
-| order | 2                          | 1                        |
-+-------+----------------------------+--------------------------+
++-------+-------------------------------+------------------------------+
+| #     | 0                             | 1                            |
++-------+-------------------------------+------------------------------+
+| min   | 15.67890123 ms - 202 bytes    | 2.3456789 ms - 102 bytes     |
+| max   | 112.78901234 ms - 209 bytes   | 9.75678901 ms - 109 bytes    |
+| avg   | 53.02524845125 ms - 205 bytes | 5.94290024625 ms - 105 bytes |
+| total | 424.20198761 ms - 1.61 KB     | 47.54320197 ms - 844 bytes   |
++-------+-------------------------------+------------------------------+
+| order | 2                             | 1                            |
++-------+-------------------------------+------------------------------+
diff --git a/tests/.pest/snapshots/Unit/Round/RoundTest/round_with_data_set___0__.snap b/tests/.pest/snapshots/Unit/Round/RoundTest/round_with_data_set___0__.snap
@@ -1,10 +1,10 @@
-+-------+-------------------+-----------------+
-| #     | 0                 | 1               |
-+-------+-------------------+-----------------+
-| min   | 5 ms - 50 bytes   | 1 ms - 20 bytes |
-| max   | 7 ms - 70 bytes   | 3 ms - 40 bytes |
-| avg   | 6 ms - 60 bytes   | 2 ms - 30 bytes |
-| total | 17 ms - 182 bytes | 7 ms - 90 bytes |
-+-------+-------------------+-----------------+
-| order | 2                 | 1               |
-+-------+-------------------+-----------------+
++-------+--------------------+-------------------+
+| #     | 0                  | 1                 |
++-------+--------------------+-------------------+
+| min   | 16 ms - 202 bytes  | 2 ms - 102 bytes  |
+| max   | 113 ms - 209 bytes | 10 ms - 109 bytes |
+| avg   | 53 ms - 205 bytes  | 6 ms - 105 bytes  |
+| total | 424 ms - 1.61 KB   | 48 ms - 844 bytes |
++-------+--------------------+-------------------+
+| order | 2                  | 1                 |
++-------+--------------------+-------------------+
diff --git a/tests/.pest/snapshots/Unit/Round/RoundTest/round_with_data_set___2__.snap b/tests/.pest/snapshots/Unit/Round/RoundTest/round_with_data_set___2__.snap
@@ -1,10 +1,10 @@
-+-------+----------------------+--------------------+
-| #     | 0                    | 1                  |
-+-------+----------------------+--------------------+
-| min   | 4.57 ms - 50 bytes   | 1.23 ms - 20 bytes |
-| max   | 6.79 ms - 70 bytes   | 3.46 ms - 40 bytes |
-| avg   | 5.68 ms - 60 bytes   | 2.35 ms - 30 bytes |
-| total | 17.04 ms - 182 bytes | 7.04 ms - 90 bytes |
-+-------+----------------------+--------------------+
-| order | 2                    | 1                  |
-+-------+----------------------+--------------------+
++-------+-----------------------+----------------------+
+| #     | 0                     | 1                    |
++-------+-----------------------+----------------------+
+| min   | 15.68 ms - 202 bytes  | 2.35 ms - 102 bytes  |
+| max   | 112.79 ms - 209 bytes | 9.76 ms - 109 bytes  |
+| avg   | 53.03 ms - 205 bytes  | 5.94 ms - 105 bytes  |
+| total | 424.2 ms - 1.61 KB    | 47.54 ms - 844 bytes |
++-------+-----------------------+----------------------+
+| order | 2                     | 1                    |
++-------+-----------------------+----------------------+
diff --git a/tests/.pest/snapshots/Unit/Round/RoundTest/round_with_data_set___5__.snap b/tests/.pest/snapshots/Unit/Round/RoundTest/round_with_data_set___5__.snap
@@ -1,10 +1,10 @@
-+-------+------------------------+-----------------------+
-| #     | 0                      | 1                     |
-+-------+------------------------+-----------------------+
-| min   | 4.56789 ms - 50 bytes  | 1.23457 ms - 20 bytes |
-| max   | 6.78901 ms - 70 bytes  | 3.45679 ms - 40 bytes |
-| avg   | 5.6786 ms - 60 bytes   | 2.34568 ms - 30 bytes |
-| total | 17.0358 ms - 182 bytes | 7.03704 ms - 90 bytes |
-+-------+------------------------+-----------------------+
-| order | 2                      | 1                     |
-+-------+------------------------+-----------------------+
++-------+--------------------------+------------------------+
+| #     | 0                        | 1                      |
++-------+--------------------------+------------------------+
+| min   | 15.6789 ms - 202 bytes   | 2.34568 ms - 102 bytes |
+| max   | 112.78901 ms - 209 bytes | 9.75679 ms - 109 bytes |
+| avg   | 53.02525 ms - 205 bytes  | 5.9429 ms - 105 bytes  |
+| total | 424.20199 ms - 1.61 KB   | 47.5432 ms - 844 bytes |
++-------+--------------------------+------------------------+
+| order | 2                        | 1                      |
++-------+--------------------------+------------------------+
diff --git a/tests/Fixtures/CollectorFixture.php b/tests/Fixtures/CollectorFixture.php
@@ -12,14 +12,28 @@ public function all(): array
     {
         return [
             [
-                [4.56789012, 50.67890],
-                [5.67890123, 60.78901],
-                [6.78901234, 70.89012],
+                [14.56789012, 201],
+                [15.67890123, 202],
+                [16.78901234, 203],
+                [17.78901234, 204],
+                [18.78901234, 205],
+                [19.78901234, 206],
+                [110.78901234, 207],
+                [111.78901234, 208],
+                [112.78901234, 209],
+                [113.78901234, 210],
             ],
             [
-                [1.23456789, 20.12345],
-                [2.34567890, 30.23456],
-                [3.45678901, 40.34567],
+                [1.23456789, 101],
+                [2.34567890, 102],
+                [3.15678901, 103],
+                [4.25678901, 104],
+                [5.35678901, 105],
+                [6.45678901, 106],
+                [7.55678901, 107],
+                [8.65678901, 108],
+                [9.75678901, 109],
+                [10.85678901, 110],
             ],
         ];
     }
diff --git a/tests/Unit/Assertions/ToBeAvgMemoryTest.php b/tests/Unit/Assertions/ToBeAvgMemoryTest.php
@@ -5,7 +5,7 @@
 test('success', function () {
     benchmark()
         ->assert()
-        ->toBeAvgMemory(1, 100);
+        ->toBeAvgMemory(1, 10000);
 
     expect(true)->toBeTrue();
 });
@@ -21,8 +21,8 @@
 test('failure less than', function () {
     benchmark()
         ->assert()
-        ->toBeAvgMemory(from: 100);
-})->throws(AssertionError::class, 'The average memory value must be greater than or equal to 100.');
+        ->toBeAvgMemory(from: 10000);
+})->throws(AssertionError::class, 'The average memory value must be greater than or equal to 10000.');
 
 test('failure greater than', function () {
     benchmark()
diff --git a/tests/Unit/Assertions/ToBeAvgTimeTest.php b/tests/Unit/Assertions/ToBeAvgTimeTest.php
@@ -5,7 +5,7 @@
 test('success', function () {
     benchmark()
         ->assert()
-        ->toBeAvgTime(1, 100);
+        ->toBeAvgTime(1, 1000);
 
     expect(true)->toBeTrue();
 });
@@ -21,8 +21,8 @@
 test('failure less than', function () {
     benchmark()
         ->assert()
-        ->toBeAvgTime(from: 100);
-})->throws(AssertionError::class, 'The average time value must be greater than or equal to 100.');
+        ->toBeAvgTime(from: 1000);
+})->throws(AssertionError::class, 'The average time value must be greater than or equal to 1000.');
 
 test('failure greater than', function () {
     benchmark()
diff --git a/tests/Unit/Assertions/ToBeMaxMemoryTest.php b/tests/Unit/Assertions/ToBeMaxMemoryTest.php
@@ -5,7 +5,7 @@
 test('success', function () {
     benchmark()
         ->assert()
-        ->toBeMaxMemory(1, 100);
+        ->toBeMaxMemory(1, 10000);
 
     expect(true)->toBeTrue();
 });
@@ -21,8 +21,8 @@
 test('failure less than', function () {
     benchmark()
         ->assert()
-        ->toBeMaxMemory(from: 100);
-})->throws(AssertionError::class, 'The maximum memory value must be greater than or equal to 100.');
+        ->toBeMaxMemory(from: 10000);
+})->throws(AssertionError::class, 'The maximum memory value must be greater than or equal to 10000.');
 
 test('failure greater than', function () {
     benchmark()
diff --git a/tests/Unit/Assertions/ToBeMaxTimeTest.php b/tests/Unit/Assertions/ToBeMaxTimeTest.php
@@ -5,7 +5,7 @@
 test('success', function () {
     benchmark()
         ->assert()
-        ->toBeMaxTime(1, 100);
+        ->toBeMaxTime(1, 1000);
 
     expect(true)->toBeTrue();
 });
@@ -21,8 +21,8 @@
 test('failure less than', function () {
     benchmark()
         ->assert()
-        ->toBeMaxTime(from: 100);
-})->throws(AssertionError::class, 'The maximum time value must be greater than or equal to 100.');
+        ->toBeMaxTime(from: 1000);
+})->throws(AssertionError::class, 'The maximum time value must be greater than or equal to 1000.');
 
 test('failure greater than', function () {
     benchmark()
diff --git a/tests/Unit/Assertions/ToBeMinMemoryTest.php b/tests/Unit/Assertions/ToBeMinMemoryTest.php
@@ -5,7 +5,7 @@
 test('success', function () {
     benchmark()
         ->assert()
-        ->toBeMinMemory(1, 100);
+        ->toBeMinMemory(1, 10000);
 
     expect(true)->toBeTrue();
 });
@@ -21,8 +21,8 @@
 test('failure less than', function () {
     benchmark()
         ->assert()
-        ->toBeMinMemory(from: 100);
-})->throws(AssertionError::class, 'The minimum memory value must be greater than or equal to 100.');
+        ->toBeMinMemory(from: 10000);
+})->throws(AssertionError::class, 'The minimum memory value must be greater than or equal to 10000.');
 
 test('failure greater than', function () {
     benchmark()
diff --git a/tests/Unit/Assertions/ToBeMinTimeTest.php b/tests/Unit/Assertions/ToBeMinTimeTest.php
@@ -5,7 +5,7 @@
 test('success', function () {
     benchmark()
         ->assert()
-        ->toBeMinTime(1, 100);
+        ->toBeMinTime(1, 1000);
 
     expect(true)->toBeTrue();
 });
@@ -21,8 +21,8 @@
 test('failure less than', function () {
     benchmark()
         ->assert()
-        ->toBeMinTime(from: 100);
-})->throws(AssertionError::class, 'The minimum time value must be greater than or equal to 100.');
+        ->toBeMinTime(from: 1000);
+})->throws(AssertionError::class, 'The minimum time value must be greater than or equal to 1000.');
 
 test('failure greater than', function () {
     benchmark()
diff --git a/tests/Unit/Assertions/ToBeTotalMemoryTest.php b/tests/Unit/Assertions/ToBeTotalMemoryTest.php
@@ -5,7 +5,7 @@
 test('success', function () {
     benchmark()
         ->assert()
-        ->toBeTotalMemory(1, 1000);
+        ->toBeTotalMemory(1, 10000);
 
     expect(true)->toBeTrue();
 });
@@ -21,8 +21,8 @@
 test('failure less than', function () {
     benchmark()
         ->assert()
-        ->toBeTotalMemory(from: 1000);
-})->throws(AssertionError::class, 'The total memory value must be greater than or equal to 1000.');
+        ->toBeTotalMemory(from: 10000);
+})->throws(AssertionError::class, 'The total memory value must be greater than or equal to 10000.');
 
 test('failure greater than', function () {
     benchmark()
diff --git a/tests/Unit/Result/ToDataTest.php b/tests/Unit/Result/ToDataTest.php

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@`
`14`	`14`	`use function is_array;`
`15`	`15`	`use function usort;`
`16`	`16`
`17`		`-class ArrService`
	`17`	`+class ArrayService`
`18`	`18`	`{`
`19`	`19`	`public function get(array $data, string $key): mixed`
`20`	`20`	`{`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`namespace DragonCode\Benchmark\Services;`
`6`	`6`
`7`	`7`	`use function array_slice;`
	`8`	`+use function asort;`
`8`	`9`	`use function count;`
`9`	`10`
`10`	`11`	`class MeasurementErrorService`
`@@ -13,20 +14,25 @@ class MeasurementErrorService`
`13`	`14`
`14`	`15`	`protected int $minCount = 10;`
`15`	`16`
`16`		`- public function __construct(`
`17`		`- protected ArrService $arr = new ArrService`
`18`		`- ) {}`
`19`		`-`
`20`	`17`	`public function filter(array $data): array`
`21`	`18`	`{`
`22`	`19`	`$count = $this->count($data);`
`23`	`20`
`24`		`- return $this->disabled($count) ? $data : $this->partial($data, $count);`
	`21`	`+ if ($this->disabled($count)) {`
	`22`	`+ return $data;`
	`23`	`+ }`
	`24`	`+`
	`25`	`+ return $this->partial($data, $count);`
`25`	`26`	`}`
`26`	`27`
`27`	`28`	`protected function partial(array $data, int $count): array`
`28`	`29`	`{`
`29`		`- return array_slice($this->sort($data), $this->take($count), $this->offset($count));`
	`30`	`+ return array_slice(`
	`31`	`+ array : $this->sort($data),`
	`32`	`+ offset : $this->offset($count),`
	`33`	`+ length : $this->take($count),`
	`34`	`+ preserve_keys: true`
	`35`	`+ );`
`30`	`36`	`}`
`31`	`37`
`32`	`38`	`protected function offset(int $count): int`
`@@ -46,11 +52,13 @@ protected function count(array $values): int`
`46`	`52`
`47`	`53`	`protected function disabled(int $count): bool`
`48`	`54`	`{`
`49`		`- return $count <= $this->minCount;`
	`55`	`+ return $count < $this->minCount;`
`50`	`56`	`}`
`51`	`57`
`52`	`58`	`protected function sort(array $values): array`
`53`	`59`	`{`
`54`		`- return $this->arr->sort($values);`
	`60`	`+ asort($values, SORT_NUMERIC);`
	`61`	`+`
	`62`	`+ return $values;`
`55`	`63`	`}`
`56`	`64`	`}`