You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
784 lines
25 KiB
784 lines
25 KiB
<?php declare(strict_types=1);
|
|
/*
|
|
* This file is part of PHPUnit.
|
|
*
|
|
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
namespace PHPUnit\Util;
|
|
|
|
use const PHP_OS;
|
|
use const PHP_VERSION;
|
|
use function addcslashes;
|
|
use function array_flip;
|
|
use function array_key_exists;
|
|
use function array_merge;
|
|
use function array_unique;
|
|
use function array_unshift;
|
|
use function class_exists;
|
|
use function count;
|
|
use function explode;
|
|
use function extension_loaded;
|
|
use function function_exists;
|
|
use function get_class;
|
|
use function ini_get;
|
|
use function interface_exists;
|
|
use function is_array;
|
|
use function is_int;
|
|
use function method_exists;
|
|
use function phpversion;
|
|
use function preg_match;
|
|
use function preg_replace;
|
|
use function sprintf;
|
|
use function strncmp;
|
|
use function strpos;
|
|
use function strtolower;
|
|
use function trim;
|
|
use function version_compare;
|
|
use PHPUnit\Framework\CodeCoverageException;
|
|
use PHPUnit\Framework\ExecutionOrderDependency;
|
|
use PHPUnit\Framework\InvalidCoversTargetException;
|
|
use PHPUnit\Framework\SelfDescribing;
|
|
use PHPUnit\Framework\TestCase;
|
|
use PHPUnit\Framework\Warning;
|
|
use PHPUnit\Runner\Version;
|
|
use PHPUnit\Util\Annotation\Registry;
|
|
use ReflectionClass;
|
|
use ReflectionException;
|
|
use ReflectionMethod;
|
|
use SebastianBergmann\CodeUnit\CodeUnitCollection;
|
|
use SebastianBergmann\CodeUnit\InvalidCodeUnitException;
|
|
use SebastianBergmann\CodeUnit\Mapper;
|
|
use SebastianBergmann\Environment\OperatingSystem;
|
|
|
|
/**
|
|
* @internal This class is not covered by the backward compatibility promise for PHPUnit
|
|
*/
|
|
final class Test
|
|
{
|
|
/**
|
|
* @var int
|
|
*/
|
|
public const UNKNOWN = -1;
|
|
|
|
/**
|
|
* @var int
|
|
*/
|
|
public const SMALL = 0;
|
|
|
|
/**
|
|
* @var int
|
|
*/
|
|
public const MEDIUM = 1;
|
|
|
|
/**
|
|
* @var int
|
|
*/
|
|
public const LARGE = 2;
|
|
|
|
/**
|
|
* @var array
|
|
*/
|
|
private static $hookMethods = [];
|
|
|
|
/**
|
|
* @throws \SebastianBergmann\RecursionContext\InvalidArgumentException
|
|
*/
|
|
public static function describe(\PHPUnit\Framework\Test $test): array
|
|
{
|
|
if ($test instanceof TestCase) {
|
|
return [get_class($test), $test->getName()];
|
|
}
|
|
|
|
if ($test instanceof SelfDescribing) {
|
|
return ['', $test->toString()];
|
|
}
|
|
|
|
return ['', get_class($test)];
|
|
}
|
|
|
|
public static function describeAsString(\PHPUnit\Framework\Test $test): string
|
|
{
|
|
if ($test instanceof SelfDescribing) {
|
|
return $test->toString();
|
|
}
|
|
|
|
return get_class($test);
|
|
}
|
|
|
|
/**
|
|
* @throws CodeCoverageException
|
|
*
|
|
* @return array|bool
|
|
*
|
|
* @psalm-param class-string $className
|
|
*/
|
|
public static function getLinesToBeCovered(string $className, string $methodName)
|
|
{
|
|
$annotations = self::parseTestMethodAnnotations(
|
|
$className,
|
|
$methodName,
|
|
);
|
|
|
|
if (!self::shouldCoversAnnotationBeUsed($annotations)) {
|
|
return false;
|
|
}
|
|
|
|
return self::getLinesToBeCoveredOrUsed($className, $methodName, 'covers');
|
|
}
|
|
|
|
/**
|
|
* Returns lines of code specified with the @uses annotation.
|
|
*
|
|
* @throws CodeCoverageException
|
|
*
|
|
* @psalm-param class-string $className
|
|
*/
|
|
public static function getLinesToBeUsed(string $className, string $methodName): array
|
|
{
|
|
return self::getLinesToBeCoveredOrUsed($className, $methodName, 'uses');
|
|
}
|
|
|
|
public static function requiresCodeCoverageDataCollection(TestCase $test): bool
|
|
{
|
|
$annotations = self::parseTestMethodAnnotations(
|
|
get_class($test),
|
|
$test->getName(false),
|
|
);
|
|
|
|
// If there is no @covers annotation but a @coversNothing annotation on
|
|
// the test method then code coverage data does not need to be collected
|
|
if (isset($annotations['method']['coversNothing'])) {
|
|
// @see https://github.com/sebastianbergmann/phpunit/issues/4947#issuecomment-1084480950
|
|
// return false;
|
|
}
|
|
|
|
// If there is at least one @covers annotation then
|
|
// code coverage data needs to be collected
|
|
if (isset($annotations['method']['covers'])) {
|
|
return true;
|
|
}
|
|
|
|
// If there is no @covers annotation but a @coversNothing annotation
|
|
// then code coverage data does not need to be collected
|
|
if (isset($annotations['class']['coversNothing'])) {
|
|
// @see https://github.com/sebastianbergmann/phpunit/issues/4947#issuecomment-1084480950
|
|
// return false;
|
|
}
|
|
|
|
// If there is no @coversNothing annotation then
|
|
// code coverage data may be collected
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @throws Exception
|
|
*
|
|
* @psalm-param class-string $className
|
|
*/
|
|
public static function getRequirements(string $className, string $methodName): array
|
|
{
|
|
return self::mergeArraysRecursively(
|
|
Registry::getInstance()->forClassName($className)->requirements(),
|
|
Registry::getInstance()->forMethod($className, $methodName)->requirements(),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns the missing requirements for a test.
|
|
*
|
|
* @throws Exception
|
|
* @throws Warning
|
|
*
|
|
* @psalm-param class-string $className
|
|
*/
|
|
public static function getMissingRequirements(string $className, string $methodName): array
|
|
{
|
|
$required = self::getRequirements($className, $methodName);
|
|
$missing = [];
|
|
$hint = null;
|
|
|
|
if (!empty($required['PHP'])) {
|
|
$operator = new VersionComparisonOperator(empty($required['PHP']['operator']) ? '>=' : $required['PHP']['operator']);
|
|
|
|
if (!version_compare(PHP_VERSION, $required['PHP']['version'], $operator->asString())) {
|
|
$missing[] = sprintf('PHP %s %s is required.', $operator->asString(), $required['PHP']['version']);
|
|
$hint = 'PHP';
|
|
}
|
|
} elseif (!empty($required['PHP_constraint'])) {
|
|
$version = new \PharIo\Version\Version(self::sanitizeVersionNumber(PHP_VERSION));
|
|
|
|
if (!$required['PHP_constraint']['constraint']->complies($version)) {
|
|
$missing[] = sprintf(
|
|
'PHP version does not match the required constraint %s.',
|
|
$required['PHP_constraint']['constraint']->asString(),
|
|
);
|
|
|
|
$hint = 'PHP_constraint';
|
|
}
|
|
}
|
|
|
|
if (!empty($required['PHPUnit'])) {
|
|
$phpunitVersion = Version::id();
|
|
|
|
$operator = new VersionComparisonOperator(empty($required['PHPUnit']['operator']) ? '>=' : $required['PHPUnit']['operator']);
|
|
|
|
if (!version_compare($phpunitVersion, $required['PHPUnit']['version'], $operator->asString())) {
|
|
$missing[] = sprintf('PHPUnit %s %s is required.', $operator->asString(), $required['PHPUnit']['version']);
|
|
$hint = $hint ?? 'PHPUnit';
|
|
}
|
|
} elseif (!empty($required['PHPUnit_constraint'])) {
|
|
$phpunitVersion = new \PharIo\Version\Version(self::sanitizeVersionNumber(Version::id()));
|
|
|
|
if (!$required['PHPUnit_constraint']['constraint']->complies($phpunitVersion)) {
|
|
$missing[] = sprintf(
|
|
'PHPUnit version does not match the required constraint %s.',
|
|
$required['PHPUnit_constraint']['constraint']->asString(),
|
|
);
|
|
|
|
$hint = $hint ?? 'PHPUnit_constraint';
|
|
}
|
|
}
|
|
|
|
if (!empty($required['OSFAMILY']) && $required['OSFAMILY'] !== (new OperatingSystem)->getFamily()) {
|
|
$missing[] = sprintf('Operating system %s is required.', $required['OSFAMILY']);
|
|
$hint = $hint ?? 'OSFAMILY';
|
|
}
|
|
|
|
if (!empty($required['OS'])) {
|
|
$requiredOsPattern = sprintf('/%s/i', addcslashes($required['OS'], '/'));
|
|
|
|
if (!preg_match($requiredOsPattern, PHP_OS)) {
|
|
$missing[] = sprintf('Operating system matching %s is required.', $requiredOsPattern);
|
|
$hint = $hint ?? 'OS';
|
|
}
|
|
}
|
|
|
|
if (!empty($required['functions'])) {
|
|
foreach ($required['functions'] as $function) {
|
|
$pieces = explode('::', $function);
|
|
|
|
if (count($pieces) === 2 && class_exists($pieces[0]) && method_exists($pieces[0], $pieces[1])) {
|
|
continue;
|
|
}
|
|
|
|
if (function_exists($function)) {
|
|
continue;
|
|
}
|
|
|
|
$missing[] = sprintf('Function %s is required.', $function);
|
|
$hint = $hint ?? 'function_' . $function;
|
|
}
|
|
}
|
|
|
|
if (!empty($required['setting'])) {
|
|
foreach ($required['setting'] as $setting => $value) {
|
|
if (ini_get($setting) !== $value) {
|
|
$missing[] = sprintf('Setting "%s" must be "%s".', $setting, $value);
|
|
$hint = $hint ?? '__SETTING_' . $setting;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!empty($required['extensions'])) {
|
|
foreach ($required['extensions'] as $extension) {
|
|
if (isset($required['extension_versions'][$extension])) {
|
|
continue;
|
|
}
|
|
|
|
if (!extension_loaded($extension)) {
|
|
$missing[] = sprintf('Extension %s is required.', $extension);
|
|
$hint = $hint ?? 'extension_' . $extension;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!empty($required['extension_versions'])) {
|
|
foreach ($required['extension_versions'] as $extension => $req) {
|
|
$actualVersion = phpversion($extension);
|
|
|
|
$operator = new VersionComparisonOperator(empty($req['operator']) ? '>=' : $req['operator']);
|
|
|
|
if ($actualVersion === false || !version_compare($actualVersion, $req['version'], $operator->asString())) {
|
|
$missing[] = sprintf('Extension %s %s %s is required.', $extension, $operator->asString(), $req['version']);
|
|
$hint = $hint ?? 'extension_' . $extension;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($hint && isset($required['__OFFSET'])) {
|
|
array_unshift($missing, '__OFFSET_FILE=' . $required['__OFFSET']['__FILE']);
|
|
array_unshift($missing, '__OFFSET_LINE=' . ($required['__OFFSET'][$hint] ?? 1));
|
|
}
|
|
|
|
return $missing;
|
|
}
|
|
|
|
/**
|
|
* Returns the provided data for a method.
|
|
*
|
|
* @throws Exception
|
|
*
|
|
* @psalm-param class-string $className
|
|
*/
|
|
public static function getProvidedData(string $className, string $methodName): ?array
|
|
{
|
|
return Registry::getInstance()->forMethod($className, $methodName)->getProvidedData();
|
|
}
|
|
|
|
/**
|
|
* @psalm-param class-string $className
|
|
*/
|
|
public static function parseTestMethodAnnotations(string $className, ?string $methodName = null): array
|
|
{
|
|
$registry = Registry::getInstance();
|
|
|
|
if ($methodName !== null) {
|
|
try {
|
|
return [
|
|
'method' => $registry->forMethod($className, $methodName)->symbolAnnotations(),
|
|
'class' => $registry->forClassName($className)->symbolAnnotations(),
|
|
];
|
|
} catch (Exception $methodNotFound) {
|
|
// ignored
|
|
}
|
|
}
|
|
|
|
return [
|
|
'method' => null,
|
|
'class' => $registry->forClassName($className)->symbolAnnotations(),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @psalm-param class-string $className
|
|
*/
|
|
public static function getInlineAnnotations(string $className, string $methodName): array
|
|
{
|
|
return Registry::getInstance()->forMethod($className, $methodName)->getInlineAnnotations();
|
|
}
|
|
|
|
/** @psalm-param class-string $className */
|
|
public static function getBackupSettings(string $className, string $methodName): array
|
|
{
|
|
return [
|
|
'backupGlobals' => self::getBooleanAnnotationSetting(
|
|
$className,
|
|
$methodName,
|
|
'backupGlobals',
|
|
),
|
|
'backupStaticAttributes' => self::getBooleanAnnotationSetting(
|
|
$className,
|
|
$methodName,
|
|
'backupStaticAttributes',
|
|
),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @psalm-param class-string $className
|
|
*
|
|
* @return ExecutionOrderDependency[]
|
|
*/
|
|
public static function getDependencies(string $className, string $methodName): array
|
|
{
|
|
$annotations = self::parseTestMethodAnnotations(
|
|
$className,
|
|
$methodName,
|
|
);
|
|
|
|
$dependsAnnotations = $annotations['class']['depends'] ?? [];
|
|
|
|
if (isset($annotations['method']['depends'])) {
|
|
$dependsAnnotations = array_merge(
|
|
$dependsAnnotations,
|
|
$annotations['method']['depends'],
|
|
);
|
|
}
|
|
|
|
// Normalize dependency name to className::methodName
|
|
$dependencies = [];
|
|
|
|
foreach ($dependsAnnotations as $value) {
|
|
$dependencies[] = ExecutionOrderDependency::createFromDependsAnnotation($className, $value);
|
|
}
|
|
|
|
return array_unique($dependencies);
|
|
}
|
|
|
|
/** @psalm-param class-string $className */
|
|
public static function getGroups(string $className, ?string $methodName = ''): array
|
|
{
|
|
$annotations = self::parseTestMethodAnnotations(
|
|
$className,
|
|
$methodName,
|
|
);
|
|
|
|
$groups = [];
|
|
|
|
if (isset($annotations['method']['author'])) {
|
|
$groups[] = $annotations['method']['author'];
|
|
} elseif (isset($annotations['class']['author'])) {
|
|
$groups[] = $annotations['class']['author'];
|
|
}
|
|
|
|
if (isset($annotations['class']['group'])) {
|
|
$groups[] = $annotations['class']['group'];
|
|
}
|
|
|
|
if (isset($annotations['method']['group'])) {
|
|
$groups[] = $annotations['method']['group'];
|
|
}
|
|
|
|
if (isset($annotations['class']['ticket'])) {
|
|
$groups[] = $annotations['class']['ticket'];
|
|
}
|
|
|
|
if (isset($annotations['method']['ticket'])) {
|
|
$groups[] = $annotations['method']['ticket'];
|
|
}
|
|
|
|
foreach (['method', 'class'] as $element) {
|
|
foreach (['small', 'medium', 'large'] as $size) {
|
|
if (isset($annotations[$element][$size])) {
|
|
$groups[] = [$size];
|
|
|
|
break 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (['method', 'class'] as $element) {
|
|
if (isset($annotations[$element]['covers'])) {
|
|
foreach ($annotations[$element]['covers'] as $coversTarget) {
|
|
$groups[] = ['__phpunit_covers_' . self::canonicalizeName($coversTarget)];
|
|
}
|
|
}
|
|
|
|
if (isset($annotations[$element]['uses'])) {
|
|
foreach ($annotations[$element]['uses'] as $usesTarget) {
|
|
$groups[] = ['__phpunit_uses_' . self::canonicalizeName($usesTarget)];
|
|
}
|
|
}
|
|
}
|
|
|
|
return array_unique(array_merge([], ...$groups));
|
|
}
|
|
|
|
/** @psalm-param class-string $className */
|
|
public static function getSize(string $className, ?string $methodName): int
|
|
{
|
|
$groups = array_flip(self::getGroups($className, $methodName));
|
|
|
|
if (isset($groups['large'])) {
|
|
return self::LARGE;
|
|
}
|
|
|
|
if (isset($groups['medium'])) {
|
|
return self::MEDIUM;
|
|
}
|
|
|
|
if (isset($groups['small'])) {
|
|
return self::SMALL;
|
|
}
|
|
|
|
return self::UNKNOWN;
|
|
}
|
|
|
|
/** @psalm-param class-string $className */
|
|
public static function getProcessIsolationSettings(string $className, string $methodName): bool
|
|
{
|
|
$annotations = self::parseTestMethodAnnotations(
|
|
$className,
|
|
$methodName,
|
|
);
|
|
|
|
return isset($annotations['class']['runTestsInSeparateProcesses']) || isset($annotations['method']['runInSeparateProcess']);
|
|
}
|
|
|
|
/** @psalm-param class-string $className */
|
|
public static function getClassProcessIsolationSettings(string $className, string $methodName): bool
|
|
{
|
|
$annotations = self::parseTestMethodAnnotations(
|
|
$className,
|
|
$methodName,
|
|
);
|
|
|
|
return isset($annotations['class']['runClassInSeparateProcess']);
|
|
}
|
|
|
|
/** @psalm-param class-string $className */
|
|
public static function getPreserveGlobalStateSettings(string $className, string $methodName): ?bool
|
|
{
|
|
return self::getBooleanAnnotationSetting(
|
|
$className,
|
|
$methodName,
|
|
'preserveGlobalState',
|
|
);
|
|
}
|
|
|
|
/** @psalm-param class-string $className */
|
|
public static function getHookMethods(string $className): array
|
|
{
|
|
if (!class_exists($className, false)) {
|
|
return self::emptyHookMethodsArray();
|
|
}
|
|
|
|
if (!isset(self::$hookMethods[$className])) {
|
|
self::$hookMethods[$className] = self::emptyHookMethodsArray();
|
|
|
|
try {
|
|
foreach ((new Reflection)->methodsInTestClass(new ReflectionClass($className)) as $method) {
|
|
$docBlock = Registry::getInstance()->forMethod($className, $method->getName());
|
|
|
|
if ($method->isStatic()) {
|
|
if ($docBlock->isHookToBeExecutedBeforeClass()) {
|
|
array_unshift(
|
|
self::$hookMethods[$className]['beforeClass'],
|
|
$method->getName(),
|
|
);
|
|
}
|
|
|
|
if ($docBlock->isHookToBeExecutedAfterClass()) {
|
|
self::$hookMethods[$className]['afterClass'][] = $method->getName();
|
|
}
|
|
}
|
|
|
|
if ($docBlock->isToBeExecutedBeforeTest()) {
|
|
array_unshift(
|
|
self::$hookMethods[$className]['before'],
|
|
$method->getName(),
|
|
);
|
|
}
|
|
|
|
if ($docBlock->isToBeExecutedAsPreCondition()) {
|
|
array_unshift(
|
|
self::$hookMethods[$className]['preCondition'],
|
|
$method->getName(),
|
|
);
|
|
}
|
|
|
|
if ($docBlock->isToBeExecutedAsPostCondition()) {
|
|
self::$hookMethods[$className]['postCondition'][] = $method->getName();
|
|
}
|
|
|
|
if ($docBlock->isToBeExecutedAfterTest()) {
|
|
self::$hookMethods[$className]['after'][] = $method->getName();
|
|
}
|
|
}
|
|
} catch (ReflectionException $e) {
|
|
}
|
|
}
|
|
|
|
return self::$hookMethods[$className];
|
|
}
|
|
|
|
public static function isTestMethod(ReflectionMethod $method): bool
|
|
{
|
|
if (!$method->isPublic()) {
|
|
return false;
|
|
}
|
|
|
|
if (strpos($method->getName(), 'test') === 0) {
|
|
return true;
|
|
}
|
|
|
|
return array_key_exists(
|
|
'test',
|
|
Registry::getInstance()->forMethod(
|
|
$method->getDeclaringClass()->getName(),
|
|
$method->getName(),
|
|
)
|
|
->symbolAnnotations(),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @throws CodeCoverageException
|
|
*
|
|
* @psalm-param class-string $className
|
|
*/
|
|
private static function getLinesToBeCoveredOrUsed(string $className, string $methodName, string $mode): array
|
|
{
|
|
$annotations = self::parseTestMethodAnnotations(
|
|
$className,
|
|
$methodName,
|
|
);
|
|
|
|
$classShortcut = null;
|
|
|
|
if (!empty($annotations['class'][$mode . 'DefaultClass'])) {
|
|
if (count($annotations['class'][$mode . 'DefaultClass']) > 1) {
|
|
throw new CodeCoverageException(
|
|
sprintf(
|
|
'More than one @%sClass annotation in class or interface "%s".',
|
|
$mode,
|
|
$className,
|
|
),
|
|
);
|
|
}
|
|
|
|
$classShortcut = $annotations['class'][$mode . 'DefaultClass'][0];
|
|
}
|
|
|
|
$list = $annotations['class'][$mode] ?? [];
|
|
|
|
if (isset($annotations['method'][$mode])) {
|
|
$list = array_merge($list, $annotations['method'][$mode]);
|
|
}
|
|
|
|
$codeUnits = CodeUnitCollection::fromArray([]);
|
|
$mapper = new Mapper;
|
|
|
|
foreach (array_unique($list) as $element) {
|
|
if ($classShortcut && strncmp($element, '::', 2) === 0) {
|
|
$element = $classShortcut . $element;
|
|
}
|
|
|
|
$element = preg_replace('/[\s()]+$/', '', $element);
|
|
$element = explode(' ', $element);
|
|
$element = $element[0];
|
|
|
|
if ($mode === 'covers' && interface_exists($element)) {
|
|
throw new InvalidCoversTargetException(
|
|
sprintf(
|
|
'Trying to @cover interface "%s".',
|
|
$element,
|
|
),
|
|
);
|
|
}
|
|
|
|
try {
|
|
$codeUnits = $codeUnits->mergeWith($mapper->stringToCodeUnits($element));
|
|
} catch (InvalidCodeUnitException $e) {
|
|
throw new InvalidCoversTargetException(
|
|
sprintf(
|
|
'"@%s %s" is invalid',
|
|
$mode,
|
|
$element,
|
|
),
|
|
$e->getCode(),
|
|
$e,
|
|
);
|
|
}
|
|
}
|
|
|
|
return $mapper->codeUnitsToSourceLines($codeUnits);
|
|
}
|
|
|
|
private static function emptyHookMethodsArray(): array
|
|
{
|
|
return [
|
|
'beforeClass' => ['setUpBeforeClass'],
|
|
'before' => ['setUp'],
|
|
'preCondition' => ['assertPreConditions'],
|
|
'postCondition' => ['assertPostConditions'],
|
|
'after' => ['tearDown'],
|
|
'afterClass' => ['tearDownAfterClass'],
|
|
];
|
|
}
|
|
|
|
/** @psalm-param class-string $className */
|
|
private static function getBooleanAnnotationSetting(string $className, ?string $methodName, string $settingName): ?bool
|
|
{
|
|
$annotations = self::parseTestMethodAnnotations(
|
|
$className,
|
|
$methodName,
|
|
);
|
|
|
|
if (isset($annotations['method'][$settingName])) {
|
|
if ($annotations['method'][$settingName][0] === 'enabled') {
|
|
return true;
|
|
}
|
|
|
|
if ($annotations['method'][$settingName][0] === 'disabled') {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (isset($annotations['class'][$settingName])) {
|
|
if ($annotations['class'][$settingName][0] === 'enabled') {
|
|
return true;
|
|
}
|
|
|
|
if ($annotations['class'][$settingName][0] === 'disabled') {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Trims any extensions from version string that follows after
|
|
* the <major>.<minor>[.<patch>] format.
|
|
*/
|
|
private static function sanitizeVersionNumber(string $version)
|
|
{
|
|
return preg_replace(
|
|
'/^(\d+\.\d+(?:.\d+)?).*$/',
|
|
'$1',
|
|
$version,
|
|
);
|
|
}
|
|
|
|
private static function shouldCoversAnnotationBeUsed(array $annotations): bool
|
|
{
|
|
if (isset($annotations['method']['coversNothing'])) {
|
|
return false;
|
|
}
|
|
|
|
if (isset($annotations['method']['covers'])) {
|
|
return true;
|
|
}
|
|
|
|
if (isset($annotations['class']['coversNothing'])) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Merge two arrays together.
|
|
*
|
|
* If an integer key exists in both arrays and preserveNumericKeys is false, the value
|
|
* from the second array will be appended to the first array. If both values are arrays, they
|
|
* are merged together, else the value of the second array overwrites the one of the first array.
|
|
*
|
|
* This implementation is copied from https://github.com/zendframework/zend-stdlib/blob/76b653c5e99b40eccf5966e3122c90615134ae46/src/ArrayUtils.php
|
|
*
|
|
* Zend Framework (http://framework.zend.com/)
|
|
*
|
|
* @see http://github.com/zendframework/zf2 for the canonical source repository
|
|
*
|
|
* @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
|
|
* @license http://framework.zend.com/license/new-bsd New BSD License
|
|
*/
|
|
private static function mergeArraysRecursively(array $a, array $b): array
|
|
{
|
|
foreach ($b as $key => $value) {
|
|
if (array_key_exists($key, $a)) {
|
|
if (is_int($key)) {
|
|
$a[] = $value;
|
|
} elseif (is_array($value) && is_array($a[$key])) {
|
|
$a[$key] = self::mergeArraysRecursively($a[$key], $value);
|
|
} else {
|
|
$a[$key] = $value;
|
|
}
|
|
} else {
|
|
$a[$key] = $value;
|
|
}
|
|
}
|
|
|
|
return $a;
|
|
}
|
|
|
|
private static function canonicalizeName(string $name): string
|
|
{
|
|
return strtolower(trim($name, '\\'));
|
|
}
|
|
}
|