<form method="POST">
    <h3>Editing: DocBlock.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\Util\Annotation;

use const JSON_ERROR_NONE;
use const PREG_OFFSET_CAPTURE;
use function array_filter;
use function array_key_exists;
use function array_map;
use function array_merge;
use function array_pop;
use function array_slice;
use function array_values;
use function count;
use function explode;
use function file;
use function implode;
use function is_array;
use function is_int;
use function json_decode;
use function json_last_error;
use function json_last_error_msg;
use function preg_match;
use function preg_match_all;
use function preg_replace;
use function preg_split;
use function realpath;
use function rtrim;
use function sprintf;
use function str_replace;
use function strlen;
use function strpos;
use function strtolower;
use function substr;
use function trim;
use PharIo\Version\VersionConstraintParser;
use PHPUnit\Framework\InvalidDataProviderException;
use PHPUnit\Framework\SkippedTestError;
use PHPUnit\Framework\Warning;
use PHPUnit\Util\Exception;
use PHPUnit\Util\InvalidDataSetException;
use ReflectionClass;
use ReflectionException;
use ReflectionFunctionAbstract;
use ReflectionMethod;
use Reflector;
use Traversable;

/**
 * This is an abstraction around a PHPUnit-specific docBlock,
 * allowing us to ask meaningful questions about a specific
 * reflection symbol.
 *
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
 */
final class DocBlock
{
    /**
     * @todo This constant should be private (it's public because of TestTest::testGetProvidedDataRegEx)
     */
    public const REGEX_DATA_PROVIDER = '/@dataProvider\s+([a-zA-Z0-9._:-\\\\x7f-\xff]+)/';

    private const REGEX_REQUIRES_VERSION            = '/@requires\s+(?P&lt;name&gt;PHP(?:Unit)?)\s+(?P&lt;operator&gt;[&lt;&gt;=!]{0,2})\s*(?P&lt;version&gt;[\d\.-]+(dev|(RC|alpha|beta)[\d\.])?)[ \t]*\r?$/m';
    private const REGEX_REQUIRES_VERSION_CONSTRAINT = '/@requires\s+(?P&lt;name&gt;PHP(?:Unit)?)\s+(?P&lt;constraint&gt;[\d\t \-.|~^]+)[ \t]*\r?$/m';
    private const REGEX_REQUIRES_OS                 = '/@requires\s+(?P&lt;name&gt;OS(?:FAMILY)?)\s+(?P&lt;value&gt;.+?)[ \t]*\r?$/m';
    private const REGEX_REQUIRES_SETTING            = '/@requires\s+(?P&lt;name&gt;setting)\s+(?P&lt;setting&gt;([^ ]+?))\s*(?P&lt;value&gt;[\w\.-]+[\w\.]?)?[ \t]*\r?$/m';
    private const REGEX_REQUIRES                    = '/@requires\s+(?P&lt;name&gt;function|extension)\s+(?P&lt;value&gt;([^\s&lt;&gt;=!]+))\s*(?P&lt;operator&gt;[&lt;&gt;=!]{0,2})\s*(?P&lt;version&gt;[\d\.-]+[\d\.]?)?[ \t]*\r?$/m';
    private const REGEX_TEST_WITH                   = '/@testWith\s+/';

    /** @var string */
    private $docComment;

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

    /** @var array&lt;string, array&lt;int, string&gt;&gt; pre-parsed annotations indexed by name and occurrence index */
    private $symbolAnnotations;

    /**
     * @var null|array&lt;string, mixed&gt;
     *
     * @psalm-var null|(array{
     *   __OFFSET: array&lt;string, int&gt;&amp;array{__FILE: string},
     *   setting?: array&lt;string, string&gt;,
     *   extension_versions?: array&lt;string, array{version: string, operator: string}&gt;
     * }&amp;array&lt;
     *   string,
     *   string|array{version: string, operator: string}|array{constraint: string}|array&lt;int|string, string&gt;
     * &gt;)
     */
    private $parsedRequirements;

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

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

    /** @var string */
    private $fileName;

    /** @var string */
    private $name;

    /**
     * @var string
     *
     * @psalm-var class-string
     */
    private $className;

    public static function ofClass(ReflectionClass $class): self
    {
        $className = $class-&gt;getName();

        return new self(
            (string) $class-&gt;getDocComment(),
            false,
            self::extractAnnotationsFromReflector($class),
            $class-&gt;getStartLine(),
            $class-&gt;getEndLine(),
            $class-&gt;getFileName(),
            $className,
            $className,
        );
    }

    /**
     * @psalm-param class-string $classNameInHierarchy
     */
    public static function ofMethod(ReflectionMethod $method, string $classNameInHierarchy): self
    {
        return new self(
            (string) $method-&gt;getDocComment(),
            true,
            self::extractAnnotationsFromReflector($method),
            $method-&gt;getStartLine(),
            $method-&gt;getEndLine(),
            $method-&gt;getFileName(),
            $method-&gt;getName(),
            $classNameInHierarchy,
        );
    }

    /**
     * Note: we do not preserve an instance of the reflection object, since it cannot be safely (de-)serialized.
     *
     * @param array&lt;string, array&lt;int, string&gt;&gt; $symbolAnnotations
     *
     * @psalm-param class-string $className
     */
    private function __construct(string $docComment, bool $isMethod, array $symbolAnnotations, int $startLine, int $endLine, string $fileName, string $name, string $className)
    {
        $this-&gt;docComment        = $docComment;
        $this-&gt;isMethod          = $isMethod;
        $this-&gt;symbolAnnotations = $symbolAnnotations;
        $this-&gt;startLine         = $startLine;
        $this-&gt;endLine           = $endLine;
        $this-&gt;fileName          = $fileName;
        $this-&gt;name              = $name;
        $this-&gt;className         = $className;
    }

    /**
     * @psalm-return array{
     *   __OFFSET: array&lt;string, int&gt;&amp;array{__FILE: string},
     *   setting?: array&lt;string, string&gt;,
     *   extension_versions?: array&lt;string, array{version: string, operator: string}&gt;
     * }&amp;array&lt;
     *   string,
     *   string|array{version: string, operator: string}|array{constraint: string}|array&lt;int|string, string&gt;
     * &gt;
     *
     * @throws Warning if the requirements version constraint is not well-formed
     */
    public function requirements(): array
    {
        if ($this-&gt;parsedRequirements !== null) {
            return $this-&gt;parsedRequirements;
        }

        $offset            = $this-&gt;startLine;
        $requires          = [];
        $recordedSettings  = [];
        $extensionVersions = [];
        $recordedOffsets   = [
            '__FILE' =&gt; realpath($this-&gt;fileName),
        ];

        // Trim docblock markers, split it into lines and rewind offset to start of docblock
        $lines = preg_replace(['#^/\*{2}#', '#\*/$#'], '', preg_split('/\r\n|\r|\n/', $this-&gt;docComment));
        $offset -= count($lines);

        foreach ($lines as $line) {
            if (preg_match(self::REGEX_REQUIRES_OS, $line, $matches)) {
                $requires[$matches['name']]        = $matches['value'];
                $recordedOffsets[$matches['name']] = $offset;
            }

            if (preg_match(self::REGEX_REQUIRES_VERSION, $line, $matches)) {
                $requires[$matches['name']] = [
                    'version'  =&gt; $matches['version'],
                    'operator' =&gt; $matches['operator'],
                ];
                $recordedOffsets[$matches['name']] = $offset;
            }

            if (preg_match(self::REGEX_REQUIRES_VERSION_CONSTRAINT, $line, $matches)) {
                if (!empty($requires[$matches['name']])) {
                    $offset++;

                    continue;
                }

                try {
                    $versionConstraintParser = new VersionConstraintParser;

                    $requires[$matches['name'] . '_constraint'] = [
                        'constraint' =&gt; $versionConstraintParser-&gt;parse(trim($matches['constraint'])),
                    ];
                    $recordedOffsets[$matches['name'] . '_constraint'] = $offset;
                } catch (\PharIo\Version\Exception $e) {
                    throw new Warning($e-&gt;getMessage(), $e-&gt;getCode(), $e);
                }
            }

            if (preg_match(self::REGEX_REQUIRES_SETTING, $line, $matches)) {
                $recordedSettings[$matches['setting']]               = $matches['value'];
                $recordedOffsets['__SETTING_' . $matches['setting']] = $offset;
            }

            if (preg_match(self::REGEX_REQUIRES, $line, $matches)) {
                $name = $matches['name'] . 's';

                if (!isset($requires[$name])) {
                    $requires[$name] = [];
                }

                $requires[$name][]                                           = $matches['value'];
                $recordedOffsets[$matches['name'] . '_' . $matches['value']] = $offset;

                if ($name === 'extensions' &amp;&amp; !empty($matches['version'])) {
                    $extensionVersions[$matches['value']] = [
                        'version'  =&gt; $matches['version'],
                        'operator' =&gt; $matches['operator'],
                    ];
                }
            }

            $offset++;
        }

        return $this-&gt;parsedRequirements = array_merge(
            $requires,
            ['__OFFSET' =&gt; $recordedOffsets],
            array_filter([
                'setting'            =&gt; $recordedSettings,
                'extension_versions' =&gt; $extensionVersions,
            ]),
        );
    }

    /**
     * Returns the provided data for a method.
     *
     * @throws Exception
     */
    public function getProvidedData(): ?array
    {
        /** @noinspection SuspiciousBinaryOperationInspection */
        $data = $this-&gt;getDataFromDataProviderAnnotation($this-&gt;docComment) ?? $this-&gt;getDataFromTestWithAnnotation($this-&gt;docComment);

        if ($data === null) {
            return null;
        }

        if ($data === []) {
            throw new SkippedTestError;
        }

        foreach ($data as $key =&gt; $value) {
            if (!is_array($value)) {
                throw new InvalidDataSetException(
                    sprintf(
                        'Data set %s is invalid.',
                        is_int($key) ? '#' . $key : '&quot;' . $key . '&quot;',
                    ),
                );
            }
        }

        return $data;
    }

    /**
     * @psalm-return array&lt;string, array{line: int, value: string}&gt;
     */
    public function getInlineAnnotations(): array
    {
        $code        = file($this-&gt;fileName);
        $lineNumber  = $this-&gt;startLine;
        $startLine   = $this-&gt;startLine - 1;
        $endLine     = $this-&gt;endLine - 1;
        $codeLines   = array_slice($code, $startLine, $endLine - $startLine + 1);
        $annotations = [];

        foreach ($codeLines as $line) {
            if (preg_match('#/\*\*?\s*@(?P&lt;name&gt;[A-Za-z_-]+)(?:[ \t]+(?P&lt;value&gt;.*?))?[ \t]*\r?\*/$#m', $line, $matches)) {
                $annotations[strtolower($matches['name'])] = [
                    'line'  =&gt; $lineNumber,
                    'value' =&gt; $matches['value'],
                ];
            }

            $lineNumber++;
        }

        return $annotations;
    }

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

    public function isHookToBeExecutedBeforeClass(): bool
    {
        return $this-&gt;isMethod &amp;&amp;
            false !== strpos($this-&gt;docComment, '@beforeClass');
    }

    public function isHookToBeExecutedAfterClass(): bool
    {
        return $this-&gt;isMethod &amp;&amp;
            false !== strpos($this-&gt;docComment, '@afterClass');
    }

    public function isToBeExecutedBeforeTest(): bool
    {
        return 1 === preg_match('/@before\b/', $this-&gt;docComment);
    }

    public function isToBeExecutedAfterTest(): bool
    {
        return 1 === preg_match('/@after\b/', $this-&gt;docComment);
    }

    public function isToBeExecutedAsPreCondition(): bool
    {
        return 1 === preg_match('/@preCondition\b/', $this-&gt;docComment);
    }

    public function isToBeExecutedAsPostCondition(): bool
    {
        return 1 === preg_match('/@postCondition\b/', $this-&gt;docComment);
    }

    private function getDataFromDataProviderAnnotation(string $docComment): ?array
    {
        $methodName = null;
        $className  = $this-&gt;className;

        if ($this-&gt;isMethod) {
            $methodName = $this-&gt;name;
        }

        if (!preg_match_all(self::REGEX_DATA_PROVIDER, $docComment, $matches)) {
            return null;
        }

        $result = [];

        foreach ($matches[1] as $match) {
            $dataProviderMethodNameNamespace = explode('\\', $match);
            $leaf                            = explode('::', array_pop($dataProviderMethodNameNamespace));
            $dataProviderMethodName          = array_pop($leaf);

            if (empty($dataProviderMethodNameNamespace)) {
                $dataProviderMethodNameNamespace = '';
            } else {
                $dataProviderMethodNameNamespace = implode('\\', $dataProviderMethodNameNamespace) . '\\';
            }

            if (empty($leaf)) {
                $dataProviderClassName = $className;
            } else {
                /** @psalm-var class-string $dataProviderClassName */
                $dataProviderClassName = $dataProviderMethodNameNamespace . array_pop($leaf);
            }

            try {
                $dataProviderClass = new ReflectionClass($dataProviderClassName);

                $dataProviderMethod = $dataProviderClass-&gt;getMethod(
                    $dataProviderMethodName,
                );
                // @codeCoverageIgnoreStart
            } catch (ReflectionException $e) {
                throw new Exception(
                    $e-&gt;getMessage(),
                    $e-&gt;getCode(),
                    $e,
                );
                // @codeCoverageIgnoreEnd
            }

            if ($dataProviderMethod-&gt;isStatic()) {
                $object = null;
            } else {
                $object = $dataProviderClass-&gt;newInstance();
            }

            if ($dataProviderMethod-&gt;getNumberOfParameters() === 0) {
                $data = $dataProviderMethod-&gt;invoke($object);
            } else {
                $data = $dataProviderMethod-&gt;invoke($object, $methodName);
            }

            if ($data instanceof Traversable) {
                $origData = $data;
                $data     = [];

                foreach ($origData as $key =&gt; $value) {
                    if (is_int($key)) {
                        $data[] = $value;
                    } elseif (array_key_exists($key, $data)) {
                        throw new InvalidDataProviderException(
                            sprintf(
                                'The key &quot;%s&quot; has already been defined in the data provider &quot;%s&quot;.',
                                $key,
                                $match,
                            ),
                        );
                    } else {
                        $data[$key] = $value;
                    }
                }
            }

            if (is_array($data)) {
                $result = array_merge($result, $data);
            }
        }

        return $result;
    }

    /**
     * @throws Exception
     */
    private function getDataFromTestWithAnnotation(string $docComment): ?array
    {
        $docComment = $this-&gt;cleanUpMultiLineAnnotation($docComment);

        if (!preg_match(self::REGEX_TEST_WITH, $docComment, $matches, PREG_OFFSET_CAPTURE)) {
            return null;
        }

        $offset            = strlen($matches[0][0]) + $matches[0][1];
        $annotationContent = substr($docComment, $offset);
        $data              = [];

        foreach (explode(&quot;\n&quot;, $annotationContent) as $candidateRow) {
            $candidateRow = trim($candidateRow);

            if ($candidateRow[0] !== '[') {
                break;
            }

            $dataSet = json_decode($candidateRow, true);

            if (json_last_error() !== JSON_ERROR_NONE) {
                throw new Exception(
                    'The data set for the @testWith annotation cannot be parsed: ' . json_last_error_msg(),
                );
            }

            $data[] = $dataSet;
        }

        if (!$data) {
            throw new Exception('The data set for the @testWith annotation cannot be parsed.');
        }

        return $data;
    }

    private function cleanUpMultiLineAnnotation(string $docComment): string
    {
        // removing initial '   * ' for docComment
        $docComment = str_replace(&quot;\r\n&quot;, &quot;\n&quot;, $docComment);
        $docComment = preg_replace('/\n\s*\*\s?/', &quot;\n&quot;, $docComment);
        $docComment = (string) substr($docComment, 0, -1);

        return rtrim($docComment, &quot;\n&quot;);
    }

    /** @return array&lt;string, array&lt;int, string&gt;&gt; */
    private static function parseDocBlock(string $docBlock): array
    {
        // Strip away the docblock header and footer to ease parsing of one line annotations
        $docBlock    = (string) substr($docBlock, 3, -2);
        $annotations = [];

        if (preg_match_all('/@(?P&lt;name&gt;[A-Za-z_-]+)(?:[ \t]+(?P&lt;value&gt;.*?))?[ \t]*\r?$/m', $docBlock, $matches)) {
            $numMatches = count($matches[0]);

            for ($i = 0; $i &lt; $numMatches; $i++) {
                $annotations[$matches['name'][$i]][] = (string) $matches['value'][$i];
            }
        }

        return $annotations;
    }

    /** @param ReflectionClass|ReflectionFunctionAbstract $reflector */
    private static function extractAnnotationsFromReflector(Reflector $reflector): array
    {
        $annotations = [];

        if ($reflector instanceof ReflectionClass) {
            $annotations = array_merge(
                $annotations,
                ...array_map(
                    static function (ReflectionClass $trait): array
                    {
                        return self::parseDocBlock((string) $trait-&gt;getDocComment());
                    },
                    array_values($reflector-&gt;getTraits()),
                ),
            );
        }

        return array_merge(
            $annotations,
            self::parseDocBlock((string) $reflector-&gt;getDocComment()),
        );
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>