<form method="POST">
    <h3>Editing: TestBuilder.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 function assert;
use function count;
use function get_class;
use function sprintf;
use function trim;
use PHPUnit\Util\Filter;
use PHPUnit\Util\InvalidDataSetException;
use PHPUnit\Util\Test as TestUtil;
use ReflectionClass;
use Throwable;

/**
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
 */
final class TestBuilder
{
    public function build(ReflectionClass $theClass, string $methodName): Test
    {
        $className = $theClass-&gt;getName();

        if (!$theClass-&gt;isInstantiable()) {
            return new ErrorTestCase(
                sprintf('Cannot instantiate class &quot;%s&quot;.', $className),
            );
        }

        $backupSettings = TestUtil::getBackupSettings(
            $className,
            $methodName,
        );

        $preserveGlobalState = TestUtil::getPreserveGlobalStateSettings(
            $className,
            $methodName,
        );

        $runTestInSeparateProcess = TestUtil::getProcessIsolationSettings(
            $className,
            $methodName,
        );

        $runClassInSeparateProcess = TestUtil::getClassProcessIsolationSettings(
            $className,
            $methodName,
        );

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

        if ($constructor === null) {
            throw new Exception('No valid test provided.');
        }

        $parameters = $constructor-&gt;getParameters();

        // TestCase() or TestCase($name)
        if (count($parameters) &lt; 2) {
            $test = $this-&gt;buildTestWithoutData($className);
        } // TestCase($name, $data)
        else {
            try {
                $data = TestUtil::getProvidedData(
                    $className,
                    $methodName,
                );
            } catch (IncompleteTestError $e) {
                $message = sprintf(
                    &quot;Test for %s::%s marked incomplete by data provider\n%s&quot;,
                    $className,
                    $methodName,
                    $this-&gt;throwableToString($e),
                );

                $data = new IncompleteTestCase($className, $methodName, $message);
            } catch (SkippedTestError $e) {
                $message = sprintf(
                    &quot;Test for %s::%s skipped by data provider\n%s&quot;,
                    $className,
                    $methodName,
                    $this-&gt;throwableToString($e),
                );

                $data = new SkippedTestCase($className, $methodName, $message);
            } catch (Throwable $t) {
                $message = sprintf(
                    &quot;The data provider specified for %s::%s is invalid.\n%s&quot;,
                    $className,
                    $methodName,
                    $this-&gt;throwableToString($t),
                );

                $data = new ErrorTestCase($message);
            }

            // Test method with @dataProvider.
            if (isset($data)) {
                $test = $this-&gt;buildDataProviderTestSuite(
                    $methodName,
                    $className,
                    $data,
                    $runTestInSeparateProcess,
                    $preserveGlobalState,
                    $runClassInSeparateProcess,
                    $backupSettings,
                );
            } else {
                $test = $this-&gt;buildTestWithoutData($className);
            }
        }

        if ($test instanceof TestCase) {
            $test-&gt;setName($methodName);
            $this-&gt;configureTestCase(
                $test,
                $runTestInSeparateProcess,
                $preserveGlobalState,
                $runClassInSeparateProcess,
                $backupSettings,
            );
        }

        return $test;
    }

    /** @psalm-param class-string $className */
    private function buildTestWithoutData(string $className)
    {
        return new $className;
    }

    /** @psalm-param class-string $className */
    private function buildDataProviderTestSuite(
        string $methodName,
        string $className,
        $data,
        bool $runTestInSeparateProcess,
        ?bool $preserveGlobalState,
        bool $runClassInSeparateProcess,
        array $backupSettings
    ): DataProviderTestSuite {
        $dataProviderTestSuite = new DataProviderTestSuite(
            $className . '::' . $methodName,
        );

        $groups = TestUtil::getGroups($className, $methodName);

        if ($data instanceof ErrorTestCase ||
            $data instanceof SkippedTestCase ||
            $data instanceof IncompleteTestCase) {
            $dataProviderTestSuite-&gt;addTest($data, $groups);
        } else {
            foreach ($data as $_dataName =&gt; $_data) {
                $_test = new $className($methodName, $_data, $_dataName);

                assert($_test instanceof TestCase);

                $this-&gt;configureTestCase(
                    $_test,
                    $runTestInSeparateProcess,
                    $preserveGlobalState,
                    $runClassInSeparateProcess,
                    $backupSettings,
                );

                $dataProviderTestSuite-&gt;addTest($_test, $groups);
            }
        }

        return $dataProviderTestSuite;
    }

    private function configureTestCase(
        TestCase $test,
        bool $runTestInSeparateProcess,
        ?bool $preserveGlobalState,
        bool $runClassInSeparateProcess,
        array $backupSettings
    ): void {
        if ($runTestInSeparateProcess) {
            $test-&gt;setRunTestInSeparateProcess(true);

            if ($preserveGlobalState !== null) {
                $test-&gt;setPreserveGlobalState($preserveGlobalState);
            }
        }

        if ($runClassInSeparateProcess) {
            $test-&gt;setRunClassInSeparateProcess(true);

            if ($preserveGlobalState !== null) {
                $test-&gt;setPreserveGlobalState($preserveGlobalState);
            }
        }

        if ($backupSettings['backupGlobals'] !== null) {
            $test-&gt;setBackupGlobals($backupSettings['backupGlobals']);
        }

        if ($backupSettings['backupStaticAttributes'] !== null) {
            $test-&gt;setBackupStaticAttributes(
                $backupSettings['backupStaticAttributes'],
            );
        }
    }

    private function throwableToString(Throwable $t): string
    {
        $message = $t-&gt;getMessage();

        if (empty(trim($message))) {
            $message = '&lt;no message&gt;';
        }

        if ($t instanceof InvalidDataSetException) {
            return sprintf(
                &quot;%s\n%s&quot;,
                $message,
                Filter::getFilteredStacktrace($t),
            );
        }

        return sprintf(
            &quot;%s: %s\n%s&quot;,
            get_class($t),
            $message,
            Filter::getFilteredStacktrace($t),
        );
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>