%PDF-
%PDF-
Mini Shell
Mini Shell
<?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 = ''): 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, '\\'));
}
}
Zerion Mini Shell 1.0