mirror of
https://github.com/pestphp/pest.git
synced 2026-09-05 14:23:34 +02:00
chore: upgrades to phpunit:13.3
This commit is contained in:
nuno maduro
@@ -16,42 +16,32 @@ namespace PHPUnit\Runner\Filter;
|
||||
use Pest\Contracts\HasPrintableTestCaseName;
|
||||
use PHPUnit\Framework\Test;
|
||||
use PHPUnit\Framework\TestSuite;
|
||||
use PHPUnit\Runner\PhptTestCase;
|
||||
use PHPUnit\Runner\Phpt\TestCase as PhptTestCase;
|
||||
use RecursiveFilterIterator;
|
||||
use RecursiveIterator;
|
||||
|
||||
use function end;
|
||||
use function preg_match;
|
||||
use function sprintf;
|
||||
use function str_replace;
|
||||
use function trim;
|
||||
|
||||
/**
|
||||
* @extends RecursiveFilterIterator<int, Test, RecursiveIterator<int, Test>>
|
||||
*
|
||||
* @internal This class is not covered by the backward compatibility promise for PHPUnit
|
||||
*/
|
||||
abstract class NameFilterIterator extends RecursiveFilterIterator
|
||||
{
|
||||
/**
|
||||
* @psalm-var non-empty-string
|
||||
*/
|
||||
private readonly string $regularExpression;
|
||||
|
||||
private readonly ?int $dataSetMinimum;
|
||||
|
||||
private readonly ?int $dataSetMaximum;
|
||||
private readonly CompiledNameFilter $filter;
|
||||
|
||||
/**
|
||||
* @psalm-param RecursiveIterator<int, Test> $iterator
|
||||
* @psalm-param non-empty-string $filter
|
||||
* @param RecursiveIterator<int, Test> $iterator
|
||||
* @param non-empty-string $filter
|
||||
*/
|
||||
public function __construct(RecursiveIterator $iterator, string $filter)
|
||||
{
|
||||
parent::__construct($iterator);
|
||||
|
||||
$preparedFilter = $this->prepareFilter($filter);
|
||||
|
||||
$this->regularExpression = $preparedFilter['regularExpression'];
|
||||
$this->dataSetMinimum = $preparedFilter['dataSetMinimum'];
|
||||
$this->dataSetMaximum = $preparedFilter['dataSetMaximum'];
|
||||
$this->filter = CompiledNameFilter::from($filter);
|
||||
}
|
||||
|
||||
public function accept(): bool
|
||||
@@ -74,70 +64,15 @@ abstract class NameFilterIterator extends RecursiveFilterIterator
|
||||
$name = $test::class.'::'.$test->nameWithDataSet();
|
||||
}
|
||||
|
||||
$accepted = @preg_match($this->regularExpression, $name, $matches) === 1;
|
||||
$accepted = @preg_match($this->filter->regularExpression(), $name, $matches) === 1;
|
||||
|
||||
if ($accepted && isset($this->dataSetMaximum)) {
|
||||
if ($accepted && $this->filter->hasDataSetRange()) {
|
||||
$set = end($matches);
|
||||
$accepted = $set >= $this->dataSetMinimum && $set <= $this->dataSetMaximum;
|
||||
$accepted = $set >= $this->filter->dataSetMinimum() && $set <= $this->filter->dataSetMaximum();
|
||||
}
|
||||
|
||||
return $this->doAccept($accepted);
|
||||
}
|
||||
|
||||
abstract protected function doAccept(bool $result): bool;
|
||||
|
||||
/**
|
||||
* @psalm-param non-empty-string $filter
|
||||
*
|
||||
* @psalm-return array{regularExpression: non-empty-string, dataSetMinimum: ?int, dataSetMaximum: ?int}
|
||||
*/
|
||||
private function prepareFilter(string $filter): array
|
||||
{
|
||||
$dataSetMinimum = null;
|
||||
$dataSetMaximum = null;
|
||||
|
||||
if (@preg_match($filter, '') === false) {
|
||||
if (preg_match('/^(.*?)#(\d+)(?:-(\d+))?$/', $filter, $matches)) {
|
||||
if (isset($matches[3]) && $matches[2] < $matches[3]) {
|
||||
$filter = sprintf(
|
||||
'%s.*with data set #(\d+)$',
|
||||
$matches[1],
|
||||
);
|
||||
|
||||
$dataSetMinimum = (int) $matches[2];
|
||||
$dataSetMaximum = (int) $matches[3];
|
||||
} else {
|
||||
$filter = sprintf(
|
||||
'%s.*with data set #%s$',
|
||||
$matches[1],
|
||||
$matches[2],
|
||||
);
|
||||
}
|
||||
}
|
||||
// * testDetermineJsonError@JSON_ERROR_NONE
|
||||
// * testDetermineJsonError@JSON.*
|
||||
elseif (preg_match('/^(.*?)@(.+)$/', $filter, $matches)) {
|
||||
$filter = sprintf(
|
||||
'%s.*with data set "%s"$',
|
||||
$matches[1],
|
||||
$matches[2],
|
||||
);
|
||||
}
|
||||
|
||||
$filter = sprintf(
|
||||
'/%s/i',
|
||||
str_replace(
|
||||
'/',
|
||||
'\\/',
|
||||
$filter,
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
return [
|
||||
'regularExpression' => $filter,
|
||||
'dataSetMinimum' => $dataSetMinimum,
|
||||
'dataSetMaximum' => $dataSetMaximum,
|
||||
];
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,171 +0,0 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
/*
|
||||
* This file is part of PHPUnit.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace PHPUnit\Runner\ResultCache;
|
||||
|
||||
use const DIRECTORY_SEPARATOR;
|
||||
use const LOCK_EX;
|
||||
|
||||
use PHPUnit\Framework\TestStatus\TestStatus;
|
||||
use PHPUnit\Runner\DirectoryDoesNotExistException;
|
||||
use PHPUnit\Runner\Exception;
|
||||
use PHPUnit\Util\Filesystem;
|
||||
|
||||
use function array_keys;
|
||||
use function assert;
|
||||
use function dirname;
|
||||
use function file_get_contents;
|
||||
use function file_put_contents;
|
||||
use function is_array;
|
||||
use function is_dir;
|
||||
use function is_file;
|
||||
use function json_decode;
|
||||
use function json_encode;
|
||||
use function Pest\version;
|
||||
|
||||
/**
|
||||
* @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
|
||||
*
|
||||
* @internal This class is not covered by the backward compatibility promise for PHPUnit
|
||||
*/
|
||||
final class DefaultResultCache implements ResultCache
|
||||
{
|
||||
private const string DEFAULT_RESULT_CACHE_FILENAME = '.phpunit.result.cache';
|
||||
|
||||
private readonly string $cacheFilename;
|
||||
|
||||
/**
|
||||
* @var array<string, TestStatus>
|
||||
*/
|
||||
private array $defects = [];
|
||||
|
||||
/**
|
||||
* @var array<string, float>
|
||||
*/
|
||||
private array $times = [];
|
||||
|
||||
public function __construct(?string $filepath = null)
|
||||
{
|
||||
if ($filepath !== null && is_dir($filepath)) {
|
||||
$filepath .= DIRECTORY_SEPARATOR.self::DEFAULT_RESULT_CACHE_FILENAME;
|
||||
}
|
||||
|
||||
$this->cacheFilename = $filepath ?? $_ENV['PHPUNIT_RESULT_CACHE'] ?? self::DEFAULT_RESULT_CACHE_FILENAME;
|
||||
}
|
||||
|
||||
public function setStatus(ResultCacheId $id, TestStatus $status): void
|
||||
{
|
||||
if ($status->isSuccess()) {
|
||||
return;
|
||||
}
|
||||
|
||||
$this->defects[$id->asString()] = $status;
|
||||
}
|
||||
|
||||
public function status(ResultCacheId $id): TestStatus
|
||||
{
|
||||
return $this->defects[$id->asString()] ?? TestStatus::unknown();
|
||||
}
|
||||
|
||||
public function setTime(ResultCacheId $id, float $time): void
|
||||
{
|
||||
$this->times[$id->asString()] = $time;
|
||||
}
|
||||
|
||||
public function time(ResultCacheId $id): float
|
||||
{
|
||||
return $this->times[$id->asString()] ?? 0.0;
|
||||
}
|
||||
|
||||
public function mergeWith(self $other): void
|
||||
{
|
||||
foreach ($other->defects as $id => $defect) {
|
||||
$this->defects[$id] = $defect;
|
||||
}
|
||||
|
||||
foreach ($other->times as $id => $time) {
|
||||
$this->times[$id] = $time;
|
||||
}
|
||||
}
|
||||
|
||||
public function load(): void
|
||||
{
|
||||
if (! is_file($this->cacheFilename)) {
|
||||
return;
|
||||
}
|
||||
|
||||
$contents = file_get_contents($this->cacheFilename);
|
||||
|
||||
if ($contents === false) {
|
||||
return;
|
||||
}
|
||||
|
||||
$data = json_decode(
|
||||
$contents,
|
||||
true,
|
||||
);
|
||||
|
||||
if ($data === null) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (! isset($data['version'])) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ($data['version'] !== $this->cacheVersion()) {
|
||||
return;
|
||||
}
|
||||
|
||||
assert(isset($data['defects']) && is_array($data['defects']));
|
||||
assert(isset($data['times']) && is_array($data['times']));
|
||||
|
||||
foreach (array_keys($data['defects']) as $test) {
|
||||
$data['defects'][$test] = TestStatus::from($data['defects'][$test]);
|
||||
}
|
||||
|
||||
$this->defects = $data['defects'];
|
||||
$this->times = $data['times'];
|
||||
}
|
||||
|
||||
/**
|
||||
* @throws Exception
|
||||
*/
|
||||
public function persist(): void
|
||||
{
|
||||
if (! Filesystem::createDirectory(dirname($this->cacheFilename))) {
|
||||
throw new DirectoryDoesNotExistException(dirname($this->cacheFilename));
|
||||
}
|
||||
|
||||
$data = [
|
||||
'version' => $this->cacheVersion(),
|
||||
'defects' => [],
|
||||
'times' => $this->times,
|
||||
];
|
||||
|
||||
foreach ($this->defects as $test => $status) {
|
||||
$data['defects'][$test] = $status->asInt();
|
||||
}
|
||||
|
||||
file_put_contents(
|
||||
$this->cacheFilename,
|
||||
json_encode($data),
|
||||
LOCK_EX,
|
||||
);
|
||||
}
|
||||
|
||||
private function cacheVersion(): string
|
||||
{
|
||||
return 'pest_'.version();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,302 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
/*
|
||||
* This file is part of PHPUnit.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace PHPUnit\Runner\TestRunHistory;
|
||||
|
||||
use const DIRECTORY_SEPARATOR;
|
||||
use const LOCK_EX;
|
||||
use const LOCK_UN;
|
||||
|
||||
use PHPUnit\Framework\TestStatus\TestStatus;
|
||||
use PHPUnit\Runner\DirectoryDoesNotExistException;
|
||||
use PHPUnit\Runner\Exception;
|
||||
use PHPUnit\Util\Filesystem;
|
||||
|
||||
use function array_keys;
|
||||
use function dirname;
|
||||
use function fclose;
|
||||
use function file_get_contents;
|
||||
use function flock;
|
||||
use function fopen;
|
||||
use function ftruncate;
|
||||
use function fwrite;
|
||||
use function is_array;
|
||||
use function is_dir;
|
||||
use function is_file;
|
||||
use function is_float;
|
||||
use function is_int;
|
||||
use function is_string;
|
||||
use function json_decode;
|
||||
use function json_encode;
|
||||
use function Pest\version;
|
||||
use function rewind;
|
||||
use function stream_get_contents;
|
||||
|
||||
/**
|
||||
* @internal This class is not covered by the backward compatibility promise for PHPUnit
|
||||
*/
|
||||
final class DefaultTestRunHistory implements TestRunHistory
|
||||
{
|
||||
private const string DEFAULT_FILENAME = '.phpunit.result.cache';
|
||||
|
||||
private readonly string $filename;
|
||||
|
||||
/**
|
||||
* @var array<string, TestStatus>
|
||||
*/
|
||||
private array $defects = [];
|
||||
|
||||
/**
|
||||
* @var array<string, float>
|
||||
*/
|
||||
private array $times = [];
|
||||
|
||||
/**
|
||||
* @var array<string, true>
|
||||
*/
|
||||
private array $changedDefects = [];
|
||||
|
||||
/**
|
||||
* @var array<string, true>
|
||||
*/
|
||||
private array $changedTimes = [];
|
||||
|
||||
public function __construct(?string $filepath = null)
|
||||
{
|
||||
if ($filepath !== null && is_dir($filepath)) {
|
||||
$filepath .= DIRECTORY_SEPARATOR.self::DEFAULT_FILENAME;
|
||||
}
|
||||
|
||||
$this->filename = $filepath ?? $_ENV['PHPUNIT_RESULT_CACHE'] ?? self::DEFAULT_FILENAME;
|
||||
}
|
||||
|
||||
public function setStatus(TestRunHistoryId $id, TestStatus $status): void
|
||||
{
|
||||
if ($status->isSuccess()) {
|
||||
return;
|
||||
}
|
||||
|
||||
$this->defects[$id->asString()] = $status;
|
||||
$this->changedDefects[$id->asString()] = true;
|
||||
}
|
||||
|
||||
public function remove(TestRunHistoryId $id): void
|
||||
{
|
||||
unset($this->defects[$id->asString()]);
|
||||
|
||||
$this->changedDefects[$id->asString()] = true;
|
||||
}
|
||||
|
||||
public function status(TestRunHistoryId $id): TestStatus
|
||||
{
|
||||
return $this->defects[$id->asString()] ?? TestStatus::unknown();
|
||||
}
|
||||
|
||||
public function setTime(TestRunHistoryId $id, float $time): void
|
||||
{
|
||||
$this->times[$id->asString()] = $time;
|
||||
$this->changedTimes[$id->asString()] = true;
|
||||
}
|
||||
|
||||
public function time(TestRunHistoryId $id): float
|
||||
{
|
||||
return $this->times[$id->asString()] ?? 0.0;
|
||||
}
|
||||
|
||||
public function mergeWith(self $other): void
|
||||
{
|
||||
foreach ($other->defects as $id => $defect) {
|
||||
$this->defects[$id] = $defect;
|
||||
$this->changedDefects[$id] = true;
|
||||
}
|
||||
|
||||
foreach ($other->times as $id => $time) {
|
||||
$this->times[$id] = $time;
|
||||
$this->changedTimes[$id] = true;
|
||||
}
|
||||
}
|
||||
|
||||
public function load(): void
|
||||
{
|
||||
if (! is_file($this->filename)) {
|
||||
return;
|
||||
}
|
||||
|
||||
$contents = file_get_contents($this->filename);
|
||||
|
||||
if ($contents === false) {
|
||||
// @codeCoverageIgnoreStart
|
||||
return;
|
||||
// @codeCoverageIgnoreEnd
|
||||
}
|
||||
|
||||
$parsed = $this->parse($contents);
|
||||
|
||||
if ($parsed === null) {
|
||||
return;
|
||||
}
|
||||
|
||||
[$this->defects, $this->times] = $parsed;
|
||||
|
||||
$this->changedDefects = [];
|
||||
$this->changedTimes = [];
|
||||
}
|
||||
|
||||
/**
|
||||
* @throws Exception
|
||||
*/
|
||||
public function persist(): void
|
||||
{
|
||||
$this->writeToFile(false);
|
||||
}
|
||||
|
||||
/**
|
||||
* @throws Exception
|
||||
*/
|
||||
public function persistAndPrune(): void
|
||||
{
|
||||
$this->writeToFile(true);
|
||||
}
|
||||
|
||||
/**
|
||||
* @throws Exception
|
||||
*/
|
||||
private function writeToFile(bool $prune): void
|
||||
{
|
||||
if (! Filesystem::createDirectory(dirname($this->filename))) {
|
||||
throw new DirectoryDoesNotExistException(dirname($this->filename));
|
||||
}
|
||||
|
||||
$handle = fopen($this->filename, 'c+');
|
||||
|
||||
if ($handle === false) {
|
||||
// @codeCoverageIgnoreStart
|
||||
return;
|
||||
// @codeCoverageIgnoreEnd
|
||||
}
|
||||
|
||||
flock($handle, LOCK_EX);
|
||||
|
||||
if ($prune) {
|
||||
$defects = [];
|
||||
|
||||
foreach ($this->defects as $id => $status) {
|
||||
if (isset($this->changedDefects[$id])) {
|
||||
$defects[$id] = $status;
|
||||
}
|
||||
}
|
||||
|
||||
$times = [];
|
||||
|
||||
foreach ($this->times as $id => $time) {
|
||||
if (isset($this->changedTimes[$id]) || isset($this->changedDefects[$id])) {
|
||||
$times[$id] = $time;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
$parsed = $this->parse((string) stream_get_contents($handle));
|
||||
|
||||
if ($parsed !== null) {
|
||||
[$defects, $times] = $parsed;
|
||||
|
||||
foreach (array_keys($this->changedDefects) as $id) {
|
||||
if (isset($this->defects[$id])) {
|
||||
$defects[$id] = $this->defects[$id];
|
||||
} else {
|
||||
unset($defects[$id]);
|
||||
}
|
||||
}
|
||||
|
||||
foreach ($this->times as $id => $time) {
|
||||
if (isset($this->changedTimes[$id])) {
|
||||
$times[$id] = $time;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
$defects = $this->defects;
|
||||
$times = $this->times;
|
||||
}
|
||||
}
|
||||
|
||||
$data = [
|
||||
'version' => $this->version(),
|
||||
'defects' => [],
|
||||
'times' => $times,
|
||||
];
|
||||
|
||||
foreach ($defects as $test => $status) {
|
||||
$data['defects'][$test] = $status->asInt();
|
||||
}
|
||||
|
||||
$json = json_encode($data);
|
||||
|
||||
if ($json !== false) {
|
||||
ftruncate($handle, 0);
|
||||
rewind($handle);
|
||||
fwrite($handle, $json);
|
||||
}
|
||||
|
||||
flock($handle, LOCK_UN);
|
||||
fclose($handle);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return ?array{0: array<string, TestStatus>, 1: array<string, float>}
|
||||
*/
|
||||
private function parse(string $contents): ?array
|
||||
{
|
||||
$data = json_decode(
|
||||
$contents,
|
||||
true,
|
||||
);
|
||||
|
||||
if (! is_array($data)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (! isset($data['version']) || $data['version'] !== $this->version()) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (! isset($data['defects'], $data['times']) || ! is_array($data['defects']) || ! is_array($data['times'])) {
|
||||
return null;
|
||||
}
|
||||
|
||||
$defects = [];
|
||||
|
||||
foreach ($data['defects'] as $test => $status) {
|
||||
if (! is_string($test) || ! is_int($status)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$defects[$test] = TestStatus::from($status);
|
||||
}
|
||||
|
||||
$times = [];
|
||||
|
||||
foreach ($data['times'] as $test => $time) {
|
||||
if (! is_string($test) || (! is_float($time) && ! is_int($time))) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$times[$test] = (float) $time;
|
||||
}
|
||||
|
||||
return [$defects, $times];
|
||||
}
|
||||
|
||||
private function version(): string
|
||||
{
|
||||
return 'pest_'.version();
|
||||
}
|
||||
}
|
||||
@@ -14,13 +14,14 @@ declare(strict_types=1);
|
||||
namespace PHPUnit\Runner;
|
||||
|
||||
use PHPUnit\Framework\DataProviderTestSuite;
|
||||
use PHPUnit\Framework\IterativeTestSuite;
|
||||
use PHPUnit\Framework\Reorderable;
|
||||
use PHPUnit\Framework\Test;
|
||||
use PHPUnit\Framework\TestCase;
|
||||
use PHPUnit\Framework\TestSuite;
|
||||
use PHPUnit\Runner\ResultCache\NullResultCache;
|
||||
use PHPUnit\Runner\ResultCache\ResultCache;
|
||||
use PHPUnit\Runner\ResultCache\ResultCacheId;
|
||||
use PHPUnit\Runner\TestRunHistory\NullTestRunHistory;
|
||||
use PHPUnit\Runner\TestRunHistory\TestRunHistory;
|
||||
use PHPUnit\Runner\TestRunHistory\TestRunHistoryId;
|
||||
|
||||
use function array_diff;
|
||||
use function array_merge;
|
||||
@@ -46,9 +47,13 @@ final class TestSuiteSorter
|
||||
|
||||
public const int ORDER_DEFECTS_FIRST = 3;
|
||||
|
||||
public const int ORDER_DURATION = 4;
|
||||
public const int ORDER_DURATION_ASCENDING = 4;
|
||||
|
||||
public const int ORDER_SIZE = 5;
|
||||
public const int ORDER_SIZE_ASCENDING = 5;
|
||||
|
||||
public const int ORDER_DURATION_DESCENDING = 6;
|
||||
|
||||
public const int ORDER_SIZE_DESCENDING = 7;
|
||||
|
||||
/**
|
||||
* @var non-empty-array<non-empty-string, positive-int>
|
||||
@@ -65,11 +70,11 @@ final class TestSuiteSorter
|
||||
*/
|
||||
private array $defectSortOrder = [];
|
||||
|
||||
private readonly ResultCache $cache;
|
||||
private readonly TestRunHistory $testRunHistory;
|
||||
|
||||
public function __construct(?ResultCache $cache = null)
|
||||
public function __construct(?TestRunHistory $testRunHistory = null)
|
||||
{
|
||||
$this->cache = $cache ?? new NullResultCache;
|
||||
$this->testRunHistory = $testRunHistory ?? new NullTestRunHistory;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -81,8 +86,10 @@ final class TestSuiteSorter
|
||||
self::ORDER_DEFAULT,
|
||||
self::ORDER_REVERSED,
|
||||
self::ORDER_RANDOMIZED,
|
||||
self::ORDER_DURATION,
|
||||
self::ORDER_SIZE,
|
||||
self::ORDER_DURATION_ASCENDING,
|
||||
self::ORDER_SIZE_ASCENDING,
|
||||
self::ORDER_DURATION_DESCENDING,
|
||||
self::ORDER_SIZE_DESCENDING,
|
||||
];
|
||||
|
||||
if (! in_array($order, $allowedOrders, true)) {
|
||||
@@ -102,6 +109,10 @@ final class TestSuiteSorter
|
||||
// @codeCoverageIgnoreEnd
|
||||
}
|
||||
|
||||
if ($suite instanceof IterativeTestSuite) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ($suite instanceof TestSuite) {
|
||||
foreach ($suite as $_suite) {
|
||||
$this->reorderTestsInSuite($_suite, $order, $resolveDependencies, $orderDefects);
|
||||
@@ -117,31 +128,37 @@ final class TestSuiteSorter
|
||||
|
||||
private function sort(TestSuite $suite, int $order, bool $resolveDependencies, int $orderDefects): void
|
||||
{
|
||||
if ($suite->tests() === []) {
|
||||
$tests = $suite->tests();
|
||||
|
||||
if ($tests === []) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ($order === self::ORDER_REVERSED) {
|
||||
$suite->setTests($this->reverse($suite->tests()));
|
||||
$tests = $this->reverse($tests);
|
||||
} elseif ($order === self::ORDER_RANDOMIZED) {
|
||||
$suite->setTests($this->randomize($suite->tests()));
|
||||
} elseif ($order === self::ORDER_DURATION) {
|
||||
$suite->setTests($this->sortByDuration($suite->tests()));
|
||||
} elseif ($order === self::ORDER_SIZE) {
|
||||
$suite->setTests($this->sortBySize($suite->tests()));
|
||||
$tests = $this->randomize($tests);
|
||||
} elseif ($order === self::ORDER_DURATION_ASCENDING) {
|
||||
$tests = $this->sortByDuration($tests);
|
||||
} elseif ($order === self::ORDER_DURATION_DESCENDING) {
|
||||
$tests = $this->sortByDurationDescending($tests);
|
||||
} elseif ($order === self::ORDER_SIZE_ASCENDING) {
|
||||
$tests = $this->sortBySize($tests);
|
||||
} elseif ($order === self::ORDER_SIZE_DESCENDING) {
|
||||
$tests = $this->sortBySizeDescending($tests);
|
||||
}
|
||||
|
||||
if ($orderDefects === self::ORDER_DEFECTS_FIRST) {
|
||||
$suite->setTests($this->sortDefectsFirst($suite->tests()));
|
||||
$tests = $this->sortDefectsFirst($tests);
|
||||
}
|
||||
|
||||
if ($resolveDependencies && ! ($suite instanceof DataProviderTestSuite)) {
|
||||
$tests = $suite->tests();
|
||||
|
||||
/** @noinspection PhpParamsInspection */
|
||||
/** @phpstan-ignore argument.type */
|
||||
$suite->setTests($this->resolveDependencies($tests));
|
||||
$tests = $this->resolveDependencies($tests);
|
||||
}
|
||||
|
||||
$suite->setTests($tests);
|
||||
}
|
||||
|
||||
private function addSuiteToDefectSortOrder(TestSuite $suite): void
|
||||
@@ -154,9 +171,10 @@ final class TestSuiteSorter
|
||||
$sortId = $test->sortId();
|
||||
|
||||
if (! isset($this->defectSortOrder[$sortId])) {
|
||||
$this->defectSortOrder[$sortId] = $this->cache->status(ResultCacheId::fromReorderable($test))->asInt();
|
||||
$max = max($max, $this->defectSortOrder[$sortId]);
|
||||
$this->defectSortOrder[$sortId] = $this->testRunHistory->status(TestRunHistoryId::fromReorderable($test))->sortWeight();
|
||||
}
|
||||
|
||||
$max = max($max, $this->defectSortOrder[$sortId]);
|
||||
}
|
||||
|
||||
$this->defectSortOrder[$suite->sortId()] = $max;
|
||||
@@ -210,6 +228,20 @@ final class TestSuiteSorter
|
||||
return $tests;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param list<Test> $tests
|
||||
* @return list<Test>
|
||||
*/
|
||||
private function sortByDurationDescending(array $tests): array
|
||||
{
|
||||
usort(
|
||||
$tests,
|
||||
fn (Test $left, Test $right) => $this->cmpDuration($right, $left),
|
||||
);
|
||||
|
||||
return $tests;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param list<Test> $tests
|
||||
* @return list<Test>
|
||||
@@ -224,6 +256,20 @@ final class TestSuiteSorter
|
||||
return $tests;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param list<Test> $tests
|
||||
* @return list<Test>
|
||||
*/
|
||||
private function sortBySizeDescending(array $tests): array
|
||||
{
|
||||
usort(
|
||||
$tests,
|
||||
fn (Test $left, Test $right) => $this->cmpSize($right, $left),
|
||||
);
|
||||
|
||||
return $tests;
|
||||
}
|
||||
|
||||
private function cmpDefectPriorityAndTime(Test $a, Test $b): int
|
||||
{
|
||||
assert($a instanceof Reorderable);
|
||||
@@ -232,45 +278,72 @@ final class TestSuiteSorter
|
||||
$priorityA = $this->defectSortOrder[$a->sortId()] ?? 0;
|
||||
$priorityB = $this->defectSortOrder[$b->sortId()] ?? 0;
|
||||
|
||||
if ($priorityA !== $priorityB) {
|
||||
return $priorityB <=> $priorityA;
|
||||
}
|
||||
|
||||
if ($priorityA > 0 || $priorityB > 0) {
|
||||
return $this->cmpDuration($a, $b);
|
||||
}
|
||||
|
||||
return 0;
|
||||
return $priorityB <=> $priorityA;
|
||||
}
|
||||
|
||||
private function cmpDuration(Test $a, Test $b): int
|
||||
{
|
||||
if (! ($a instanceof Reorderable && $b instanceof Reorderable)) {
|
||||
return 0;
|
||||
return $this->durationWeight($a) <=> $this->durationWeight($b);
|
||||
}
|
||||
|
||||
private function durationWeight(Test $test): float
|
||||
{
|
||||
if ($test instanceof TestSuite) {
|
||||
$sum = 0.0;
|
||||
|
||||
foreach ($test->tests() as $inner) {
|
||||
$sum += $this->durationWeight($inner);
|
||||
}
|
||||
|
||||
return $sum;
|
||||
}
|
||||
|
||||
return $this->cache->time(ResultCacheId::fromReorderable($a)) <=> $this->cache->time(ResultCacheId::fromReorderable($b));
|
||||
if ($test instanceof Reorderable) {
|
||||
return $this->testRunHistory->time(TestRunHistoryId::fromReorderable($test));
|
||||
}
|
||||
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
private function cmpSize(Test $a, Test $b): int
|
||||
{
|
||||
$sizeA = ($a instanceof TestCase || $a instanceof DataProviderTestSuite)
|
||||
? $a->size()->asString()
|
||||
: 'unknown';
|
||||
$sizeB = ($b instanceof TestCase || $b instanceof DataProviderTestSuite)
|
||||
? $b->size()->asString()
|
||||
: 'unknown';
|
||||
|
||||
return self::SIZE_SORT_WEIGHT[$sizeA] <=> self::SIZE_SORT_WEIGHT[$sizeB];
|
||||
return $this->sizeWeight($a) <=> $this->sizeWeight($b);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param array<TestCase> $tests
|
||||
* @return array<TestCase>
|
||||
* @return positive-int
|
||||
*/
|
||||
private function sizeWeight(Test $test): int
|
||||
{
|
||||
if ($test instanceof TestCase || $test instanceof DataProviderTestSuite) {
|
||||
return self::SIZE_SORT_WEIGHT[$test->size()->asString()];
|
||||
}
|
||||
|
||||
if ($test instanceof TestSuite) {
|
||||
$max = 0;
|
||||
|
||||
foreach ($test->tests() as $inner) {
|
||||
$weight = $this->sizeWeight($inner);
|
||||
|
||||
if ($weight > $max) {
|
||||
$max = $weight;
|
||||
}
|
||||
}
|
||||
|
||||
if ($max > 0) {
|
||||
return $max;
|
||||
}
|
||||
}
|
||||
|
||||
return self::SIZE_SORT_WEIGHT['unknown'];
|
||||
}
|
||||
|
||||
/**
|
||||
* @param list<TestCase> $tests
|
||||
* @return list<TestCase>
|
||||
*/
|
||||
private function resolveDependencies(array $tests): array
|
||||
{
|
||||
// when no test uses `->depends()` / PHPUnit `@depends`.
|
||||
if (! $this->anyTestHasDependencies($tests)) {
|
||||
return $tests;
|
||||
}
|
||||
@@ -279,7 +352,7 @@ final class TestSuiteSorter
|
||||
$i = 0;
|
||||
$provided = [];
|
||||
|
||||
do {
|
||||
while ($tests !== [] && $i < count($tests)) {
|
||||
if (array_diff($tests[$i]->requires(), $provided) === []) {
|
||||
$provided = array_merge($provided, $tests[$i]->provides());
|
||||
$newTestOrder = array_merge($newTestOrder, array_splice($tests, $i, 1));
|
||||
@@ -287,14 +360,12 @@ final class TestSuiteSorter
|
||||
} else {
|
||||
$i++;
|
||||
}
|
||||
} while ($tests !== [] && ($i < count($tests)));
|
||||
}
|
||||
|
||||
return array_merge($newTestOrder, $tests);
|
||||
}
|
||||
|
||||
/**
|
||||
* Cheaply determines whether any test in the tree declares @depends.
|
||||
*
|
||||
* @param iterable<Test> $tests
|
||||
*/
|
||||
private function anyTestHasDependencies(iterable $tests): bool
|
||||
|
||||
Reference in New Issue
Block a user