- {% if stats|length > 0 %}
-
-
Vue d'ensemble des benchmarks
-
Nombre total de benchmarks: {{ stats|length }}
-
Versions PHP comparées: {{ allPhpVersions|join(', ') }}
-
-
- {% for benchmarkKey, benchmark in stats %}
-
-
-
-
{{ benchmark.name }} ({{ benchmark.benchId }})
-
-
- Afficher/Masquer le graphique
-
-
- ms/ns
-
-
-
-
-
- {{ render_chart(benchmark.chart) }}
-
-
-
-
-
-
- Échantillons
- {% for version in allPhpVersions %}
-
- {% if benchmark.phpVersions[version] is defined %}
- {{ benchmark.phpVersions[version].count }}
- {% else %}
- -
- {% endif %}
-
- {% endfor %}
-
-
- p50 (ms)
- {% set best_p50 = 999999 %}
- {% for version in allPhpVersions %}
- {% if benchmark.phpVersions[version] is defined and benchmark.phpVersions[version].p50 < best_p50 %}
- {% set best_p50 = benchmark.phpVersions[version].p50 %}
- {% endif %}
- {% endfor %}
-
- {% for version in allPhpVersions %}
-
- {% if benchmark.phpVersions[version] is defined %}
- {{ benchmark.phpVersions[version].p50|number_format(5) }}
- {% else %}
- -
- {% endif %}
-
- {% endfor %}
-
-
- p80 (ms)
- {% set best_p80 = 999999 %}
- {% for version in allPhpVersions %}
- {% if benchmark.phpVersions[version] is defined and benchmark.phpVersions[version].p80 < best_p80 %}
- {% set best_p80 = benchmark.phpVersions[version].p80 %}
- {% endif %}
- {% endfor %}
-
- {% for version in allPhpVersions %}
-
- {% if benchmark.phpVersions[version] is defined %}
- {{ benchmark.phpVersions[version].p80|number_format(5) }}
- {% else %}
- -
- {% endif %}
-
- {% endfor %}
-
-
- p90 (ms)
- {% set best_p90 = 999999 %}
- {% for version in allPhpVersions %}
- {% if benchmark.phpVersions[version] is defined and benchmark.phpVersions[version].p90 < best_p90 %}
- {% set best_p90 = benchmark.phpVersions[version].p90 %}
- {% endif %}
- {% endfor %}
+ PHP Performance Benchmarks
- {% for version in allPhpVersions %}
-
- {% if benchmark.phpVersions[version] is defined %}
- {{ benchmark.phpVersions[version].p90|number_format(5) }}
- {% else %}
- -
- {% endif %}
-
- {% endfor %}
-
-
- p95 (ms)
- {% set best_p95 = 999999 %}
- {% for version in allPhpVersions %}
- {% if benchmark.phpVersions[version] is defined and benchmark.phpVersions[version].p95 < best_p95 %}
- {% set best_p95 = benchmark.phpVersions[version].p95 %}
- {% endif %}
- {% endfor %}
-
- {% for version in allPhpVersions %}
-
- {% if benchmark.phpVersions[version] is defined %}
- {{ benchmark.phpVersions[version].p95|number_format(5) }}
- {% else %}
- -
- {% endif %}
-
- {% endfor %}
-
-
- p99 (ms)
- {% set best_p99 = 999999 %}
- {% for version in allPhpVersions %}
- {% if benchmark.phpVersions[version] is defined and benchmark.phpVersions[version].p99 < best_p99 %}
- {% set best_p99 = benchmark.phpVersions[version].p99 %}
- {% endif %}
- {% endfor %}
+ {# Statistics Overview #}
+
+
+
📦
+
+
{{ stats.totalBenchmarks }}
+
Available Benchmarks
+
+
+
+
🚀
+
+
{{ stats.phpVersionsTested }}
+
PHP Versions
+
+
+
+
✅
+
+
{{ stats.benchmarksExecuted }}
+
Benchmarks Executed
+
+
+
+
⚡
+
+
{{ stats.totalExecutions }}
+
Total Test Runs
+
+
+
- {% if benchmark.phpVersions[version] is defined %}
- {{ benchmark.phpVersions[version].p99|number_format(5) }}
- {% else %}
- -
- {% endif %}
-
- {% endfor %}
-
-
- Moyenne (ms)
- {% set best_avg = 999999 %}
- {% for version in allPhpVersions %}
- {% if benchmark.phpVersions[version] is defined and benchmark.phpVersions[version].avg < best_avg %}
- {% set best_avg = benchmark.phpVersions[version].avg %}
- {% endif %}
- {% endfor %}
+ {# Filter and Sort Section #}
+
+
+ {# Search Bar #}
+
+
+ 🔍
+
+
+ ✕ Reset
+
+
- {% for version in allPhpVersions %}
-
- {% if benchmark.phpVersions[version] is defined %}
- {{ benchmark.phpVersions[version].avg|number_format(5) }}
- {% else %}
- -
- {% endif %}
-
- {% endfor %}
-
-
- Mémoire utilisée (Mo)
- {% set best_memory = 999999999999 %}
- {% for version in allPhpVersions %}
- {% if benchmark.phpVersions[version] is defined and benchmark.phpVersions[version].memoryUsed < best_memory %}
- {% set best_memory = benchmark.phpVersions[version].memoryUsed %}
- {% endif %}
- {% endfor %}
+ {# Sort and Filter Buttons #}
+
+
+ Sort by:
+
+ Name ↑
+
+
+ Category ↕
+
+
- {% for version in allPhpVersions %}
-
- {% if benchmark.phpVersions[version] is defined %}
- {{ (benchmark.phpVersions[version].memoryUsed / 1024 / 1024)|number_format(2) }}
- {% else %}
- -
- {% endif %}
-
- {% endfor %}
-
-
- Pic de mémoire (Mo)
- {% set best_memory_peak = 999999999999 %}
- {% for version in allPhpVersions %}
- {% if benchmark.phpVersions[version] is defined and benchmark.phpVersions[version].memoryPeak < best_memory_peak %}
- {% set best_memory_peak = benchmark.phpVersions[version].memoryPeak %}
- {% endif %}
- {% endfor %}
+
+ Category:
+
+ All
+
+ {% for category in top_categories %}
+
+ {{ category }}
+
+ {% endfor %}
+
+
- {% for version in allPhpVersions %}
-
- {% if benchmark.phpVersions[version] is defined %}
- {{ (benchmark.phpVersions[version].memoryPeak / 1024 / 1024)|number_format(2) }}
- {% else %}
- -
- {% endif %}
-
- {% endfor %}
-
-
-
+ {# Stats #}
+
+
Loading...
+
+ {# Global Unit Switch - Compact pill-shaped toggle #}
+
+
+ ms
+
+
+ ns
+
- {% endfor %}
- {% else %}
-
-
Aucune donnée de performance disponible.
- {% endif %}
+
+
+ {# Benchmark Cards Container #}
+
+
+
+ {# No Results Message #}
+
+
🔍
+
No benchmarks found
+
+ Try modifying your search criteria or reset the filters.
+
+
+
{% endblock %}
diff --git a/tests/Unit/Application/Dashboard/DTO/BenchmarkStatisticsDataTest.php b/tests/Unit/Application/Dashboard/DTO/BenchmarkStatisticsDataTest.php
new file mode 100644
index 0000000..72c9518
--- /dev/null
+++ b/tests/Unit/Application/Dashboard/DTO/BenchmarkStatisticsDataTest.php
@@ -0,0 +1,153 @@
+benchmarkId);
+ self::assertSame('Test Benchmark', $dto->benchmarkName);
+ self::assertSame('php84', $dto->phpVersion);
+ self::assertSame(100, $dto->count);
+ self::assertSame(1.8, $dto->avg);
+ self::assertSame($percentiles, $dto->percentiles);
+ self::assertSame(1024.5, $dto->memoryUsed);
+ self::assertSame(2048.0, $dto->memoryPeak);
+ self::assertSame(1.5, $dto->getP50());
+ self::assertSame(2.0, $dto->getP80());
+ self::assertSame(2.5, $dto->getP90());
+ self::assertSame(3.0, $dto->getP95());
+ self::assertSame(4.0, $dto->getP99());
+ }
+
+ public function testPercentilesAreAccessibleViaGetters(): void
+ {
+ // Arrange
+ $percentiles = new PercentileMetrics(
+ p50: 1.5,
+ p80: 2.0,
+ p90: 2.5,
+ p95: 3.0,
+ p99: 4.0,
+ );
+
+ $dto = new BenchmarkStatisticsData(
+ benchmarkId: 'test',
+ benchmarkName: 'Test',
+ phpVersion: 'php84',
+ count: 100,
+ avg: 1.8,
+ percentiles: $percentiles,
+ memoryUsed: 1024.5,
+ memoryPeak: 2048.0,
+ );
+
+ // Act & Assert - All percentiles accessible via getter methods
+ self::assertSame(1.5, $dto->getP50());
+ self::assertSame(2.0, $dto->getP80());
+ self::assertSame(2.5, $dto->getP90());
+ self::assertSame(3.0, $dto->getP95());
+ self::assertSame(4.0, $dto->getP99());
+ }
+
+ public function testFromDomainCreatesDTO(): void
+ {
+ // Arrange
+ $percentiles = new PercentileMetrics(
+ p50: 1.5,
+ p80: 2.0,
+ p90: 2.5,
+ p95: 3.0,
+ p99: 4.0,
+ );
+
+ $domainStats = new BenchmarkStatistics(
+ benchmarkId: 'test-benchmark',
+ benchmarkName: 'Test Benchmark',
+ phpVersion: 'php84',
+ executionCount: 100,
+ averageExecutionTime: 1.8,
+ percentiles: $percentiles,
+ averageMemoryUsed: 1024.5,
+ peakMemoryUsed: 2048.0,
+ );
+
+ // Act
+ $dto = BenchmarkStatisticsData::fromDomain($domainStats);
+
+ // Assert
+ self::assertSame('test-benchmark', $dto->benchmarkId);
+ self::assertSame('Test Benchmark', $dto->benchmarkName);
+ self::assertSame('php84', $dto->phpVersion);
+ self::assertSame(100, $dto->count);
+ self::assertSame(1.8, $dto->avg);
+ self::assertSame($percentiles, $dto->percentiles);
+ self::assertSame(1024.5, $dto->memoryUsed);
+ self::assertSame(2048.0, $dto->memoryPeak);
+ }
+
+ public function testFromDomainPreservesPercentiles(): void
+ {
+ // Arrange
+ $percentiles = new PercentileMetrics(
+ p50: 10.0,
+ p80: 20.0,
+ p90: 30.0,
+ p95: 40.0,
+ p99: 50.0,
+ );
+
+ $domainStats = new BenchmarkStatistics(
+ benchmarkId: 'test',
+ benchmarkName: 'Test',
+ phpVersion: 'php85',
+ executionCount: 50,
+ averageExecutionTime: 25.0,
+ percentiles: $percentiles,
+ averageMemoryUsed: 512.0,
+ peakMemoryUsed: 1024.0,
+ );
+
+ // Act
+ $dto = BenchmarkStatisticsData::fromDomain($domainStats);
+
+ // Assert - Verify percentiles are accessible via getter methods
+ self::assertSame(10.0, $dto->getP50());
+ self::assertSame(20.0, $dto->getP80());
+ self::assertSame(30.0, $dto->getP90());
+ self::assertSame(40.0, $dto->getP95());
+ self::assertSame(50.0, $dto->getP99());
+ }
+}
diff --git a/tests/Unit/Application/UseCase/AsyncBenchmarkRunnerTest.php b/tests/Unit/Application/UseCase/AsyncBenchmarkRunnerTest.php
new file mode 100644
index 0000000..a9b5c8b
--- /dev/null
+++ b/tests/Unit/Application/UseCase/AsyncBenchmarkRunnerTest.php
@@ -0,0 +1,239 @@
+benchmarkExecutor = $this->createMock(BenchmarkExecutorPort::class);
+ $this->resultPersister = $this->createMock(ResultPersisterPort::class);
+ $this->eventDispatcher = $this->createMock(EventDispatcherPort::class);
+ $this->asyncExecutor = $this->createMock(AsyncExecutorPort::class);
+
+ $this->runner = new AsyncBenchmarkRunner(
+ benchmarkExecutorPort: $this->benchmarkExecutor,
+ resultPersisterPort: $this->resultPersister,
+ eventDispatcher: $this->eventDispatcher,
+ asyncExecutor: $this->asyncExecutor,
+ );
+ }
+
+ public function testRunDispatchesBenchmarkStartedEvent(): void
+ {
+ // Arrange
+ $benchmark = $this->createMock(Benchmark::class);
+
+ $configuration = new BenchmarkConfiguration(
+ benchmark: $benchmark,
+ phpVersion: PhpVersion::PHP_8_4,
+ iterations: 1,
+ );
+
+ $result = new BenchmarkResult(
+ executionTimeMs: 1.0,
+ memoryUsedBytes: 100,
+ memoryPeakBytes: 200,
+ );
+
+ $this->asyncExecutor->method('addTask')->willReturnCallback(
+ function (callable $task, callable $onSuccess) use ($result): void {
+ $onSuccess($result);
+ },
+ );
+
+ // Assert BenchmarkStarted event is dispatched
+ $dispatchedEvents = [];
+ $this->eventDispatcher
+ ->expects(self::exactly(3))
+ ->method('dispatch')
+ ->willReturnCallback(function (object $event) use (&$dispatchedEvents): void {
+ $dispatchedEvents[] = $event;
+ });
+
+ // Act
+ $this->runner->run($configuration);
+
+ // Assert
+ self::assertCount(3, $dispatchedEvents);
+ self::assertInstanceOf(BenchmarkStarted::class, $dispatchedEvents[0]);
+ self::assertInstanceOf(BenchmarkProgress::class, $dispatchedEvents[1]);
+ self::assertInstanceOf(BenchmarkCompleted::class, $dispatchedEvents[2]);
+ }
+
+ public function testRunExecutesBenchmarkAndPersistsResults(): void
+ {
+ // Arrange
+ $benchmark = $this->createMock(Benchmark::class);
+
+ $configuration = new BenchmarkConfiguration(
+ benchmark: $benchmark,
+ phpVersion: PhpVersion::PHP_8_4,
+ iterations: 3,
+ );
+
+ $result = new BenchmarkResult(
+ executionTimeMs: 1.23,
+ memoryUsedBytes: 1024,
+ memoryPeakBytes: 2048,
+ );
+
+ $this->benchmarkExecutor
+ ->expects(self::never())
+ ->method('execute');
+
+ $this->asyncExecutor
+ ->expects(self::exactly(3))
+ ->method('addTask')
+ ->willReturnCallback(function (callable $task, callable $onSuccess) use ($result): void {
+ // Simulate async execution
+ $onSuccess($result);
+ });
+
+ $this->resultPersister
+ ->expects(self::exactly(3))
+ ->method('persist')
+ ->with($configuration, $result);
+
+ $this->asyncExecutor
+ ->expects(self::once())
+ ->method('wait');
+
+ // Act
+ $this->runner->run($configuration);
+ }
+
+ public function testRunDispatchesProgressEventsForEachIteration(): void
+ {
+ // Arrange
+ $benchmark = $this->createMock(Benchmark::class);
+
+ $configuration = new BenchmarkConfiguration(
+ benchmark: $benchmark,
+ phpVersion: PhpVersion::PHP_8_4,
+ iterations: 2,
+ );
+
+ $result = new BenchmarkResult(
+ executionTimeMs: 1.0,
+ memoryUsedBytes: 100,
+ memoryPeakBytes: 200,
+ );
+
+ $this->asyncExecutor->method('addTask')->willReturnCallback(
+ function (callable $task, callable $onSuccess) use ($result): void {
+ $onSuccess($result);
+ },
+ );
+
+ $dispatchedEvents = [];
+ $this->eventDispatcher
+ ->method('dispatch')
+ ->willReturnCallback(function (object $event) use (&$dispatchedEvents): void {
+ $dispatchedEvents[] = $event;
+ });
+
+ // Act
+ $this->runner->run($configuration);
+
+ // Assert: Should have BenchmarkStarted + 2 Progress + BenchmarkCompleted
+ self::assertCount(4, $dispatchedEvents);
+ self::assertInstanceOf(BenchmarkStarted::class, $dispatchedEvents[0]);
+ self::assertInstanceOf(BenchmarkProgress::class, $dispatchedEvents[1]);
+ self::assertInstanceOf(BenchmarkProgress::class, $dispatchedEvents[2]);
+ self::assertInstanceOf(BenchmarkCompleted::class, $dispatchedEvents[3]);
+ }
+
+ public function testRunDispatchesCompletedEventAfterAllIterations(): void
+ {
+ // Arrange
+ $benchmark = $this->createMock(Benchmark::class);
+
+ $configuration = new BenchmarkConfiguration(
+ benchmark: $benchmark,
+ phpVersion: PhpVersion::PHP_8_4,
+ iterations: 1,
+ );
+
+ $this->asyncExecutor->method('addTask')->willReturnCallback(
+ function (callable $task, callable $onSuccess): void {
+ $result = new BenchmarkResult(
+ executionTimeMs: 1.0,
+ memoryUsedBytes: 100,
+ memoryPeakBytes: 200,
+ );
+ $onSuccess($result);
+ },
+ );
+
+ $completedEventDispatched = false;
+ $this->eventDispatcher
+ ->method('dispatch')
+ ->willReturnCallback(function (object $event) use (&$completedEventDispatched): void {
+ if ($event instanceof BenchmarkCompleted) {
+ $completedEventDispatched = true;
+ }
+ });
+
+ // Act
+ $this->runner->run($configuration);
+
+ // Assert
+ self::assertTrue($completedEventDispatched);
+ }
+
+ public function testRunCallsAsyncExecutorWait(): void
+ {
+ // Arrange
+ $benchmark = $this->createMock(Benchmark::class);
+
+ $configuration = new BenchmarkConfiguration(
+ benchmark: $benchmark,
+ phpVersion: PhpVersion::PHP_8_4,
+ iterations: 1,
+ );
+
+ $this->asyncExecutor->method('addTask')->willReturnCallback(
+ function (callable $task, callable $onSuccess): void {
+ $result = new BenchmarkResult(
+ executionTimeMs: 1.0,
+ memoryUsedBytes: 100,
+ memoryPeakBytes: 200,
+ );
+ $onSuccess($result);
+ },
+ );
+
+ $this->asyncExecutor
+ ->expects(self::once())
+ ->method('wait');
+
+ // Act
+ $this->runner->run($configuration);
+ }
+}
diff --git a/tests/Unit/Domain/Benchmark/Model/BenchmarkResultTest.php b/tests/Unit/Domain/Benchmark/Model/BenchmarkResultTest.php
new file mode 100644
index 0000000..855d7ac
--- /dev/null
+++ b/tests/Unit/Domain/Benchmark/Model/BenchmarkResultTest.php
@@ -0,0 +1,201 @@
+executionTimeMs);
+ self::assertSame(1024.0, $result->memoryUsedBytes);
+ self::assertSame(2048.0, $result->memoryPeakBytes);
+ }
+
+ public function testFromArrayWithValidData(): void
+ {
+ $data = [
+ 'execution_time_ms' => 15.75,
+ 'memory_used_bytes' => 2048.5,
+ 'memory_peak_bytes' => 4096.25,
+ ];
+
+ $result = BenchmarkResult::fromArray($data);
+
+ self::assertSame(15.75, $result->executionTimeMs);
+ self::assertSame(2048.5, $result->memoryUsedBytes);
+ self::assertSame(4096.25, $result->memoryPeakBytes);
+ }
+
+ public function testFromArrayWithIntegerValues(): void
+ {
+ $data = [
+ 'execution_time_ms' => 10,
+ 'memory_used_bytes' => 1024,
+ 'memory_peak_bytes' => 2048,
+ ];
+
+ $result = BenchmarkResult::fromArray($data);
+
+ self::assertSame(10.0, $result->executionTimeMs);
+ self::assertSame(1024.0, $result->memoryUsedBytes);
+ self::assertSame(2048.0, $result->memoryPeakBytes);
+ }
+
+ public function testFromArrayWithStringNumericValues(): void
+ {
+ $data = [
+ 'execution_time_ms' => '12.5',
+ 'memory_used_bytes' => '1024.0',
+ 'memory_peak_bytes' => '2048.5',
+ ];
+
+ $result = BenchmarkResult::fromArray($data);
+
+ self::assertSame(12.5, $result->executionTimeMs);
+ self::assertSame(1024.0, $result->memoryUsedBytes);
+ self::assertSame(2048.5, $result->memoryPeakBytes);
+ }
+
+ public function testFromArrayWithMissingKeysDefaultsToZero(): void
+ {
+ $data = [];
+
+ $result = BenchmarkResult::fromArray($data);
+
+ self::assertSame(0.0, $result->executionTimeMs);
+ self::assertSame(0.0, $result->memoryUsedBytes);
+ self::assertSame(0.0, $result->memoryPeakBytes);
+ }
+
+ public function testFromArrayWithPartialDataDefaultsMissingToZero(): void
+ {
+ $data = [
+ 'execution_time_ms' => 25.5,
+ ];
+
+ $result = BenchmarkResult::fromArray($data);
+
+ self::assertSame(25.5, $result->executionTimeMs);
+ self::assertSame(0.0, $result->memoryUsedBytes);
+ self::assertSame(0.0, $result->memoryPeakBytes);
+ }
+
+ public function testFromArrayWithInvalidNonNumericValuesDefaultsToZero(): void
+ {
+ $data = [
+ 'execution_time_ms' => 'invalid',
+ 'memory_used_bytes' => 'not-a-number',
+ 'memory_peak_bytes' => null,
+ ];
+
+ $result = BenchmarkResult::fromArray($data);
+
+ self::assertSame(0.0, $result->executionTimeMs);
+ self::assertSame(0.0, $result->memoryUsedBytes);
+ self::assertSame(0.0, $result->memoryPeakBytes);
+ }
+
+ public function testFromArrayWithBooleanValuesDefaultsToZero(): void
+ {
+ $data = [
+ 'execution_time_ms' => true,
+ 'memory_used_bytes' => false,
+ 'memory_peak_bytes' => true,
+ ];
+
+ $result = BenchmarkResult::fromArray($data);
+
+ self::assertSame(0.0, $result->executionTimeMs);
+ self::assertSame(0.0, $result->memoryUsedBytes);
+ self::assertSame(0.0, $result->memoryPeakBytes);
+ }
+
+ public function testFromArrayWithArrayValuesDefaultsToZero(): void
+ {
+ $data = [
+ 'execution_time_ms' => [10.5],
+ 'memory_used_bytes' => ['value' => 1024],
+ 'memory_peak_bytes' => [],
+ ];
+
+ $result = BenchmarkResult::fromArray($data);
+
+ self::assertSame(0.0, $result->executionTimeMs);
+ self::assertSame(0.0, $result->memoryUsedBytes);
+ self::assertSame(0.0, $result->memoryPeakBytes);
+ }
+
+ public function testFromArrayWithNegativeValues(): void
+ {
+ $data = [
+ 'execution_time_ms' => -10.5,
+ 'memory_used_bytes' => -1024.0,
+ 'memory_peak_bytes' => -2048.0,
+ ];
+
+ $result = BenchmarkResult::fromArray($data);
+
+ // Negative values are allowed (edge case)
+ self::assertSame(-10.5, $result->executionTimeMs);
+ self::assertSame(-1024.0, $result->memoryUsedBytes);
+ self::assertSame(-2048.0, $result->memoryPeakBytes);
+ }
+
+ public function testFromArrayWithZeroValues(): void
+ {
+ $data = [
+ 'execution_time_ms' => 0,
+ 'memory_used_bytes' => 0.0,
+ 'memory_peak_bytes' => 0,
+ ];
+
+ $result = BenchmarkResult::fromArray($data);
+
+ self::assertSame(0.0, $result->executionTimeMs);
+ self::assertSame(0.0, $result->memoryUsedBytes);
+ self::assertSame(0.0, $result->memoryPeakBytes);
+ }
+
+ public function testFromArrayWithVeryLargeNumbers(): void
+ {
+ $data = [
+ 'execution_time_ms' => 999999.99,
+ 'memory_used_bytes' => 1073741824.0, // 1GB
+ 'memory_peak_bytes' => 2147483648.0, // 2GB
+ ];
+
+ $result = BenchmarkResult::fromArray($data);
+
+ self::assertSame(999999.99, $result->executionTimeMs);
+ self::assertSame(1073741824.0, $result->memoryUsedBytes);
+ self::assertSame(2147483648.0, $result->memoryPeakBytes);
+ }
+
+ public function testFromArrayWithExtraKeysIgnoresThem(): void
+ {
+ $data = [
+ 'execution_time_ms' => 10.0,
+ 'memory_used_bytes' => 1024.0,
+ 'memory_peak_bytes' => 2048.0,
+ 'extra_field' => 'ignored',
+ 'another_field' => 123,
+ ];
+
+ $result = BenchmarkResult::fromArray($data);
+
+ self::assertSame(10.0, $result->executionTimeMs);
+ self::assertSame(1024.0, $result->memoryUsedBytes);
+ self::assertSame(2048.0, $result->memoryPeakBytes);
+ }
+}
diff --git a/tests/Unit/Domain/Dashboard/Model/BenchmarkMetricsTest.php b/tests/Unit/Domain/Dashboard/Model/BenchmarkMetricsTest.php
new file mode 100644
index 0000000..5c22394
--- /dev/null
+++ b/tests/Unit/Domain/Dashboard/Model/BenchmarkMetricsTest.php
@@ -0,0 +1,102 @@
+benchmarkId);
+ self::assertSame('Test Benchmark', $metrics->benchmarkName);
+ self::assertSame('php84', $metrics->phpVersion);
+ self::assertSame([10.0, 20.0, 30.0], $metrics->executionTimes);
+ self::assertSame([100.0, 200.0, 300.0], $metrics->memoryUsages);
+ self::assertSame([150.0, 250.0, 350.0], $metrics->memoryPeaks);
+ }
+
+ public function testGetExecutionCountReturnsCorrectCount(): void
+ {
+ $metrics = new BenchmarkMetrics(
+ benchmarkId: 'test-id',
+ benchmarkName: 'Test',
+ phpVersion: 'php84',
+ executionTimes: [10.0, 20.0, 30.0],
+ memoryUsages: [100.0],
+ memoryPeaks: [100.0],
+ );
+
+ self::assertSame(3, $metrics->getExecutionCount());
+ }
+
+ public function testGetExecutionCountReturnsZeroForEmptyArray(): void
+ {
+ $metrics = new BenchmarkMetrics(
+ benchmarkId: 'test-id',
+ benchmarkName: 'Test',
+ phpVersion: 'php84',
+ executionTimes: [],
+ memoryUsages: [],
+ memoryPeaks: [],
+ );
+
+ self::assertSame(0, $metrics->getExecutionCount());
+ }
+
+ public function testIsEmptyReturnsTrueForNoExecutions(): void
+ {
+ $metrics = new BenchmarkMetrics(
+ benchmarkId: 'test-id',
+ benchmarkName: 'Test',
+ phpVersion: 'php84',
+ executionTimes: [],
+ memoryUsages: [],
+ memoryPeaks: [],
+ );
+
+ self::assertTrue($metrics->isEmpty());
+ }
+
+ public function testIsEmptyReturnsFalseForExecutions(): void
+ {
+ $metrics = new BenchmarkMetrics(
+ benchmarkId: 'test-id',
+ benchmarkName: 'Test',
+ phpVersion: 'php84',
+ executionTimes: [10.0],
+ memoryUsages: [100.0],
+ memoryPeaks: [100.0],
+ );
+
+ self::assertFalse($metrics->isEmpty());
+ }
+
+ public function testValueObjectIsReadonly(): void
+ {
+ $metrics = new BenchmarkMetrics(
+ benchmarkId: 'test-id',
+ benchmarkName: 'Test',
+ phpVersion: 'php84',
+ executionTimes: [10.0],
+ memoryUsages: [100.0],
+ memoryPeaks: [100.0],
+ );
+
+ $reflection = new ReflectionClass($metrics);
+ self::assertTrue($reflection->isReadOnly());
+ }
+}
diff --git a/tests/Unit/Domain/Dashboard/Model/PercentileMetricsTest.php b/tests/Unit/Domain/Dashboard/Model/PercentileMetricsTest.php
new file mode 100644
index 0000000..2162393
--- /dev/null
+++ b/tests/Unit/Domain/Dashboard/Model/PercentileMetricsTest.php
@@ -0,0 +1,129 @@
+p50);
+ self::assertSame(15.2, $metrics->p80);
+ self::assertSame(18.7, $metrics->p90);
+ self::assertSame(22.1, $metrics->p95);
+ self::assertSame(30.5, $metrics->p99);
+ }
+
+ public function testFromArrayWithValidData(): void
+ {
+ $data = [
+ 'p50' => 12.5,
+ 'p80' => 16.0,
+ 'p90' => 20.0,
+ 'p95' => 25.0,
+ 'p99' => 35.0,
+ ];
+
+ $metrics = PercentileMetrics::fromArray($data);
+
+ self::assertSame(12.5, $metrics->p50);
+ self::assertSame(16.0, $metrics->p80);
+ self::assertSame(20.0, $metrics->p90);
+ self::assertSame(25.0, $metrics->p95);
+ self::assertSame(35.0, $metrics->p99);
+ }
+
+ public function testFromArrayWithMissingKeysDefaultsToZero(): void
+ {
+ $data = [];
+
+ $metrics = PercentileMetrics::fromArray($data);
+
+ self::assertSame(0.0, $metrics->p50);
+ self::assertSame(0.0, $metrics->p80);
+ self::assertSame(0.0, $metrics->p90);
+ self::assertSame(0.0, $metrics->p95);
+ self::assertSame(0.0, $metrics->p99);
+ }
+
+ public function testFromArrayWithPartialDataDefaultsMissingToZero(): void
+ {
+ $data = [
+ 'p50' => 10.0,
+ 'p90' => 20.0,
+ ];
+
+ $metrics = PercentileMetrics::fromArray($data);
+
+ self::assertSame(10.0, $metrics->p50);
+ self::assertSame(0.0, $metrics->p80);
+ self::assertSame(20.0, $metrics->p90);
+ self::assertSame(0.0, $metrics->p95);
+ self::assertSame(0.0, $metrics->p99);
+ }
+
+ public function testFromArrayWithExtraKeysIgnoresThem(): void
+ {
+ $data = [
+ 'p50' => 10.0,
+ 'p80' => 15.0,
+ 'p90' => 20.0,
+ 'p95' => 25.0,
+ 'p99' => 30.0,
+ 'p100' => 40.0,
+ 'extra' => 100.0,
+ ];
+
+ $metrics = PercentileMetrics::fromArray($data);
+
+ self::assertSame(10.0, $metrics->p50);
+ self::assertSame(15.0, $metrics->p80);
+ self::assertSame(20.0, $metrics->p90);
+ self::assertSame(25.0, $metrics->p95);
+ self::assertSame(30.0, $metrics->p99);
+ }
+
+ public function testValueObjectIsReadonly(): void
+ {
+ $metrics = new PercentileMetrics(
+ p50: 10.0,
+ p80: 15.0,
+ p90: 20.0,
+ p95: 25.0,
+ p99: 30.0,
+ );
+
+ $reflection = new ReflectionClass($metrics);
+ self::assertTrue($reflection->isReadOnly());
+ }
+
+ public function testPercentilesAreInAscendingOrder(): void
+ {
+ $metrics = new PercentileMetrics(
+ p50: 10.0,
+ p80: 15.0,
+ p90: 20.0,
+ p95: 25.0,
+ p99: 30.0,
+ );
+
+ // Verify semantic meaning: higher percentiles should have higher or equal values
+ self::assertLessThanOrEqual($metrics->p80, $metrics->p50);
+ self::assertLessThanOrEqual($metrics->p90, $metrics->p80);
+ self::assertLessThanOrEqual($metrics->p95, $metrics->p90);
+ self::assertLessThanOrEqual($metrics->p99, $metrics->p95);
+ }
+}
diff --git a/tests/Unit/Domain/Dashboard/Service/StatisticsCalculatorTest.php b/tests/Unit/Domain/Dashboard/Service/StatisticsCalculatorTest.php
new file mode 100644
index 0000000..a307f2a
--- /dev/null
+++ b/tests/Unit/Domain/Dashboard/Service/StatisticsCalculatorTest.php
@@ -0,0 +1,198 @@
+calculator = new StatisticsCalculator();
+ }
+
+ public function testCalculateWithEmptyMetricsReturnsZeroStatistics(): void
+ {
+ $metrics = new BenchmarkMetrics(
+ benchmarkId: 'test-bench',
+ benchmarkName: 'Test Benchmark',
+ phpVersion: 'php84',
+ executionTimes: [],
+ memoryUsages: [],
+ memoryPeaks: [],
+ );
+
+ $statistics = $this->calculator->calculate($metrics);
+
+ self::assertSame('test-bench', $statistics->benchmarkId);
+ self::assertSame('Test Benchmark', $statistics->benchmarkName);
+ self::assertSame('php84', $statistics->phpVersion);
+ self::assertSame(0, $statistics->executionCount);
+ self::assertSame(0.0, $statistics->averageExecutionTime);
+ self::assertSame(0.0, $statistics->averageMemoryUsed);
+ self::assertSame(0.0, $statistics->peakMemoryUsed);
+ self::assertSame(0.0, $statistics->percentiles->p50);
+ self::assertSame(0.0, $statistics->percentiles->p90);
+ self::assertSame(0.0, $statistics->percentiles->p99);
+ }
+
+ public function testCalculateWithSingleValueReturnsCorrectStatistics(): void
+ {
+ $metrics = new BenchmarkMetrics(
+ benchmarkId: 'test-bench',
+ benchmarkName: 'Test Benchmark',
+ phpVersion: 'php84',
+ executionTimes: [10.5],
+ memoryUsages: [1024.0],
+ memoryPeaks: [2048.0],
+ );
+
+ $statistics = $this->calculator->calculate($metrics);
+
+ self::assertSame(1, $statistics->executionCount);
+ self::assertSame(10.5, $statistics->averageExecutionTime);
+ self::assertSame(1024.0, $statistics->averageMemoryUsed);
+ self::assertSame(2048.0, $statistics->peakMemoryUsed);
+ self::assertSame(10.5, $statistics->percentiles->p50);
+ self::assertSame(10.5, $statistics->percentiles->p90);
+ self::assertSame(10.5, $statistics->percentiles->p99);
+ }
+
+ public function testCalculateWithMultipleValuesReturnsCorrectAverage(): void
+ {
+ $metrics = new BenchmarkMetrics(
+ benchmarkId: 'test-bench',
+ benchmarkName: 'Test Benchmark',
+ phpVersion: 'php84',
+ executionTimes: [10.0, 20.0, 30.0],
+ memoryUsages: [100.0, 200.0, 300.0],
+ memoryPeaks: [150.0, 250.0, 350.0],
+ );
+
+ $statistics = $this->calculator->calculate($metrics);
+
+ self::assertSame(3, $statistics->executionCount);
+ self::assertSame(20.0, $statistics->averageExecutionTime);
+ self::assertSame(200.0, $statistics->averageMemoryUsed);
+ self::assertSame(350.0, $statistics->peakMemoryUsed);
+ }
+
+ public function testCalculatePercentilesWithSortedData(): void
+ {
+ // Dataset: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 (10 values)
+ $metrics = new BenchmarkMetrics(
+ benchmarkId: 'test-bench',
+ benchmarkName: 'Test Benchmark',
+ phpVersion: 'php84',
+ executionTimes: [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0],
+ memoryUsages: [100.0],
+ memoryPeaks: [100.0],
+ );
+
+ $statistics = $this->calculator->calculate($metrics);
+
+ // P50 (50th percentile / median) = 5th value
+ self::assertSame(5.0, $statistics->percentiles->p50);
+
+ // P80 (80th percentile) = 8th value
+ self::assertSame(8.0, $statistics->percentiles->p80);
+
+ // P90 (90th percentile) = 9th value
+ self::assertSame(9.0, $statistics->percentiles->p90);
+
+ // P95 (95th percentile) = 10th value
+ self::assertSame(10.0, $statistics->percentiles->p95);
+
+ // P99 (99th percentile) = 10th value (last)
+ self::assertSame(10.0, $statistics->percentiles->p99);
+ }
+
+ public function testCalculatePercentilesWithUnsortedData(): void
+ {
+ // Unsorted dataset: should be sorted internally
+ $metrics = new BenchmarkMetrics(
+ benchmarkId: 'test-bench',
+ benchmarkName: 'Test Benchmark',
+ phpVersion: 'php84',
+ executionTimes: [50.0, 10.0, 30.0, 20.0, 40.0],
+ memoryUsages: [100.0],
+ memoryPeaks: [100.0],
+ );
+
+ $statistics = $this->calculator->calculate($metrics);
+
+ // After sorting: [10, 20, 30, 40, 50]
+ // P50 (median) = 30 (3rd value)
+ self::assertSame(30.0, $statistics->percentiles->p50);
+
+ // P90 = 50 (5th value, 90% of 5 = 4.5 -> ceil = 5)
+ self::assertSame(50.0, $statistics->percentiles->p90);
+ }
+
+ public function testCalculateWithRealWorldBenchmarkData(): void
+ {
+ // Realistic benchmark execution times in milliseconds
+ $metrics = new BenchmarkMetrics(
+ benchmarkId: 'array-loop',
+ benchmarkName: 'Array Loop Performance',
+ phpVersion: 'php84',
+ executionTimes: [
+ 12.5, 12.8, 13.1, 12.9, 13.0,
+ 12.7, 12.6, 13.2, 12.8, 12.9,
+ 50.0, // outlier
+ ],
+ memoryUsages: [
+ 1024.0, 1025.0, 1026.0, 1024.5, 1025.5,
+ 1024.8, 1025.2, 1026.1, 1025.3, 1024.9,
+ 2048.0, // outlier
+ ],
+ memoryPeaks: [
+ 2048.0, 2049.0, 2050.0, 2048.5, 2049.5,
+ 2048.8, 2049.2, 2050.1, 2049.3, 2048.9,
+ 4096.0, // outlier
+ ],
+ );
+
+ $statistics = $this->calculator->calculate($metrics);
+
+ self::assertSame(11, $statistics->executionCount);
+
+ // Average should include the outlier
+ self::assertGreaterThan(13.0, $statistics->averageExecutionTime);
+ self::assertLessThan(20.0, $statistics->averageExecutionTime);
+
+ // P50 should be around 12.9 (not affected by outlier)
+ self::assertGreaterThanOrEqual(12.5, $statistics->percentiles->p50);
+ self::assertLessThanOrEqual(13.2, $statistics->percentiles->p50);
+
+ // P99 should be the outlier
+ self::assertSame(50.0, $statistics->percentiles->p99);
+ }
+
+ public function testCalculateDoesNotModifyOriginalData(): void
+ {
+ $originalTimes = [30.0, 10.0, 20.0];
+ $metrics = new BenchmarkMetrics(
+ benchmarkId: 'test-bench',
+ benchmarkName: 'Test Benchmark',
+ phpVersion: 'php84',
+ executionTimes: $originalTimes,
+ memoryUsages: [100.0],
+ memoryPeaks: [100.0],
+ );
+
+ $this->calculator->calculate($metrics);
+
+ // Original array should remain unchanged (immutability check)
+ self::assertCount(3, $originalTimes);
+ self::assertSame(30.0, $originalTimes[0]);
+ self::assertSame(10.0, $originalTimes[1]);
+ self::assertSame(20.0, $originalTimes[2]);
+ }
+}
diff --git a/tests/Unit/Domain/PhpVersion/Enum/PhpVersionTest.php b/tests/Unit/Domain/PhpVersion/Enum/PhpVersionTest.php
new file mode 100644
index 0000000..68cc62a
--- /dev/null
+++ b/tests/Unit/Domain/PhpVersion/Enum/PhpVersionTest.php
@@ -0,0 +1,93 @@
+value);
+ self::assertSame('php70', PhpVersion::PHP_7_0->value);
+ self::assertSame('php71', PhpVersion::PHP_7_1->value);
+ self::assertSame('php72', PhpVersion::PHP_7_2->value);
+ self::assertSame('php73', PhpVersion::PHP_7_3->value);
+ self::assertSame('php74', PhpVersion::PHP_7_4->value);
+ self::assertSame('php80', PhpVersion::PHP_8_0->value);
+ self::assertSame('php81', PhpVersion::PHP_8_1->value);
+ self::assertSame('php82', PhpVersion::PHP_8_2->value);
+ self::assertSame('php83', PhpVersion::PHP_8_3->value);
+ self::assertSame('php84', PhpVersion::PHP_8_4->value);
+ self::assertSame('php85', PhpVersion::PHP_8_5->value);
+ }
+
+ public function testFromValueCreatesCorrectEnum(): void
+ {
+ self::assertSame(PhpVersion::PHP_8_4, PhpVersion::from('php84'));
+ self::assertSame(PhpVersion::PHP_8_3, PhpVersion::from('php83'));
+ self::assertSame(PhpVersion::PHP_7_4, PhpVersion::from('php74'));
+ }
+
+ public function testTryFromReturnsNullForInvalidValue(): void
+ {
+ self::assertNull(PhpVersion::tryFrom('php99'));
+ self::assertNull(PhpVersion::tryFrom('invalid'));
+ self::assertNull(PhpVersion::tryFrom(''));
+ }
+
+ public function testTryFromReturnsEnumForValidValue(): void
+ {
+ self::assertSame(PhpVersion::PHP_8_4, PhpVersion::tryFrom('php84'));
+ self::assertSame(PhpVersion::PHP_5_6, PhpVersion::tryFrom('php56'));
+ }
+
+ public function testEnumIsBackedByString(): void
+ {
+ $enum = PhpVersion::PHP_8_4;
+
+ self::assertIsString($enum->value);
+ }
+
+ public function testEnumCanBeComparedInConditionals(): void
+ {
+ $version = PhpVersion::PHP_8_4;
+
+ $isModern = match (true) {
+ PhpVersion::PHP_8_3 === $version || PhpVersion::PHP_8_4 === $version => true,
+ default => false,
+ };
+
+ self::assertTrue($isModern);
+ }
+
+ public function testEnumCasesAreSingleton(): void
+ {
+ $version1 = PhpVersion::PHP_8_4;
+ $version2 = PhpVersion::from('php84');
+
+ self::assertSame($version1, $version2);
+ }
+}
diff --git a/tests/bootstrap.php b/tests/bootstrap.php
index e494c79..838b35f 100644
--- a/tests/bootstrap.php
+++ b/tests/bootstrap.php
@@ -7,7 +7,7 @@
require dirname(__DIR__) . '/vendor/autoload.php';
if (method_exists(Dotenv::class, 'bootEnv')) {
- (new Dotenv())->bootEnv(dirname(__DIR__) . '/.env');
+ new Dotenv()->bootEnv(dirname(__DIR__) . '/.env');
}
if ($_SERVER['APP_DEBUG']) {
+
+
+
+
+**A modern benchmarking framework for PHP testing performance across versions 5.6 to 8.5**
+
+[Features](#-features) • [Installation](#-installation) • [Usage](#-usage) • [Architecture](#-architecture) • [Contributing](#-contributing)
+
+
