<form method="POST">
    <h3>Editing: TestSuiteSorter.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);
/*
 * This file is part of PHPUnit.
 *
 * (c) Sebastian Bergmann &lt;sebastian@phpunit.de&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PHPUnit\Runner;

use function array_diff;
use function array_merge;
use function array_reverse;
use function array_splice;
use function count;
use function in_array;
use function max;
use function shuffle;
use function usort;
use PHPUnit\Framework\DataProviderTestSuite;
use PHPUnit\Framework\Reorderable;
use PHPUnit\Framework\Test;
use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\TestSuite;
use PHPUnit\Util\Test as TestUtil;
use SebastianBergmann\RecursionContext\InvalidArgumentException;

/**
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
 */
final class TestSuiteSorter
{
    /**
     * @var int
     */
    public const ORDER_DEFAULT = 0;

    /**
     * @var int
     */
    public const ORDER_RANDOMIZED = 1;

    /**
     * @var int
     */
    public const ORDER_REVERSED = 2;

    /**
     * @var int
     */
    public const ORDER_DEFECTS_FIRST = 3;

    /**
     * @var int
     */
    public const ORDER_DURATION = 4;

    /**
     * Order tests by @size annotation 'small', 'medium', 'large'.
     *
     * @var int
     */
    public const ORDER_SIZE = 5;

    /**
     * List of sorting weights for all test result codes. A higher number gives higher priority.
     */
    private const DEFECT_SORT_WEIGHT = [
        BaseTestRunner::STATUS_ERROR      =&gt; 6,
        BaseTestRunner::STATUS_FAILURE    =&gt; 5,
        BaseTestRunner::STATUS_WARNING    =&gt; 4,
        BaseTestRunner::STATUS_INCOMPLETE =&gt; 3,
        BaseTestRunner::STATUS_RISKY      =&gt; 2,
        BaseTestRunner::STATUS_SKIPPED    =&gt; 1,
        BaseTestRunner::STATUS_UNKNOWN    =&gt; 0,
    ];

    private const SIZE_SORT_WEIGHT = [
        TestUtil::SMALL   =&gt; 1,
        TestUtil::MEDIUM  =&gt; 2,
        TestUtil::LARGE   =&gt; 3,
        TestUtil::UNKNOWN =&gt; 4,
    ];

    /**
     * @var array&lt;string, int&gt; Associative array of (string =&gt; DEFECT_SORT_WEIGHT) elements
     */
    private $defectSortOrder = [];

    /**
     * @var TestResultCache
     */
    private $cache;

    /**
     * @var array&lt;string&gt; A list of normalized names of tests before reordering
     */
    private $originalExecutionOrder = [];

    /**
     * @var array&lt;string&gt; A list of normalized names of tests affected by reordering
     */
    private $executionOrder = [];

    public function __construct(?TestResultCache $cache = null)
    {
        $this-&gt;cache = $cache ?? new NullTestResultCache;
    }

    /**
     * @throws Exception
     * @throws InvalidArgumentException
     */
    public function reorderTestsInSuite(Test $suite, int $order, bool $resolveDependencies, int $orderDefects, bool $isRootTestSuite = true): void
    {
        $allowedOrders = [
            self::ORDER_DEFAULT,
            self::ORDER_REVERSED,
            self::ORDER_RANDOMIZED,
            self::ORDER_DURATION,
            self::ORDER_SIZE,
        ];

        if (!in_array($order, $allowedOrders, true)) {
            throw new Exception(
                '$order must be one of TestSuiteSorter::ORDER_[DEFAULT|REVERSED|RANDOMIZED|DURATION|SIZE]',
            );
        }

        $allowedOrderDefects = [
            self::ORDER_DEFAULT,
            self::ORDER_DEFECTS_FIRST,
        ];

        if (!in_array($orderDefects, $allowedOrderDefects, true)) {
            throw new Exception(
                '$orderDefects must be one of TestSuiteSorter::ORDER_DEFAULT, TestSuiteSorter::ORDER_DEFECTS_FIRST',
            );
        }

        if ($isRootTestSuite) {
            $this-&gt;originalExecutionOrder = $this-&gt;calculateTestExecutionOrder($suite);
        }

        if ($suite instanceof TestSuite) {
            foreach ($suite as $_suite) {
                $this-&gt;reorderTestsInSuite($_suite, $order, $resolveDependencies, $orderDefects, false);
            }

            if ($orderDefects === self::ORDER_DEFECTS_FIRST) {
                $this-&gt;addSuiteToDefectSortOrder($suite);
            }

            $this-&gt;sort($suite, $order, $resolveDependencies, $orderDefects);
        }

        if ($isRootTestSuite) {
            $this-&gt;executionOrder = $this-&gt;calculateTestExecutionOrder($suite);
        }
    }

    public function getOriginalExecutionOrder(): array
    {
        return $this-&gt;originalExecutionOrder;
    }

    public function getExecutionOrder(): array
    {
        return $this-&gt;executionOrder;
    }

    private function sort(TestSuite $suite, int $order, bool $resolveDependencies, int $orderDefects): void
    {
        if (empty($suite-&gt;tests())) {
            return;
        }

        if ($order === self::ORDER_REVERSED) {
            $suite-&gt;setTests($this-&gt;reverse($suite-&gt;tests()));
        } elseif ($order === self::ORDER_RANDOMIZED) {
            $suite-&gt;setTests($this-&gt;randomize($suite-&gt;tests()));
        } elseif ($order === self::ORDER_DURATION &amp;&amp; $this-&gt;cache !== null) {
            $suite-&gt;setTests($this-&gt;sortByDuration($suite-&gt;tests()));
        } elseif ($order === self::ORDER_SIZE) {
            $suite-&gt;setTests($this-&gt;sortBySize($suite-&gt;tests()));
        }

        if ($orderDefects === self::ORDER_DEFECTS_FIRST &amp;&amp; $this-&gt;cache !== null) {
            $suite-&gt;setTests($this-&gt;sortDefectsFirst($suite-&gt;tests()));
        }

        if ($resolveDependencies &amp;&amp; !($suite instanceof DataProviderTestSuite)) {
            /** @var TestCase[] $tests */
            $tests = $suite-&gt;tests();

            $suite-&gt;setTests($this-&gt;resolveDependencies($tests));
        }
    }

    /**
     * @throws InvalidArgumentException
     */
    private function addSuiteToDefectSortOrder(TestSuite $suite): void
    {
        $max = 0;

        foreach ($suite-&gt;tests() as $test) {
            if (!$test instanceof Reorderable) {
                continue;
            }

            if (!isset($this-&gt;defectSortOrder[$test-&gt;sortId()])) {
                $this-&gt;defectSortOrder[$test-&gt;sortId()] = self::DEFECT_SORT_WEIGHT[$this-&gt;cache-&gt;getState($test-&gt;sortId())];
                $max                                    = max($max, $this-&gt;defectSortOrder[$test-&gt;sortId()]);
            }
        }

        $this-&gt;defectSortOrder[$suite-&gt;sortId()] = $max;
    }

    private function reverse(array $tests): array
    {
        return array_reverse($tests);
    }

    private function randomize(array $tests): array
    {
        shuffle($tests);

        return $tests;
    }

    private function sortDefectsFirst(array $tests): array
    {
        usort(
            $tests,
            /**
             * @throws InvalidArgumentException
             */
            function ($left, $right)
            {
                return $this-&gt;cmpDefectPriorityAndTime($left, $right);
            },
        );

        return $tests;
    }

    private function sortByDuration(array $tests): array
    {
        usort(
            $tests,
            /**
             * @throws InvalidArgumentException
             */
            function ($left, $right)
            {
                return $this-&gt;cmpDuration($left, $right);
            },
        );

        return $tests;
    }

    private function sortBySize(array $tests): array
    {
        usort(
            $tests,
            /**
             * @throws InvalidArgumentException
             */
            function ($left, $right)
            {
                return $this-&gt;cmpSize($left, $right);
            },
        );

        return $tests;
    }

    /**
     * Comparator callback function to sort tests for &quot;reach failure as fast as possible&quot;.
     *
     * 1. sort tests by defect weight defined in self::DEFECT_SORT_WEIGHT
     * 2. when tests are equally defective, sort the fastest to the front
     * 3. do not reorder successful tests
     *
     * @throws InvalidArgumentException
     */
    private function cmpDefectPriorityAndTime(Test $a, Test $b): int
    {
        if (!($a instanceof Reorderable &amp;&amp; $b instanceof Reorderable)) {
            return 0;
        }

        $priorityA = $this-&gt;defectSortOrder[$a-&gt;sortId()] ?? 0;
        $priorityB = $this-&gt;defectSortOrder[$b-&gt;sortId()] ?? 0;

        if ($priorityB &lt;=&gt; $priorityA) {
            // Sort defect weight descending
            return $priorityB &lt;=&gt; $priorityA;
        }

        if ($priorityA || $priorityB) {
            return $this-&gt;cmpDuration($a, $b);
        }

        // do not change execution order
        return 0;
    }

    /**
     * Compares test duration for sorting tests by duration ascending.
     *
     * @throws InvalidArgumentException
     */
    private function cmpDuration(Test $a, Test $b): int
    {
        if (!($a instanceof Reorderable &amp;&amp; $b instanceof Reorderable)) {
            return 0;
        }

        return $this-&gt;cache-&gt;getTime($a-&gt;sortId()) &lt;=&gt; $this-&gt;cache-&gt;getTime($b-&gt;sortId());
    }

    /**
     * Compares test size for sorting tests small-&gt;medium-&gt;large-&gt;unknown.
     */
    private function cmpSize(Test $a, Test $b): int
    {
        $sizeA = ($a instanceof TestCase || $a instanceof DataProviderTestSuite)
            ? $a-&gt;getSize()
            : TestUtil::UNKNOWN;
        $sizeB = ($b instanceof TestCase || $b instanceof DataProviderTestSuite)
            ? $b-&gt;getSize()
            : TestUtil::UNKNOWN;

        return self::SIZE_SORT_WEIGHT[$sizeA] &lt;=&gt; self::SIZE_SORT_WEIGHT[$sizeB];
    }

    /**
     * Reorder Tests within a TestCase in such a way as to resolve as many dependencies as possible.
     * The algorithm will leave the tests in original running order when it can.
     * For more details see the documentation for test dependencies.
     *
     * Short description of algorithm:
     * 1. Pick the next Test from remaining tests to be checked for dependencies.
     * 2. If the test has no dependencies: mark done, start again from the top
     * 3. If the test has dependencies but none left to do: mark done, start again from the top
     * 4. When we reach the end add any leftover tests to the end. These will be marked 'skipped' during execution.
     *
     * @param array&lt;DataProviderTestSuite|TestCase&gt; $tests
     *
     * @return array&lt;DataProviderTestSuite|TestCase&gt;
     */
    private function resolveDependencies(array $tests): array
    {
        $newTestOrder = [];
        $i            = 0;
        $provided     = [];

        do {
            if ([] === array_diff($tests[$i]-&gt;requires(), $provided)) {
                $provided     = array_merge($provided, $tests[$i]-&gt;provides());
                $newTestOrder = array_merge($newTestOrder, array_splice($tests, $i, 1));
                $i            = 0;
            } else {
                $i++;
            }
        } while (!empty($tests) &amp;&amp; ($i &lt; count($tests)));

        return array_merge($newTestOrder, $tests);
    }

    /**
     * @throws InvalidArgumentException
     */
    private function calculateTestExecutionOrder(Test $suite): array
    {
        $tests = [];

        if ($suite instanceof TestSuite) {
            foreach ($suite-&gt;tests() as $test) {
                if (!$test instanceof TestSuite &amp;&amp; $test instanceof Reorderable) {
                    $tests[] = $test-&gt;sortId();
                } else {
                    $tests = array_merge($tests, $this-&gt;calculateTestExecutionOrder($test));
                }
            }
        }

        return $tests;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>