Jordi Boggiano
4 years ago
committed by
GitHub
commit
a1c731b552
@ -0,0 +1,762 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of Composer.
|
||||
*
|
||||
* (c) Nils Adermann <naderman@naderman.de>
|
||||
* Jordi Boggiano <j.boggiano@seld.be>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace Composer\Test {
|
||||
use PHPUnit\Framework\TestCase;
|
||||
use PHPUnit\Framework\Constraint\IsEqual;
|
||||
use PHPUnit\Framework\Constraint\LogicalNot;
|
||||
use PHPUnit\Framework\Constraint\RegularExpression;
|
||||
use PHPUnit\Framework\Constraint\StringContains;
|
||||
use PHPUnit\Framework\Constraint\TraversableContains;
|
||||
|
||||
if (method_exists('PHPUnit\Framework\TestCase', 'assertStringContainsString')) {
|
||||
abstract class PolyfillTestCase extends TestCase {}
|
||||
} else {
|
||||
abstract class PolyfillTestCase extends TestCase
|
||||
{
|
||||
// all the functions below are form https://github.com/symfony/phpunit-bridge/blob/bd341a45ef79b30918376e8b8e2279fac6894c3b/Legacy/PolyfillAssertTrait.php
|
||||
|
||||
/**
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertIsInt($actual, $message = '')
|
||||
{
|
||||
static::assertInternalType('int', $actual, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertIsNumeric($actual, $message = '')
|
||||
{
|
||||
static::assertInternalType('numeric', $actual, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertIsObject($actual, $message = '')
|
||||
{
|
||||
static::assertInternalType('object', $actual, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertIsResource($actual, $message = '')
|
||||
{
|
||||
static::assertInternalType('resource', $actual, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertIsString($actual, $message = '')
|
||||
{
|
||||
static::assertInternalType('string', $actual, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertIsScalar($actual, $message = '')
|
||||
{
|
||||
static::assertInternalType('scalar', $actual, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertIsCallable($actual, $message = '')
|
||||
{
|
||||
static::assertInternalType('callable', $actual, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertIsIterable($actual, $message = '')
|
||||
{
|
||||
static::assertInternalType('iterable', $actual, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $needle
|
||||
* @param string $haystack
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertStringContainsString($needle, $haystack, $message = '')
|
||||
{
|
||||
$constraint = new StringContains($needle, false);
|
||||
static::assertThat($haystack, $constraint, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $needle
|
||||
* @param string $haystack
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertStringContainsStringIgnoringCase($needle, $haystack, $message = '')
|
||||
{
|
||||
$constraint = new StringContains($needle, true);
|
||||
static::assertThat($haystack, $constraint, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $needle
|
||||
* @param string $haystack
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertStringNotContainsString($needle, $haystack, $message = '')
|
||||
{
|
||||
$constraint = new LogicalNot(new StringContains($needle, false));
|
||||
static::assertThat($haystack, $constraint, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $needle
|
||||
* @param string $haystack
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertStringNotContainsStringIgnoringCase($needle, $haystack, $message = '')
|
||||
{
|
||||
$constraint = new LogicalNot(new StringContains($needle, true));
|
||||
static::assertThat($haystack, $constraint, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertFinite($actual, $message = '')
|
||||
{
|
||||
static::assertInternalType('float', $actual, $message);
|
||||
static::assertTrue(is_finite($actual), $message ? $message : "Failed asserting that $actual is finite.");
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertInfinite($actual, $message = '')
|
||||
{
|
||||
static::assertInternalType('float', $actual, $message);
|
||||
static::assertTrue(is_infinite($actual), $message ? $message : "Failed asserting that $actual is infinite.");
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertNan($actual, $message = '')
|
||||
{
|
||||
static::assertInternalType('float', $actual, $message);
|
||||
static::assertTrue(is_nan($actual), $message ? $message : "Failed asserting that $actual is nan.");
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $filename
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertIsReadable($filename, $message = '')
|
||||
{
|
||||
static::assertInternalType('string', $filename, $message);
|
||||
static::assertTrue(is_readable($filename), $message ? $message : "Failed asserting that $filename is readable.");
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $filename
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertNotIsReadable($filename, $message = '')
|
||||
{
|
||||
static::assertInternalType('string', $filename, $message);
|
||||
static::assertFalse(is_readable($filename), $message ? $message : "Failed asserting that $filename is not readable.");
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $filename
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertIsNotReadable($filename, $message = '')
|
||||
{
|
||||
static::assertNotIsReadable($filename, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $filename
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertIsWritable($filename, $message = '')
|
||||
{
|
||||
static::assertInternalType('string', $filename, $message);
|
||||
static::assertTrue(is_writable($filename), $message ? $message : "Failed asserting that $filename is writable.");
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $filename
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertNotIsWritable($filename, $message = '')
|
||||
{
|
||||
static::assertInternalType('string', $filename, $message);
|
||||
static::assertFalse(is_writable($filename), $message ? $message : "Failed asserting that $filename is not writable.");
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $filename
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertIsNotWritable($filename, $message = '')
|
||||
{
|
||||
static::assertNotIsWritable($filename, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $directory
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertDirectoryExists($directory, $message = '')
|
||||
{
|
||||
static::assertInternalType('string', $directory, $message);
|
||||
static::assertTrue(is_dir($directory), $message ? $message : "Failed asserting that $directory exists.");
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $directory
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertDirectoryNotExists($directory, $message = '')
|
||||
{
|
||||
static::assertInternalType('string', $directory, $message);
|
||||
static::assertFalse(is_dir($directory), $message ? $message : "Failed asserting that $directory does not exist.");
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $directory
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertDirectoryDoesNotExist($directory, $message = '')
|
||||
{
|
||||
static::assertDirectoryNotExists($directory, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $directory
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertDirectoryIsReadable($directory, $message = '')
|
||||
{
|
||||
static::assertDirectoryExists($directory, $message);
|
||||
static::assertIsReadable($directory, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $directory
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertDirectoryNotIsReadable($directory, $message = '')
|
||||
{
|
||||
static::assertDirectoryExists($directory, $message);
|
||||
static::assertNotIsReadable($directory, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $directory
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertDirectoryIsNotReadable($directory, $message = '')
|
||||
{
|
||||
static::assertDirectoryNotIsReadable($directory, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $directory
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertDirectoryIsWritable($directory, $message = '')
|
||||
{
|
||||
static::assertDirectoryExists($directory, $message);
|
||||
static::assertIsWritable($directory, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $directory
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertDirectoryNotIsWritable($directory, $message = '')
|
||||
{
|
||||
static::assertDirectoryExists($directory, $message);
|
||||
static::assertNotIsWritable($directory, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $directory
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertDirectoryIsNotWritable($directory, $message = '')
|
||||
{
|
||||
static::assertDirectoryNotIsWritable($directory, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $filename
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertFileExists($filename, $message = '')
|
||||
{
|
||||
static::assertInternalType('string', $filename, $message);
|
||||
static::assertTrue(file_exists($filename), $message ? $message : "Failed asserting that $filename exists.");
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $filename
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertFileNotExists($filename, $message = '')
|
||||
{
|
||||
static::assertInternalType('string', $filename, $message);
|
||||
static::assertFalse(file_exists($filename), $message ? $message : "Failed asserting that $filename does not exist.");
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $filename
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertFileDoesNotExist($filename, $message = '')
|
||||
{
|
||||
static::assertFileNotExists($filename, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $filename
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertFileIsReadable($filename, $message = '')
|
||||
{
|
||||
static::assertFileExists($filename, $message);
|
||||
static::assertIsReadable($filename, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $filename
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertFileNotIsReadable($filename, $message = '')
|
||||
{
|
||||
static::assertFileExists($filename, $message);
|
||||
static::assertNotIsReadable($filename, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $filename
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertFileIsNotReadable($filename, $message = '')
|
||||
{
|
||||
static::assertFileNotIsReadable($filename, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $filename
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertFileIsWritable($filename, $message = '')
|
||||
{
|
||||
static::assertFileExists($filename, $message);
|
||||
static::assertIsWritable($filename, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $filename
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertFileNotIsWritable($filename, $message = '')
|
||||
{
|
||||
static::assertFileExists($filename, $message);
|
||||
static::assertNotIsWritable($filename, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $filename
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertFileIsNotWritable($filename, $message = '')
|
||||
{
|
||||
static::assertFileNotIsWritable($filename, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $pattern
|
||||
* @param string $string
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertMatchesRegularExpression($pattern, $string, $message = '')
|
||||
{
|
||||
static::assertRegExp($pattern, $string, $message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $pattern
|
||||
* @param string $string
|
||||
* @param string $message
|
||||
*
|
||||
* @return void
|
||||
*/
|
||||
public static function assertDoesNotMatchRegularExpression($pattern, $string, $message = '')
|
||||
{
|
||||
static::assertNotRegExp($pattern, $string, $message);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
namespace {
|
||||
foreach (array(
|
||||
'PHPUnit\Framework\Constraint\IsEqual',
|
||||
'PHPUnit\Framework\Constraint\StringContains',
|
||||
'PHPUnit\Framework\Constraint\TraversableContains',
|
||||
) as $class) {
|
||||
if (!class_exists($class) && class_exists(str_replace('\\', '_', $class))) {
|
||||
class_alias(str_replace('\\', '_', $class), $class);
|
||||
}
|
||||
}
|
||||
|
||||
foreach (array(
|
||||
'PHPUnit\Framework\SelfDescribing',
|
||||
) as $interface) {
|
||||
if (!interface_exists($interface) && interface_exists(str_replace('\\', '_', $interface))) {
|
||||
class_alias(str_replace('\\', '_', $interface), $interface);
|
||||
}
|
||||
}
|
||||
|
||||
if (!class_exists('PHPUnit\Framework\Constraint\Constraint')) {
|
||||
class_alias('PHPUnit_Framework_Constraint', 'PHPUnit\Framework\Constraint\Constraint');
|
||||
}
|
||||
}
|
||||
|
||||
// all the code below taken from various PHPUnit versions to make things work on PHPUnit 4.8 / PHP 5.3
|
||||
/*
|
||||
* 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\Framework\Constraint {
|
||||
use Countable;
|
||||
use PHPUnit\Framework\ExpectationFailedException;
|
||||
|
||||
if (!class_exists('PHPUnit\Framework\Constraint\RegularExpression')) {
|
||||
/**
|
||||
* Constraint that asserts that the string it is evaluated for matches
|
||||
* a regular expression.
|
||||
*
|
||||
* Checks a given value using the Perl Compatible Regular Expression extension
|
||||
* in PHP. The pattern is matched by executing preg_match().
|
||||
*
|
||||
* The pattern string passed in the constructor.
|
||||
*/
|
||||
class RegularExpression extends Constraint
|
||||
{
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
protected $pattern;
|
||||
|
||||
/**
|
||||
* @param string $pattern
|
||||
*/
|
||||
public function __construct($pattern)
|
||||
{
|
||||
parent::__construct();
|
||||
$this->pattern = $pattern;
|
||||
}
|
||||
|
||||
/**
|
||||
* Evaluates the constraint for parameter $other. Returns true if the
|
||||
* constraint is met, false otherwise.
|
||||
*
|
||||
* @param mixed $other Value or object to evaluate.
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
protected function matches($other)
|
||||
{
|
||||
return \preg_match($this->pattern, $other) > 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a string representation of the constraint.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function toString()
|
||||
{
|
||||
return \sprintf(
|
||||
'matches PCRE pattern "%s"',
|
||||
$this->pattern
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!class_exists('PHPUnit\Framework\Constraint\LogicalNot')) {
|
||||
/**
|
||||
* Logical NOT.
|
||||
*/
|
||||
class LogicalNot extends Constraint
|
||||
{
|
||||
/**
|
||||
* @var Constraint
|
||||
*/
|
||||
protected $constraint;
|
||||
|
||||
/**
|
||||
* @param Constraint $constraint
|
||||
*/
|
||||
public function __construct($constraint)
|
||||
{
|
||||
parent::__construct();
|
||||
|
||||
if (!($constraint instanceof Constraint)) {
|
||||
$constraint = new IsEqual($constraint);
|
||||
}
|
||||
|
||||
$this->constraint = $constraint;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string $string
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public static function negate($string)
|
||||
{
|
||||
$positives = array(
|
||||
'contains ',
|
||||
'exists',
|
||||
'has ',
|
||||
'is ',
|
||||
'are ',
|
||||
'matches ',
|
||||
'starts with ',
|
||||
'ends with ',
|
||||
'reference ',
|
||||
'not not '
|
||||
);
|
||||
|
||||
$negatives = array(
|
||||
'does not contain ',
|
||||
'does not exist',
|
||||
'does not have ',
|
||||
'is not ',
|
||||
'are not ',
|
||||
'does not match ',
|
||||
'starts not with ',
|
||||
'ends not with ',
|
||||
'don\'t reference ',
|
||||
'not '
|
||||
);
|
||||
|
||||
\preg_match('/(\'[\w\W]*\')([\w\W]*)("[\w\W]*")/i', $string, $matches);
|
||||
|
||||
if (\count($matches) > 0) {
|
||||
$nonInput = $matches[2];
|
||||
|
||||
$negatedString = \str_replace(
|
||||
$nonInput,
|
||||
\str_replace(
|
||||
$positives,
|
||||
$negatives,
|
||||
$nonInput
|
||||
),
|
||||
$string
|
||||
);
|
||||
} else {
|
||||
$negatedString = \str_replace(
|
||||
$positives,
|
||||
$negatives,
|
||||
$string
|
||||
);
|
||||
}
|
||||
|
||||
return $negatedString;
|
||||
}
|
||||
|
||||
/**
|
||||
* Evaluates the constraint for parameter $other
|
||||
*
|
||||
* If $returnResult is set to false (the default), an exception is thrown
|
||||
* in case of a failure. null is returned otherwise.
|
||||
*
|
||||
* If $returnResult is true, the result of the evaluation is returned as
|
||||
* a boolean value instead: true in case of success, false in case of a
|
||||
* failure.
|
||||
*
|
||||
* @param mixed $other Value or object to evaluate.
|
||||
* @param string $description Additional information about the test
|
||||
* @param bool $returnResult Whether to return a result or throw an exception
|
||||
*
|
||||
* @return mixed
|
||||
*
|
||||
* @throws ExpectationFailedException
|
||||
*/
|
||||
public function evaluate($other, $description = '', $returnResult = false)
|
||||
{
|
||||
$success = !$this->constraint->evaluate($other, $description, true);
|
||||
|
||||
if ($returnResult) {
|
||||
return $success;
|
||||
}
|
||||
|
||||
if (!$success) {
|
||||
$this->fail($other, $description);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the description of the failure
|
||||
*
|
||||
* The beginning of failure messages is "Failed asserting that" in most
|
||||
* cases. This method should return the second part of that sentence.
|
||||
*
|
||||
* @param mixed $other Evaluated value or object.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
protected function failureDescription($other)
|
||||
{
|
||||
switch (\get_class($this->constraint)) {
|
||||
case 'PHPUnit\Framework\Constraint\LogicalAnd':
|
||||
case 'PHPUnit\Framework\Constraint\LogicalNot':
|
||||
case 'PHPUnit\Framework\Constraint\LogicalOr':
|
||||
return 'not( ' . $this->constraint->failureDescription($other) . ' )';
|
||||
|
||||
default:
|
||||
return self::negate(
|
||||
$this->constraint->failureDescription($other)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a string representation of the constraint.
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function toString()
|
||||
{
|
||||
switch (\get_class($this->constraint)) {
|
||||
case 'PHPUnit\Framework\Constraint\LogicalAnd':
|
||||
case 'PHPUnit\Framework\Constraint\LogicalNot':
|
||||
case 'PHPUnit\Framework\Constraint\LogicalOr':
|
||||
return 'not( ' . $this->constraint->toString() . ' )';
|
||||
|
||||
default:
|
||||
return self::negate(
|
||||
$this->constraint->toString()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Counts the number of constraint elements.
|
||||
*
|
||||
* @return int
|
||||
*/
|
||||
public function count()
|
||||
{
|
||||
return \count($this->constraint);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue