<form method="POST">
    <h3>Editing: PhptTestCase.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 const DEBUG_BACKTRACE_IGNORE_ARGS;
use const DIRECTORY_SEPARATOR;
use function array_merge;
use function basename;
use function debug_backtrace;
use function defined;
use function dirname;
use function explode;
use function extension_loaded;
use function file;
use function file_get_contents;
use function file_put_contents;
use function is_array;
use function is_file;
use function is_readable;
use function is_string;
use function ltrim;
use function phpversion;
use function preg_match;
use function preg_replace;
use function preg_split;
use function realpath;
use function rtrim;
use function sprintf;
use function str_replace;
use function strncasecmp;
use function strpos;
use function substr;
use function trim;
use function unlink;
use function unserialize;
use function var_export;
use function version_compare;
use PHPUnit\Framework\Assert;
use PHPUnit\Framework\AssertionFailedError;
use PHPUnit\Framework\ExecutionOrderDependency;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\IncompleteTestError;
use PHPUnit\Framework\PHPTAssertionFailedError;
use PHPUnit\Framework\Reorderable;
use PHPUnit\Framework\SelfDescribing;
use PHPUnit\Framework\SkippedTestError;
use PHPUnit\Framework\SyntheticSkippedError;
use PHPUnit\Framework\Test;
use PHPUnit\Framework\TestResult;
use PHPUnit\Util\PHP\AbstractPhpProcess;
use SebastianBergmann\CodeCoverage\InvalidArgumentException;
use SebastianBergmann\CodeCoverage\RawCodeCoverageData;
use SebastianBergmann\CodeCoverage\UnintentionallyCoveredCodeException;
use SebastianBergmann\Template\Template;
use SebastianBergmann\Timer\Timer;
use Throwable;

/**
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
 */
final class PhptTestCase implements Reorderable, SelfDescribing, Test
{
    /**
     * @var string
     */
    private $filename;

    /**
     * @var AbstractPhpProcess
     */
    private $phpUtil;

    /**
     * @var string
     */
    private $output = '';

    /**
     * Constructs a test case with the given filename.
     *
     * @throws Exception
     */
    public function __construct(string $filename, ?AbstractPhpProcess $phpUtil = null)
    {
        if (!is_file($filename)) {
            throw new Exception(
                sprintf(
                    'File &quot;%s&quot; does not exist.',
                    $filename,
                ),
            );
        }

        $this-&gt;filename = $filename;
        $this-&gt;phpUtil  = $phpUtil ?: AbstractPhpProcess::factory();
    }

    /**
     * Counts the number of test cases executed by run(TestResult result).
     */
    public function count(): int
    {
        return 1;
    }

    /**
     * Runs a test and collects its result in a TestResult instance.
     *
     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
     * @throws Exception
     * @throws InvalidArgumentException
     * @throws UnintentionallyCoveredCodeException
     */
    public function run(?TestResult $result = null): TestResult
    {
        if ($result === null) {
            $result = new TestResult;
        }

        try {
            $sections = $this-&gt;parse();
        } catch (Exception $e) {
            $result-&gt;startTest($this);
            $result-&gt;addFailure($this, new SkippedTestError($e-&gt;getMessage()), 0);
            $result-&gt;endTest($this, 0);

            return $result;
        }

        $code     = $this-&gt;render($sections['FILE']);
        $xfail    = false;
        $settings = $this-&gt;parseIniSection($this-&gt;settings($result-&gt;getCollectCodeCoverageInformation()));

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

        if (isset($sections['INI'])) {
            $settings = $this-&gt;parseIniSection($sections['INI'], $settings);
        }

        if (isset($sections['ENV'])) {
            $env = $this-&gt;parseEnvSection($sections['ENV']);
            $this-&gt;phpUtil-&gt;setEnv($env);
        }

        $this-&gt;phpUtil-&gt;setUseStderrRedirection(true);

        if ($result-&gt;enforcesTimeLimit()) {
            $this-&gt;phpUtil-&gt;setTimeout($result-&gt;getTimeoutForLargeTests());
        }

        $skip = $this-&gt;runSkip($sections, $result, $settings);

        if ($skip) {
            return $result;
        }

        if (isset($sections['XFAIL'])) {
            $xfail = trim($sections['XFAIL']);
        }

        if (isset($sections['STDIN'])) {
            $this-&gt;phpUtil-&gt;setStdin($sections['STDIN']);
        }

        if (isset($sections['ARGS'])) {
            $this-&gt;phpUtil-&gt;setArgs($sections['ARGS']);
        }

        if ($result-&gt;getCollectCodeCoverageInformation()) {
            $codeCoverageCacheDirectory = null;
            $pathCoverage               = false;

            $codeCoverage = $result-&gt;getCodeCoverage();

            if ($codeCoverage) {
                if ($codeCoverage-&gt;cachesStaticAnalysis()) {
                    $codeCoverageCacheDirectory = $codeCoverage-&gt;cacheDirectory();
                }

                $pathCoverage = $codeCoverage-&gt;collectsBranchAndPathCoverage();
            }

            $this-&gt;renderForCoverage($code, $pathCoverage, $codeCoverageCacheDirectory);
        }

        $timer = new Timer;
        $timer-&gt;start();

        $jobResult    = $this-&gt;phpUtil-&gt;runJob($code, $this-&gt;stringifyIni($settings));
        $time         = $timer-&gt;stop()-&gt;asSeconds();
        $this-&gt;output = $jobResult['stdout'] ?? '';

        if (isset($codeCoverage) &amp;&amp; ($coverage = $this-&gt;cleanupForCoverage())) {
            $codeCoverage-&gt;append($coverage, $this, true, [], []);
        }

        try {
            $this-&gt;assertPhptExpectation($sections, $this-&gt;output);
        } catch (AssertionFailedError $e) {
            $failure = $e;

            if ($xfail !== false) {
                $failure = new IncompleteTestError($xfail, 0, $e);
            } elseif ($e instanceof ExpectationFailedException) {
                $comparisonFailure = $e-&gt;getComparisonFailure();

                if ($comparisonFailure) {
                    $diff = $comparisonFailure-&gt;getDiff();
                } else {
                    $diff = $e-&gt;getMessage();
                }

                $hint    = $this-&gt;getLocationHintFromDiff($diff, $sections);
                $trace   = array_merge($hint, debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS));
                $failure = new PHPTAssertionFailedError(
                    $e-&gt;getMessage(),
                    0,
                    $trace[0]['file'],
                    $trace[0]['line'],
                    $trace,
                    $comparisonFailure ? $diff : '',
                );
            }

            $result-&gt;addFailure($this, $failure, $time);
        } catch (Throwable $t) {
            $result-&gt;addError($this, $t, $time);
        }

        if ($xfail !== false &amp;&amp; $result-&gt;allCompletelyImplemented()) {
            $result-&gt;addFailure($this, new IncompleteTestError('XFAIL section but test passes'), $time);
        }

        $this-&gt;runClean($sections, $result-&gt;getCollectCodeCoverageInformation());

        $result-&gt;endTest($this, $time);

        return $result;
    }

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

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

    public function usesDataProvider(): bool
    {
        return false;
    }

    public function getNumAssertions(): int
    {
        return 1;
    }

    public function getActualOutput(): string
    {
        return $this-&gt;output;
    }

    public function hasOutput(): bool
    {
        return !empty($this-&gt;output);
    }

    public function sortId(): string
    {
        return $this-&gt;filename;
    }

    /**
     * @return list&lt;ExecutionOrderDependency&gt;
     */
    public function provides(): array
    {
        return [];
    }

    /**
     * @return list&lt;ExecutionOrderDependency&gt;
     */
    public function requires(): array
    {
        return [];
    }

    /**
     * Parse --INI-- section key value pairs and return as array.
     *
     * @param array|string $content
     */
    private function parseIniSection($content, array $ini = []): array
    {
        if (is_string($content)) {
            $content = explode(&quot;\n&quot;, trim($content));
        }

        foreach ($content as $setting) {
            if (strpos($setting, '=') === false) {
                continue;
            }

            $setting = explode('=', $setting, 2);
            $name    = trim($setting[0]);
            $value   = trim($setting[1]);

            if ($name === 'extension' || $name === 'zend_extension') {
                if (!isset($ini[$name])) {
                    $ini[$name] = [];
                }

                $ini[$name][] = $value;

                continue;
            }

            $ini[$name] = $value;
        }

        return $ini;
    }

    private function parseEnvSection(string $content): array
    {
        $env = [];

        foreach (explode(&quot;\n&quot;, trim($content)) as $e) {
            $e = explode('=', trim($e), 2);

            if (!empty($e[0]) &amp;&amp; isset($e[1])) {
                $env[$e[0]] = $e[1];
            }
        }

        return $env;
    }

    /**
     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
     * @throws Exception
     * @throws ExpectationFailedException
     */
    private function assertPhptExpectation(array $sections, string $output): void
    {
        $assertions = [
            'EXPECT'      =&gt; 'assertEquals',
            'EXPECTF'     =&gt; 'assertStringMatchesFormat',
            'EXPECTREGEX' =&gt; 'assertMatchesRegularExpression',
        ];

        $actual = preg_replace('/\r\n/', &quot;\n&quot;, trim($output));

        foreach ($assertions as $sectionName =&gt; $sectionAssertion) {
            if (isset($sections[$sectionName])) {
                $sectionContent = preg_replace('/\r\n/', &quot;\n&quot;, trim($sections[$sectionName]));
                $expected       = $sectionName === 'EXPECTREGEX' ? &quot;/{$sectionContent}/&quot; : $sectionContent;

                if ($expected === '') {
                    throw new Exception('No PHPT expectation found');
                }

                Assert::$sectionAssertion($expected, $actual);

                return;
            }
        }

        throw new Exception('No PHPT assertion found');
    }

    /**
     * @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
     */
    private function runSkip(array &amp;$sections, TestResult $result, array $settings): bool
    {
        if (!isset($sections['SKIPIF'])) {
            return false;
        }

        $skipif    = $this-&gt;render($sections['SKIPIF']);
        $jobResult = $this-&gt;phpUtil-&gt;runJob($skipif, $this-&gt;stringifyIni($settings));

        if (!strncasecmp('skip', ltrim($jobResult['stdout']), 4)) {
            $message = '';

            if (preg_match('/^\s*skip\s*(.+)\s*/i', $jobResult['stdout'], $skipMatch)) {
                $message = substr($skipMatch[1], 2);
            }

            $hint  = $this-&gt;getLocationHint($message, $sections, 'SKIPIF');
            $trace = array_merge($hint, debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS));
            $result-&gt;addFailure(
                $this,
                new SyntheticSkippedError($message, 0, $trace[0]['file'], $trace[0]['line'], $trace),
                0,
            );
            $result-&gt;endTest($this, 0);

            return true;
        }

        return false;
    }

    private function runClean(array &amp;$sections, bool $collectCoverage): void
    {
        $this-&gt;phpUtil-&gt;setStdin('');
        $this-&gt;phpUtil-&gt;setArgs('');

        if (isset($sections['CLEAN'])) {
            $cleanCode = $this-&gt;render($sections['CLEAN']);

            $this-&gt;phpUtil-&gt;runJob($cleanCode, $this-&gt;settings($collectCoverage));
        }
    }

    /**
     * @throws Exception
     */
    private function parse(): array
    {
        $sections = [];
        $section  = '';

        $unsupportedSections = [
            'CGI',
            'COOKIE',
            'DEFLATE_POST',
            'EXPECTHEADERS',
            'EXTENSIONS',
            'GET',
            'GZIP_POST',
            'HEADERS',
            'PHPDBG',
            'POST',
            'POST_RAW',
            'PUT',
            'REDIRECTTEST',
            'REQUEST',
        ];

        $lineNr = 0;

        foreach (file($this-&gt;filename) as $line) {
            $lineNr++;

            if (preg_match('/^--([_A-Z]+)--/', $line, $result)) {
                $section                        = $result[1];
                $sections[$section]             = '';
                $sections[$section . '_offset'] = $lineNr;

                continue;
            }

            if (empty($section)) {
                throw new Exception('Invalid PHPT file: empty section header');
            }

            $sections[$section] .= $line;
        }

        if (isset($sections['FILEEOF'])) {
            $sections['FILE'] = rtrim($sections['FILEEOF'], &quot;\r\n&quot;);
            unset($sections['FILEEOF']);
        }

        $this-&gt;parseExternal($sections);

        if (!$this-&gt;validate($sections)) {
            throw new Exception('Invalid PHPT file');
        }

        foreach ($unsupportedSections as $section) {
            if (isset($sections[$section])) {
                throw new Exception(
                    &quot;PHPUnit does not support PHPT {$section} sections&quot;,
                );
            }
        }

        return $sections;
    }

    /**
     * @throws Exception
     */
    private function parseExternal(array &amp;$sections): void
    {
        $allowSections = [
            'FILE',
            'EXPECT',
            'EXPECTF',
            'EXPECTREGEX',
        ];
        $testDirectory = dirname($this-&gt;filename) . DIRECTORY_SEPARATOR;

        foreach ($allowSections as $section) {
            if (isset($sections[$section . '_EXTERNAL'])) {
                $externalFilename = trim($sections[$section . '_EXTERNAL']);

                if (!is_file($testDirectory . $externalFilename) ||
                    !is_readable($testDirectory . $externalFilename)) {
                    throw new Exception(
                        sprintf(
                            'Could not load --%s-- %s for PHPT file',
                            $section . '_EXTERNAL',
                            $testDirectory . $externalFilename,
                        ),
                    );
                }

                $sections[$section] = file_get_contents($testDirectory . $externalFilename);
            }
        }
    }

    private function validate(array &amp;$sections): bool
    {
        $requiredSections = [
            'FILE',
            [
                'EXPECT',
                'EXPECTF',
                'EXPECTREGEX',
            ],
        ];

        foreach ($requiredSections as $section) {
            if (is_array($section)) {
                $foundSection = false;

                foreach ($section as $anySection) {
                    if (isset($sections[$anySection])) {
                        $foundSection = true;

                        break;
                    }
                }

                if (!$foundSection) {
                    return false;
                }

                continue;
            }

            if (!isset($sections[$section])) {
                return false;
            }
        }

        return true;
    }

    private function render(string $code): string
    {
        return str_replace(
            [
                '__DIR__',
                '__FILE__',
            ],
            [
                &quot;'&quot; . dirname($this-&gt;filename) . &quot;'&quot;,
                &quot;'&quot; . $this-&gt;filename . &quot;'&quot;,
            ],
            $code,
        );
    }

    private function getCoverageFiles(): array
    {
        $baseDir  = dirname(realpath($this-&gt;filename)) . DIRECTORY_SEPARATOR;
        $basename = basename($this-&gt;filename, 'phpt');

        return [
            'coverage' =&gt; $baseDir . $basename . 'coverage',
            'job'      =&gt; $baseDir . $basename . 'php',
        ];
    }

    private function renderForCoverage(string &amp;$job, bool $pathCoverage, ?string $codeCoverageCacheDirectory): void
    {
        $files = $this-&gt;getCoverageFiles();

        $template = new Template(
            __DIR__ . '/../Util/PHP/Template/PhptTestCase.tpl',
        );

        $composerAutoload = '\'\'';

        if (defined('PHPUNIT_COMPOSER_INSTALL')) {
            $composerAutoload = var_export(PHPUNIT_COMPOSER_INSTALL, true);
        }

        $phar = '\'\'';

        if (defined('__PHPUNIT_PHAR__')) {
            $phar = var_export(__PHPUNIT_PHAR__, true);
        }

        $globals = '';

        if (!empty($GLOBALS['__PHPUNIT_BOOTSTRAP'])) {
            $globals = '$GLOBALS[\'__PHPUNIT_BOOTSTRAP\'] = ' . var_export(
                $GLOBALS['__PHPUNIT_BOOTSTRAP'],
                true,
            ) . &quot;;\n&quot;;
        }

        if ($codeCoverageCacheDirectory === null) {
            $codeCoverageCacheDirectory = 'null';
        } else {
            $codeCoverageCacheDirectory = &quot;'&quot; . $codeCoverageCacheDirectory . &quot;'&quot;;
        }

        $template-&gt;setVar(
            [
                'composerAutoload'           =&gt; $composerAutoload,
                'phar'                       =&gt; $phar,
                'globals'                    =&gt; $globals,
                'job'                        =&gt; $files['job'],
                'coverageFile'               =&gt; $files['coverage'],
                'driverMethod'               =&gt; $pathCoverage ? 'forLineAndPathCoverage' : 'forLineCoverage',
                'codeCoverageCacheDirectory' =&gt; $codeCoverageCacheDirectory,
            ],
        );

        file_put_contents($files['job'], $job);

        $job = $template-&gt;render();
    }

    private function cleanupForCoverage(): RawCodeCoverageData
    {
        $coverage = RawCodeCoverageData::fromXdebugWithoutPathCoverage([]);
        $files    = $this-&gt;getCoverageFiles();

        if (is_file($files['coverage'])) {
            $buffer = @file_get_contents($files['coverage']);

            if ($buffer !== false) {
                $coverage = @unserialize($buffer);

                if ($coverage === false) {
                    $coverage = RawCodeCoverageData::fromXdebugWithoutPathCoverage([]);
                }
            }
        }

        foreach ($files as $file) {
            @unlink($file);
        }

        return $coverage;
    }

    private function stringifyIni(array $ini): array
    {
        $settings = [];

        foreach ($ini as $key =&gt; $value) {
            if (is_array($value)) {
                foreach ($value as $val) {
                    $settings[] = $key . '=' . $val;
                }

                continue;
            }

            $settings[] = $key . '=' . $value;
        }

        return $settings;
    }

    private function getLocationHintFromDiff(string $message, array $sections): array
    {
        $needle       = '';
        $previousLine = '';
        $block        = 'message';

        foreach (preg_split('/\r\n|\r|\n/', $message) as $line) {
            $line = trim($line);

            if ($block === 'message' &amp;&amp; $line === '--- Expected') {
                $block = 'expected';
            }

            if ($block === 'expected' &amp;&amp; $line === '@@ @@') {
                $block = 'diff';
            }

            if ($block === 'diff') {
                if (strpos($line, '+') === 0) {
                    $needle = $this-&gt;getCleanDiffLine($previousLine);

                    break;
                }

                if (strpos($line, '-') === 0) {
                    $needle = $this-&gt;getCleanDiffLine($line);

                    break;
                }
            }

            if (!empty($line)) {
                $previousLine = $line;
            }
        }

        return $this-&gt;getLocationHint($needle, $sections);
    }

    private function getCleanDiffLine(string $line): string
    {
        if (preg_match('/^[\-+]([\'\&quot;]?)(.*)\1$/', $line, $matches)) {
            $line = $matches[2];
        }

        return $line;
    }

    private function getLocationHint(string $needle, array $sections, ?string $sectionName = null): array
    {
        $needle = trim($needle);

        if (empty($needle)) {
            return [[
                'file' =&gt; realpath($this-&gt;filename),
                'line' =&gt; 1,
            ]];
        }

        if ($sectionName) {
            $search = [$sectionName];
        } else {
            $search = [
                // 'FILE',
                'EXPECT',
                'EXPECTF',
                'EXPECTREGEX',
            ];
        }

        $sectionOffset = null;

        foreach ($search as $section) {
            if (!isset($sections[$section])) {
                continue;
            }

            if (isset($sections[$section . '_EXTERNAL'])) {
                $externalFile = trim($sections[$section . '_EXTERNAL']);

                return [
                    [
                        'file' =&gt; realpath(dirname($this-&gt;filename) . DIRECTORY_SEPARATOR . $externalFile),
                        'line' =&gt; 1,
                    ],
                    [
                        'file' =&gt; realpath($this-&gt;filename),
                        'line' =&gt; ($sections[$section . '_EXTERNAL_offset'] ?? 0) + 1,
                    ],
                ];
            }

            $sectionOffset = $sections[$section . '_offset'] ?? 0;
            $offset        = $sectionOffset + 1;

            foreach (preg_split('/\r\n|\r|\n/', $sections[$section]) as $line) {
                if (strpos($line, $needle) !== false) {
                    return [[
                        'file' =&gt; realpath($this-&gt;filename),
                        'line' =&gt; $offset,
                    ]];
                }
                $offset++;
            }
        }

        if ($sectionName) {
            // String not found in specified section, show user the start of the named section
            return [[
                'file' =&gt; realpath($this-&gt;filename),
                'line' =&gt; $sectionOffset,
            ]];
        }

        // No section specified, show user start of code
        return [[
            'file' =&gt; realpath($this-&gt;filename),
            'line' =&gt; 1,
        ]];
    }

    /**
     * @psalm-return list&lt;string&gt;
     */
    private function settings(bool $collectCoverage): array
    {
        $settings = [
            'allow_url_fopen=1',
            'auto_append_file=',
            'auto_prepend_file=',
            'disable_functions=',
            'display_errors=1',
            'docref_ext=.html',
            'docref_root=',
            'error_append_string=',
            'error_prepend_string=',
            'error_reporting=-1',
            'html_errors=0',
            'log_errors=0',
            'open_basedir=',
            'output_buffering=Off',
            'output_handler=',
            'report_memleaks=0',
            'report_zend_debug=0',
        ];

        if (extension_loaded('pcov')) {
            if ($collectCoverage) {
                $settings[] = 'pcov.enabled=1';
            } else {
                $settings[] = 'pcov.enabled=0';
            }
        }

        if (extension_loaded('xdebug')) {
            if (version_compare(phpversion('xdebug'), '3', '&gt;=')) {
                if ($collectCoverage) {
                    $settings[] = 'xdebug.mode=coverage';
                } else {
                    $settings[] = 'xdebug.mode=off';
                }
            } else {
                $settings[] = 'xdebug.default_enable=0';

                if ($collectCoverage) {
                    $settings[] = 'xdebug.coverage_enable=1';
                }
            }
        }

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