<form method="POST">
    <h3>Editing: TestSuite.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\Framework;

use const PHP_EOL;
use function array_keys;
use function array_map;
use function array_merge;
use function array_slice;
use function array_unique;
use function basename;
use function call_user_func;
use function class_exists;
use function count;
use function dirname;
use function get_declared_classes;
use function implode;
use function is_bool;
use function is_callable;
use function is_file;
use function is_object;
use function is_string;
use function method_exists;
use function preg_match;
use function preg_quote;
use function sprintf;
use function strpos;
use function substr;
use Iterator;
use IteratorAggregate;
use PHPUnit\Runner\BaseTestRunner;
use PHPUnit\Runner\Filter\Factory;
use PHPUnit\Runner\PhptTestCase;
use PHPUnit\Util\FileLoader;
use PHPUnit\Util\Reflection;
use PHPUnit\Util\Test as TestUtil;
use ReflectionClass;
use ReflectionException;
use ReflectionMethod;
use SebastianBergmann\CodeCoverage\UnintentionallyCoveredCodeException;
use Throwable;

/**
 * @template-implements IteratorAggregate&lt;int, Test&gt;
 *
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
 */
class TestSuite implements IteratorAggregate, Reorderable, SelfDescribing, Test
{
    /**
     * Enable or disable the backup and restoration of the $GLOBALS array.
     *
     * @var bool
     */
    protected $backupGlobals;

    /**
     * Enable or disable the backup and restoration of static attributes.
     *
     * @var bool
     */
    protected $backupStaticAttributes;

    /**
     * @var bool
     */
    protected $runTestInSeparateProcess = false;

    /**
     * The name of the test suite.
     *
     * @var string
     */
    protected $name = '';

    /**
     * The test groups of the test suite.
     *
     * @psalm-var array&lt;string,list&lt;Test&gt;&gt;
     */
    protected $groups = [];

    /**
     * The tests in the test suite.
     *
     * @var Test[]
     */
    protected $tests = [];

    /**
     * The number of tests in the test suite.
     *
     * @var int
     */
    protected $numTests = -1;

    /**
     * @var bool
     */
    protected $testCase = false;

    /**
     * @var string[]
     */
    protected $foundClasses = [];

    /**
     * @var null|list&lt;ExecutionOrderDependency&gt;
     */
    protected $providedTests;

    /**
     * @var null|list&lt;ExecutionOrderDependency&gt;
     */
    protected $requiredTests;

    /**
     * @var bool
     */
    private $beStrictAboutChangesToGlobalState;

    /**
     * @var Factory
     */
    private $iteratorFilter;

    /**
     * @var int
     */
    private $declaredClassesPointer;

    /**
     * @psalm-var array&lt;int,string&gt;
     */
    private $warnings = [];

    /**
     * Constructs a new TestSuite.
     *
     *   - PHPUnit\Framework\TestSuite() constructs an empty TestSuite.
     *
     *   - PHPUnit\Framework\TestSuite(ReflectionClass) constructs a
     *     TestSuite from the given class.
     *
     *   - PHPUnit\Framework\TestSuite(ReflectionClass, String)
     *     constructs a TestSuite from the given class with the given
     *     name.
     *
     *   - PHPUnit\Framework\TestSuite(String) either constructs a
     *     TestSuite from the given class (if the passed string is the
     *     name of an existing class) or constructs an empty TestSuite
     *     with the given name.
     *
     * @param ReflectionClass|string $theClass
     *
     * @throws Exception
     */
    public function __construct($theClass = '', string $name = '')
    {
        if (!is_string($theClass) &amp;&amp; !$theClass instanceof ReflectionClass) {
            throw InvalidArgumentException::create(
                1,
                'ReflectionClass object or string',
            );
        }

        $this-&gt;declaredClassesPointer = count(get_declared_classes());

        if (!$theClass instanceof ReflectionClass) {
            if (class_exists($theClass, true)) {
                if ($name === '') {
                    $name = $theClass;
                }

                try {
                    $theClass = new ReflectionClass($theClass);
                } catch (ReflectionException $e) {
                    throw new Exception(
                        $e-&gt;getMessage(),
                        $e-&gt;getCode(),
                        $e,
                    );
                }
                // @codeCoverageIgnoreEnd
            } else {
                $this-&gt;setName($theClass);

                return;
            }
        }

        if (!$theClass-&gt;isSubclassOf(TestCase::class)) {
            $this-&gt;setName((string) $theClass);

            return;
        }

        if ($name !== '') {
            $this-&gt;setName($name);
        } else {
            $this-&gt;setName($theClass-&gt;getName());
        }

        $constructor = $theClass-&gt;getConstructor();

        if ($constructor !== null &amp;&amp;
            !$constructor-&gt;isPublic()) {
            $this-&gt;addTest(
                new WarningTestCase(
                    sprintf(
                        'Class &quot;%s&quot; has no public constructor.',
                        $theClass-&gt;getName(),
                    ),
                ),
            );

            return;
        }

        foreach ((new Reflection)-&gt;publicMethodsInTestClass($theClass) as $method) {
            if (!TestUtil::isTestMethod($method)) {
                continue;
            }

            $this-&gt;addTestMethod($theClass, $method);
        }

        if (empty($this-&gt;tests)) {
            $this-&gt;addTest(
                new WarningTestCase(
                    sprintf(
                        'No tests found in class &quot;%s&quot;.',
                        $theClass-&gt;getName(),
                    ),
                ),
            );
        }

        $this-&gt;testCase = true;
    }

    /**
     * Returns a string representation of the test suite.
     */
    public function toString(): string
    {
        return $this-&gt;getName();
    }

    /**
     * Adds a test to the suite.
     *
     * @param array $groups
     */
    public function addTest(Test $test, $groups = []): void
    {
        try {
            $class = new ReflectionClass($test);
            // @codeCoverageIgnoreStart
        } catch (ReflectionException $e) {
            throw new Exception(
                $e-&gt;getMessage(),
                $e-&gt;getCode(),
                $e,
            );
        }
        // @codeCoverageIgnoreEnd

        if (!$class-&gt;isAbstract()) {
            $this-&gt;tests[] = $test;
            $this-&gt;clearCaches();

            if ($test instanceof self &amp;&amp; empty($groups)) {
                $groups = $test-&gt;getGroups();
            }

            if ($this-&gt;containsOnlyVirtualGroups($groups)) {
                $groups[] = 'default';
            }

            foreach ($groups as $group) {
                if (!isset($this-&gt;groups[$group])) {
                    $this-&gt;groups[$group] = [$test];
                } else {
                    $this-&gt;groups[$group][] = $test;
                }
            }

            if ($test instanceof TestCase) {
                $test-&gt;setGroups($groups);
            }
        }
    }

    /**
     * Adds the tests from the given class to the suite.
     *
     * @psalm-param object|class-string $testClass
     *
     * @throws Exception
     */
    public function addTestSuite($testClass): void
    {
        if (!(is_object($testClass) || (is_string($testClass) &amp;&amp; class_exists($testClass)))) {
            throw InvalidArgumentException::create(
                1,
                'class name or object',
            );
        }

        if (!is_object($testClass)) {
            try {
                $testClass = new ReflectionClass($testClass);
                // @codeCoverageIgnoreStart
            } catch (ReflectionException $e) {
                throw new Exception(
                    $e-&gt;getMessage(),
                    $e-&gt;getCode(),
                    $e,
                );
            }
            // @codeCoverageIgnoreEnd
        }

        if ($testClass instanceof self) {
            $this-&gt;addTest($testClass);
        } elseif ($testClass instanceof ReflectionClass) {
            $suiteMethod = false;

            if (!$testClass-&gt;isAbstract() &amp;&amp; $testClass-&gt;hasMethod(BaseTestRunner::SUITE_METHODNAME)) {
                try {
                    $method = $testClass-&gt;getMethod(
                        BaseTestRunner::SUITE_METHODNAME,
                    );
                    // @codeCoverageIgnoreStart
                } catch (ReflectionException $e) {
                    throw new Exception(
                        $e-&gt;getMessage(),
                        $e-&gt;getCode(),
                        $e,
                    );
                }
                // @codeCoverageIgnoreEnd

                if ($method-&gt;isStatic()) {
                    $this-&gt;addTest(
                        $method-&gt;invoke(null, $testClass-&gt;getName()),
                    );

                    $suiteMethod = true;
                }
            }

            if (!$suiteMethod &amp;&amp; !$testClass-&gt;isAbstract() &amp;&amp; $testClass-&gt;isSubclassOf(TestCase::class)) {
                $this-&gt;addTest(new self($testClass));
            }
        } else {
            throw new Exception;
        }
    }

    public function addWarning(string $warning): void
    {
        $this-&gt;warnings[] = $warning;
    }

    /**
     * Wraps both &lt;code&gt;addTest()&lt;/code&gt; and &lt;code&gt;addTestSuite&lt;/code&gt;
     * as well as the separate import statements for the user's convenience.
     *
     * If the named file cannot be read or there are no new tests that can be
     * added, a &lt;code&gt;PHPUnit\Framework\WarningTestCase&lt;/code&gt; will be created instead,
     * leaving the current test run untouched.
     *
     * @throws Exception
     */
    public function addTestFile(string $filename): void
    {
        if (is_file($filename) &amp;&amp; substr($filename, -5) === '.phpt') {
            $this-&gt;addTest(new PhptTestCase($filename));

            $this-&gt;declaredClassesPointer = count(get_declared_classes());

            return;
        }

        $numTests = count($this-&gt;tests);

        // The given file may contain further stub classes in addition to the
        // test class itself. Figure out the actual test class.
        $filename   = FileLoader::checkAndLoad($filename);
        $newClasses = array_slice(get_declared_classes(), $this-&gt;declaredClassesPointer);

        // The diff is empty in case a parent class (with test methods) is added
        // AFTER a child class that inherited from it. To account for that case,
        // accumulate all discovered classes, so the parent class may be found in
        // a later invocation.
        if (!empty($newClasses)) {
            // On the assumption that test classes are defined first in files,
            // process discovered classes in approximate LIFO order, so as to
            // avoid unnecessary reflection.
            $this-&gt;foundClasses           = array_merge($newClasses, $this-&gt;foundClasses);
            $this-&gt;declaredClassesPointer = count(get_declared_classes());
        }

        // The test class's name must match the filename, either in full, or as
        // a PEAR/PSR-0 prefixed short name ('NameSpace_ShortName'), or as a
        // PSR-1 local short name ('NameSpace\ShortName'). The comparison must be
        // anchored to prevent false-positive matches (e.g., 'OtherShortName').
        $shortName      = basename($filename, '.php');
        $shortNameRegEx = '/(?:^|_|\\\\)' . preg_quote($shortName, '/') . '$/';

        foreach ($this-&gt;foundClasses as $i =&gt; $className) {
            if (preg_match($shortNameRegEx, $className)) {
                try {
                    $class = new ReflectionClass($className);
                    // @codeCoverageIgnoreStart
                } catch (ReflectionException $e) {
                    throw new Exception(
                        $e-&gt;getMessage(),
                        $e-&gt;getCode(),
                        $e,
                    );
                }
                // @codeCoverageIgnoreEnd

                if ($class-&gt;getFileName() == $filename) {
                    $newClasses = [$className];
                    unset($this-&gt;foundClasses[$i]);

                    break;
                }
            }
        }

        foreach ($newClasses as $className) {
            try {
                $class = new ReflectionClass($className);
                // @codeCoverageIgnoreStart
            } catch (ReflectionException $e) {
                throw new Exception(
                    $e-&gt;getMessage(),
                    $e-&gt;getCode(),
                    $e,
                );
            }
            // @codeCoverageIgnoreEnd

            if (dirname($class-&gt;getFileName()) === __DIR__) {
                continue;
            }

            if ($class-&gt;isAbstract() &amp;&amp; $class-&gt;isSubclassOf(TestCase::class)) {
                $this-&gt;addWarning(
                    sprintf(
                        'Abstract test case classes with &quot;Test&quot; suffix are deprecated (%s)',
                        $class-&gt;getName(),
                    ),
                );
            }

            if (!$class-&gt;isAbstract()) {
                if ($class-&gt;hasMethod(BaseTestRunner::SUITE_METHODNAME)) {
                    try {
                        $method = $class-&gt;getMethod(
                            BaseTestRunner::SUITE_METHODNAME,
                        );
                        // @codeCoverageIgnoreStart
                    } catch (ReflectionException $e) {
                        throw new Exception(
                            $e-&gt;getMessage(),
                            $e-&gt;getCode(),
                            $e,
                        );
                    }
                    // @codeCoverageIgnoreEnd

                    if ($method-&gt;isStatic()) {
                        $this-&gt;addTest($method-&gt;invoke(null, $className));
                    }
                } elseif ($class-&gt;implementsInterface(Test::class)) {
                    // Do we have modern namespacing ('Foo\Bar\WhizBangTest') or old-school namespacing ('Foo_Bar_WhizBangTest')?
                    $isPsr0            = (!$class-&gt;inNamespace()) &amp;&amp; (strpos($class-&gt;getName(), '_') !== false);
                    $expectedClassName = $isPsr0 ? $className : $shortName;

                    if (($pos = strpos($expectedClassName, '.')) !== false) {
                        $expectedClassName = substr(
                            $expectedClassName,
                            0,
                            $pos,
                        );
                    }

                    if ($class-&gt;getShortName() !== $expectedClassName) {
                        $this-&gt;addWarning(
                            sprintf(
                                &quot;Test case class not matching filename is deprecated\n               in %s\n               Class name was '%s', expected '%s'&quot;,
                                $filename,
                                $class-&gt;getShortName(),
                                $expectedClassName,
                            ),
                        );
                    }

                    $this-&gt;addTestSuite($class);
                }
            }
        }

        if (count($this-&gt;tests) &gt; ++$numTests) {
            $this-&gt;addWarning(
                sprintf(
                    &quot;Multiple test case classes per file is deprecated\n               in %s&quot;,
                    $filename,
                ),
            );
        }

        $this-&gt;numTests = -1;
    }

    /**
     * Wrapper for addTestFile() that adds multiple test files.
     *
     * @throws Exception
     */
    public function addTestFiles(iterable $fileNames): void
    {
        foreach ($fileNames as $filename) {
            $this-&gt;addTestFile((string) $filename);
        }
    }

    /**
     * Counts the number of test cases that will be run by this test.
     *
     * @todo refactor usage of numTests in DefaultResultPrinter
     */
    public function count(): int
    {
        $this-&gt;numTests = 0;

        foreach ($this as $test) {
            $this-&gt;numTests += count($test);
        }

        return $this-&gt;numTests;
    }

    /**
     * Returns the name of the suite.
     */
    public function getName(): string
    {
        return $this-&gt;name;
    }

    /**
     * Returns the test groups of the suite.
     *
     * @psalm-return list&lt;string&gt;
     */
    public function getGroups(): array
    {
        return array_map(
            static function ($key): string
            {
                return (string) $key;
            },
            array_keys($this-&gt;groups),
        );
    }

    public function getGroupDetails(): array
    {
        return $this-&gt;groups;
    }

    /**
     * Set tests groups of the test case.
     */
    public function setGroupDetails(array $groups): void
    {
        $this-&gt;groups = $groups;
    }

    /**
     * Runs the tests and collects their result in a TestResult.
     *
     * @throws \SebastianBergmann\CodeCoverage\InvalidArgumentException
     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
     * @throws CodeCoverageException
     * @throws UnintentionallyCoveredCodeException
     * @throws Warning
     */
    public function run(?TestResult $result = null): TestResult
    {
        if ($result === null) {
            $result = $this-&gt;createResult();
        }

        if (count($this) === 0) {
            return $result;
        }

        /** @psalm-var class-string $className */
        $className   = $this-&gt;name;
        $hookMethods = TestUtil::getHookMethods($className);

        $result-&gt;startTestSuite($this);

        $test = null;

        if ($this-&gt;testCase &amp;&amp; class_exists($this-&gt;name, false)) {
            try {
                foreach ($hookMethods['beforeClass'] as $beforeClassMethod) {
                    if (method_exists($this-&gt;name, $beforeClassMethod)) {
                        if ($missingRequirements = TestUtil::getMissingRequirements($this-&gt;name, $beforeClassMethod)) {
                            $this-&gt;markTestSuiteSkipped(implode(PHP_EOL, $missingRequirements));
                        }

                        call_user_func([$this-&gt;name, $beforeClassMethod]);
                    }
                }
            } catch (SkippedTestError|SkippedTestSuiteError $error) {
                foreach ($this-&gt;tests() as $test) {
                    $result-&gt;startTest($test);
                    $result-&gt;addFailure($test, $error, 0);
                    $result-&gt;endTest($test, 0);
                }

                $result-&gt;endTestSuite($this);

                return $result;
            } catch (Throwable $t) {
                $errorAdded = false;

                foreach ($this-&gt;tests() as $test) {
                    if ($result-&gt;shouldStop()) {
                        break;
                    }

                    $result-&gt;startTest($test);

                    if (!$errorAdded) {
                        $result-&gt;addError($test, $t, 0);

                        $errorAdded = true;
                    } else {
                        $result-&gt;addFailure(
                            $test,
                            new SkippedTestError('Test skipped because of an error in hook method'),
                            0,
                        );
                    }

                    $result-&gt;endTest($test, 0);
                }

                $result-&gt;endTestSuite($this);

                return $result;
            }
        }

        foreach ($this as $test) {
            if ($result-&gt;shouldStop()) {
                break;
            }

            if ($test instanceof TestCase || $test instanceof self) {
                $test-&gt;setBeStrictAboutChangesToGlobalState($this-&gt;beStrictAboutChangesToGlobalState);
                $test-&gt;setBackupGlobals($this-&gt;backupGlobals);
                $test-&gt;setBackupStaticAttributes($this-&gt;backupStaticAttributes);
                $test-&gt;setRunTestInSeparateProcess($this-&gt;runTestInSeparateProcess);
            }

            $test-&gt;run($result);
        }

        if ($this-&gt;testCase &amp;&amp; class_exists($this-&gt;name, false)) {
            foreach ($hookMethods['afterClass'] as $afterClassMethod) {
                if (method_exists($this-&gt;name, $afterClassMethod)) {
                    try {
                        call_user_func([$this-&gt;name, $afterClassMethod]);
                    } catch (Throwable $t) {
                        $message = &quot;Exception in {$this-&gt;name}::{$afterClassMethod}&quot; . PHP_EOL . $t-&gt;getMessage();
                        $error   = new SyntheticError($message, 0, $t-&gt;getFile(), $t-&gt;getLine(), $t-&gt;getTrace());

                        $placeholderTest = clone $test;
                        $placeholderTest-&gt;setName($afterClassMethod);

                        $result-&gt;startTest($placeholderTest);
                        $result-&gt;addFailure($placeholderTest, $error, 0);
                        $result-&gt;endTest($placeholderTest, 0);
                    }
                }
            }
        }

        $result-&gt;endTestSuite($this);

        return $result;
    }

    public function setRunTestInSeparateProcess(bool $runTestInSeparateProcess): void
    {
        $this-&gt;runTestInSeparateProcess = $runTestInSeparateProcess;
    }

    public function setName(string $name): void
    {
        $this-&gt;name = $name;
    }

    /**
     * Returns the tests as an enumeration.
     *
     * @return Test[]
     */
    public function tests(): array
    {
        return $this-&gt;tests;
    }

    /**
     * Set tests of the test suite.
     *
     * @param Test[] $tests
     */
    public function setTests(array $tests): void
    {
        $this-&gt;tests = $tests;
    }

    /**
     * Mark the test suite as skipped.
     *
     * @param string $message
     *
     * @throws SkippedTestSuiteError
     *
     * @psalm-return never-return
     */
    public function markTestSuiteSkipped($message = ''): void
    {
        throw new SkippedTestSuiteError($message);
    }

    /**
     * @param bool $beStrictAboutChangesToGlobalState
     */
    public function setBeStrictAboutChangesToGlobalState($beStrictAboutChangesToGlobalState): void
    {
        if (null === $this-&gt;beStrictAboutChangesToGlobalState &amp;&amp; is_bool($beStrictAboutChangesToGlobalState)) {
            $this-&gt;beStrictAboutChangesToGlobalState = $beStrictAboutChangesToGlobalState;
        }
    }

    /**
     * @param bool $backupGlobals
     */
    public function setBackupGlobals($backupGlobals): void
    {
        if (null === $this-&gt;backupGlobals &amp;&amp; is_bool($backupGlobals)) {
            $this-&gt;backupGlobals = $backupGlobals;
        }
    }

    /**
     * @param bool $backupStaticAttributes
     */
    public function setBackupStaticAttributes($backupStaticAttributes): void
    {
        if (null === $this-&gt;backupStaticAttributes &amp;&amp; is_bool($backupStaticAttributes)) {
            $this-&gt;backupStaticAttributes = $backupStaticAttributes;
        }
    }

    /**
     * Returns an iterator for this test suite.
     */
    public function getIterator(): Iterator
    {
        $iterator = new TestSuiteIterator($this);

        if ($this-&gt;iteratorFilter !== null) {
            $iterator = $this-&gt;iteratorFilter-&gt;factory($iterator, $this);
        }

        return $iterator;
    }

    public function injectFilter(Factory $filter): void
    {
        $this-&gt;iteratorFilter = $filter;

        foreach ($this as $test) {
            if ($test instanceof self) {
                $test-&gt;injectFilter($filter);
            }
        }
    }

    /**
     * @psalm-return array&lt;int,string&gt;
     */
    public function warnings(): array
    {
        return array_unique($this-&gt;warnings);
    }

    /**
     * @return list&lt;ExecutionOrderDependency&gt;
     */
    public function provides(): array
    {
        if ($this-&gt;providedTests === null) {
            $this-&gt;providedTests = [];

            if (is_callable($this-&gt;sortId(), true)) {
                $this-&gt;providedTests[] = new ExecutionOrderDependency($this-&gt;sortId());
            }

            foreach ($this-&gt;tests as $test) {
                if (!($test instanceof Reorderable)) {
                    // @codeCoverageIgnoreStart
                    continue;
                    // @codeCoverageIgnoreEnd
                }
                $this-&gt;providedTests = ExecutionOrderDependency::mergeUnique($this-&gt;providedTests, $test-&gt;provides());
            }
        }

        return $this-&gt;providedTests;
    }

    /**
     * @return list&lt;ExecutionOrderDependency&gt;
     */
    public function requires(): array
    {
        if ($this-&gt;requiredTests === null) {
            $this-&gt;requiredTests = [];

            foreach ($this-&gt;tests as $test) {
                if (!($test instanceof Reorderable)) {
                    // @codeCoverageIgnoreStart
                    continue;
                    // @codeCoverageIgnoreEnd
                }
                $this-&gt;requiredTests = ExecutionOrderDependency::mergeUnique(
                    ExecutionOrderDependency::filterInvalid($this-&gt;requiredTests),
                    $test-&gt;requires(),
                );
            }

            $this-&gt;requiredTests = ExecutionOrderDependency::diff($this-&gt;requiredTests, $this-&gt;provides());
        }

        return $this-&gt;requiredTests;
    }

    public function sortId(): string
    {
        return $this-&gt;getName() . '::class';
    }

    /**
     * Creates a default TestResult object.
     */
    protected function createResult(): TestResult
    {
        return new TestResult;
    }

    /**
     * @throws Exception
     */
    protected function addTestMethod(ReflectionClass $class, ReflectionMethod $method): void
    {
        $methodName = $method-&gt;getName();

        $test = (new TestBuilder)-&gt;build($class, $methodName);

        if ($test instanceof TestCase || $test instanceof DataProviderTestSuite) {
            $test-&gt;setDependencies(
                TestUtil::getDependencies($class-&gt;getName(), $methodName),
            );
        }

        $this-&gt;addTest(
            $test,
            TestUtil::getGroups($class-&gt;getName(), $methodName),
        );
    }

    private function clearCaches(): void
    {
        $this-&gt;numTests      = -1;
        $this-&gt;providedTests = null;
        $this-&gt;requiredTests = null;
    }

    private function containsOnlyVirtualGroups(array $groups): bool
    {
        foreach ($groups as $group) {
            if (strpos($group, '__phpunit_') !== 0) {
                return false;
            }
        }

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