PK `TLrr .travis.ymlnu W+A language: php
sudo: false
php:
- 7.1
- 7.2
- master
env:
matrix:
- DEPENDENCIES="high"
- DEPENDENCIES="low"
global:
- DEFAULT_COMPOSER_FLAGS="--no-interaction --no-ansi --no-progress --no-suggest"
before_install:
- composer self-update
- composer clear-cache
install:
- if [[ "$DEPENDENCIES" = 'high' ]]; then travis_retry composer update $DEFAULT_COMPOSER_FLAGS; fi
- if [[ "$DEPENDENCIES" = 'low' ]]; then travis_retry composer update $DEFAULT_COMPOSER_FLAGS --prefer-lowest; fi
script:
- ./vendor/bin/phpunit --coverage-clover=coverage.xml
after_success:
- bash <(curl -s https://codecov.io/bash)
notifications:
email: false
PK `TL( .php_csnu W+A
For the full copyright and license information, please view the LICENSE
file that was distributed with this source code.
EOF;
return PhpCsFixer\Config::create()
->setRiskyAllowed(true)
->setRules(
[
'array_syntax' => ['syntax' => 'short'],
'binary_operator_spaces' => [
'align_double_arrow' => true,
'align_equals' => true
],
'blank_line_after_namespace' => true,
'blank_line_before_statement' => [
'statements' => [
'break',
'continue',
'return',
'throw',
'try',
],
],
'braces' => true,
'cast_spaces' => true,
'compact_nullable_typehint' => true,
'concat_space' => ['spacing' => 'one'],
'declare_equal_normalize' => ['space' => 'none'],
'dir_constant' => true,
'elseif' => true,
'encoding' => true,
'full_opening_tag' => true,
'function_declaration' => true,
'header_comment' => ['header' => $header, 'separate' => 'none'],
'indentation_type' => true,
'line_ending' => true,
'list_syntax' => ['syntax' => 'short'],
'lowercase_cast' => true,
'lowercase_constants' => true,
'lowercase_keywords' => true,
'magic_constant_casing' => true,
'method_argument_space' => ['ensure_fully_multiline' => true],
'method_separation' => true,
'modernize_types_casting' => true,
'native_function_casing' => true,
'native_function_invocation' => true,
'no_alias_functions' => true,
'no_blank_lines_after_class_opening' => true,
'no_blank_lines_after_phpdoc' => true,
'no_closing_tag' => true,
'no_empty_comment' => true,
'no_empty_phpdoc' => true,
'no_empty_statement' => true,
'no_extra_consecutive_blank_lines' => true,
'no_homoglyph_names' => true,
'no_leading_import_slash' => true,
'no_leading_namespace_whitespace' => true,
'no_mixed_echo_print' => ['use' => 'print'],
'no_null_property_initialization' => true,
'no_short_bool_cast' => true,
'no_short_echo_tag' => true,
'no_singleline_whitespace_before_semicolons' => true,
'no_spaces_after_function_name' => true,
'no_spaces_inside_parenthesis' => true,
'no_superfluous_elseif' => true,
'no_trailing_comma_in_list_call' => true,
'no_trailing_comma_in_singleline_array' => true,
'no_trailing_whitespace' => true,
'no_trailing_whitespace_in_comment' => true,
'no_unneeded_control_parentheses' => true,
'no_unneeded_curly_braces' => true,
'no_unneeded_final_method' => true,
'no_unreachable_default_argument_value' => true,
'no_unused_imports' => true,
'no_useless_else' => true,
'no_whitespace_before_comma_in_array' => true,
'no_whitespace_in_blank_line' => true,
'non_printable_character' => true,
'normalize_index_brace' => true,
'object_operator_without_whitespace' => true,
'ordered_class_elements' => [
'use_trait',
'constant_public',
'constant_protected',
'constant_private',
'property_public',
'property_protected',
'property_private',
'construct',
'destruct',
'magic',
'phpunit',
'method_public',
'method_protected',
'method_private'
],
'ordered_imports' => true,
'phpdoc_add_missing_param_annotation' => true,
'phpdoc_align' => true,
'phpdoc_annotation_without_dot' => true,
'phpdoc_indent' => true,
'phpdoc_no_access' => true,
'phpdoc_no_empty_return' => true,
'phpdoc_no_package' => true,
'phpdoc_order' => true,
'phpdoc_return_self_reference' => true,
'phpdoc_scalar' => true,
'phpdoc_separation' => true,
'phpdoc_single_line_var_spacing' => true,
'phpdoc_to_comment' => true,
'phpdoc_trim' => true,
'phpdoc_types' => true,
'phpdoc_types_order' => true,
'phpdoc_var_without_name' => true,
'pow_to_exponentiation' => true,
'protected_to_private' => true,
'return_type_declaration' => ['space_before' => 'none'],
'self_accessor' => true,
'short_scalar_cast' => true,
'simplified_null_return' => true,
'single_blank_line_at_eof' => true,
'single_import_per_statement' => true,
'single_line_after_imports' => true,
'single_quote' => true,
'standardize_not_equals' => true,
'ternary_to_null_coalescing' => true,
'trim_array_spaces' => true,
'unary_operator_spaces' => true,
'visibility_required' => true,
//'void_return' => true,
'whitespace_after_comma_in_array' => true,
]
)
->setFinder(
PhpCsFixer\Finder::create()
->files()
->in(__DIR__ . '/src')
->name('*.php')
);
PK `TL-A.# # README.mdnu W+A [![Latest Stable Version](https://img.shields.io/packagist/v/phpunit/phpunit-mock-objects.svg?style=flat-square)](https://packagist.org/packages/phpunit/phpunit-mock-objects)
[![Minimum PHP Version](https://img.shields.io/badge/php-%3E%3D%207.1-8892BF.svg?style=flat-square)](https://php.net/)
[![Build Status](https://img.shields.io/travis/sebastianbergmann/phpunit-mock-objects/master.svg?style=flat-square)](https://phpunit.de/build-status.html)
# phpunit-mock-objects
**phpunit-mock-objects** is the default mock object library for PHPUnit.
PK `TL9&- CONTRIBUTING.mdnu W+A Please refer to [https://github.com/sebastianbergmann/phpunit/blob/master/.github/CONTRIBUTING.md](https://github.com/sebastianbergmann/phpunit/blob/master/.github/CONTRIBUTING.md) for details on how to contribute to this project.
PK `TL<- -
.gitignorenu W+A /.idea
/.php_cs.cache
/composer.lock
/vendor
PK `TLD phpunit.xmlnu W+A
tests
tests
src
PK `TLQ src/Generator.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject;
use Doctrine\Instantiator\Exception\ExceptionInterface as InstantiatorException;
use Doctrine\Instantiator\Instantiator;
use Iterator;
use IteratorAggregate;
use PHPUnit\Framework\Exception;
use PHPUnit\Util\InvalidArgumentHelper;
use ReflectionClass;
use ReflectionException;
use ReflectionMethod;
use SoapClient;
use Text_Template;
use Traversable;
/**
* Mock Object Code Generator
*/
class Generator
{
/**
* @var array
*/
private static $cache = [];
/**
* @var Text_Template[]
*/
private static $templates = [];
/**
* @var array
*/
private $blacklistedMethodNames = [
'__CLASS__' => true,
'__DIR__' => true,
'__FILE__' => true,
'__FUNCTION__' => true,
'__LINE__' => true,
'__METHOD__' => true,
'__NAMESPACE__' => true,
'__TRAIT__' => true,
'__clone' => true,
'__halt_compiler' => true,
];
/**
* Returns a mock object for the specified class.
*
* @param string|string[] $type
* @param array $methods
* @param array $arguments
* @param string $mockClassName
* @param bool $callOriginalConstructor
* @param bool $callOriginalClone
* @param bool $callAutoload
* @param bool $cloneArguments
* @param bool $callOriginalMethods
* @param object $proxyTarget
* @param bool $allowMockingUnknownTypes
*
* @throws Exception
* @throws RuntimeException
* @throws \PHPUnit\Framework\Exception
* @throws \ReflectionException
*
* @return MockObject
*/
public function getMock($type, $methods = [], array $arguments = [], $mockClassName = '', $callOriginalConstructor = true, $callOriginalClone = true, $callAutoload = true, $cloneArguments = true, $callOriginalMethods = false, $proxyTarget = null, $allowMockingUnknownTypes = true)
{
if (!\is_array($type) && !\is_string($type)) {
throw InvalidArgumentHelper::factory(1, 'array or string');
}
if (!\is_string($mockClassName)) {
throw InvalidArgumentHelper::factory(4, 'string');
}
if (!\is_array($methods) && null !== $methods) {
throw InvalidArgumentHelper::factory(2, 'array', $methods);
}
if ($type === 'Traversable' || $type === '\\Traversable') {
$type = 'Iterator';
}
if (\is_array($type)) {
$type = \array_unique(
\array_map(
function ($type) {
if ($type === 'Traversable' ||
$type === '\\Traversable' ||
$type === '\\Iterator') {
return 'Iterator';
}
return $type;
},
$type
)
);
}
if (!$allowMockingUnknownTypes) {
if (\is_array($type)) {
foreach ($type as $_type) {
if (!\class_exists($_type, $callAutoload) &&
!\interface_exists($_type, $callAutoload)) {
throw new RuntimeException(
\sprintf(
'Cannot stub or mock class or interface "%s" which does not exist',
$_type
)
);
}
}
} else {
if (!\class_exists($type, $callAutoload) &&
!\interface_exists($type, $callAutoload)
) {
throw new RuntimeException(
\sprintf(
'Cannot stub or mock class or interface "%s" which does not exist',
$type
)
);
}
}
}
if (null !== $methods) {
foreach ($methods as $method) {
if (!\preg_match('~[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*~', $method)) {
throw new RuntimeException(
\sprintf(
'Cannot stub or mock method with invalid name "%s"',
$method
)
);
}
}
if ($methods !== \array_unique($methods)) {
throw new RuntimeException(
\sprintf(
'Cannot stub or mock using a method list that contains duplicates: "%s" (duplicate: "%s")',
\implode(', ', $methods),
\implode(', ', \array_unique(\array_diff_assoc($methods, \array_unique($methods))))
)
);
}
}
if ($mockClassName !== '' && \class_exists($mockClassName, false)) {
$reflect = new ReflectionClass($mockClassName);
if (!$reflect->implementsInterface(MockObject::class)) {
throw new RuntimeException(
\sprintf(
'Class "%s" already exists.',
$mockClassName
)
);
}
}
if ($callOriginalConstructor === false && $callOriginalMethods === true) {
throw new RuntimeException(
'Proxying to original methods requires invoking the original constructor'
);
}
$mock = $this->generate(
$type,
$methods,
$mockClassName,
$callOriginalClone,
$callAutoload,
$cloneArguments,
$callOriginalMethods
);
return $this->getObject(
$mock['code'],
$mock['mockClassName'],
$type,
$callOriginalConstructor,
$callAutoload,
$arguments,
$callOriginalMethods,
$proxyTarget
);
}
/**
* Returns a mock object for the specified abstract class with all abstract
* methods of the class mocked. Concrete methods to mock can be specified with
* the last parameter
*
* @param string $originalClassName
* @param array $arguments
* @param string $mockClassName
* @param bool $callOriginalConstructor
* @param bool $callOriginalClone
* @param bool $callAutoload
* @param array $mockedMethods
* @param bool $cloneArguments
*
* @throws \ReflectionException
* @throws RuntimeException
* @throws Exception
*
* @return MockObject
*/
public function getMockForAbstractClass($originalClassName, array $arguments = [], $mockClassName = '', $callOriginalConstructor = true, $callOriginalClone = true, $callAutoload = true, $mockedMethods = [], $cloneArguments = true)
{
if (!\is_string($originalClassName)) {
throw InvalidArgumentHelper::factory(1, 'string');
}
if (!\is_string($mockClassName)) {
throw InvalidArgumentHelper::factory(3, 'string');
}
if (\class_exists($originalClassName, $callAutoload) ||
\interface_exists($originalClassName, $callAutoload)) {
$reflector = new ReflectionClass($originalClassName);
$methods = $mockedMethods;
foreach ($reflector->getMethods() as $method) {
if ($method->isAbstract() && !\in_array($method->getName(), $methods)) {
$methods[] = $method->getName();
}
}
if (empty($methods)) {
$methods = null;
}
return $this->getMock(
$originalClassName,
$methods,
$arguments,
$mockClassName,
$callOriginalConstructor,
$callOriginalClone,
$callAutoload,
$cloneArguments
);
}
throw new RuntimeException(
\sprintf('Class "%s" does not exist.', $originalClassName)
);
}
/**
* Returns a mock object for the specified trait with all abstract methods
* of the trait mocked. Concrete methods to mock can be specified with the
* `$mockedMethods` parameter.
*
* @param string $traitName
* @param array $arguments
* @param string $mockClassName
* @param bool $callOriginalConstructor
* @param bool $callOriginalClone
* @param bool $callAutoload
* @param array $mockedMethods
* @param bool $cloneArguments
*
* @throws \ReflectionException
* @throws RuntimeException
* @throws Exception
*
* @return MockObject
*/
public function getMockForTrait($traitName, array $arguments = [], $mockClassName = '', $callOriginalConstructor = true, $callOriginalClone = true, $callAutoload = true, $mockedMethods = [], $cloneArguments = true)
{
if (!\is_string($traitName)) {
throw InvalidArgumentHelper::factory(1, 'string');
}
if (!\is_string($mockClassName)) {
throw InvalidArgumentHelper::factory(3, 'string');
}
if (!\trait_exists($traitName, $callAutoload)) {
throw new RuntimeException(
\sprintf(
'Trait "%s" does not exist.',
$traitName
)
);
}
$className = $this->generateClassName(
$traitName,
'',
'Trait_'
);
$classTemplate = $this->getTemplate('trait_class.tpl');
$classTemplate->setVar(
[
'prologue' => 'abstract ',
'class_name' => $className['className'],
'trait_name' => $traitName
]
);
$this->evalClass(
$classTemplate->render(),
$className['className']
);
return $this->getMockForAbstractClass($className['className'], $arguments, $mockClassName, $callOriginalConstructor, $callOriginalClone, $callAutoload, $mockedMethods, $cloneArguments);
}
/**
* Returns an object for the specified trait.
*
* @param string $traitName
* @param array $arguments
* @param string $traitClassName
* @param bool $callOriginalConstructor
* @param bool $callOriginalClone
* @param bool $callAutoload
*
* @throws \ReflectionException
* @throws RuntimeException
* @throws Exception
*
* @return object
*/
public function getObjectForTrait($traitName, array $arguments = [], $traitClassName = '', $callOriginalConstructor = true, $callOriginalClone = true, $callAutoload = true)
{
if (!\is_string($traitName)) {
throw InvalidArgumentHelper::factory(1, 'string');
}
if (!\is_string($traitClassName)) {
throw InvalidArgumentHelper::factory(3, 'string');
}
if (!\trait_exists($traitName, $callAutoload)) {
throw new RuntimeException(
\sprintf(
'Trait "%s" does not exist.',
$traitName
)
);
}
$className = $this->generateClassName(
$traitName,
$traitClassName,
'Trait_'
);
$classTemplate = $this->getTemplate('trait_class.tpl');
$classTemplate->setVar(
[
'prologue' => '',
'class_name' => $className['className'],
'trait_name' => $traitName
]
);
return $this->getObject($classTemplate->render(), $className['className']);
}
/**
* @param array|string $type
* @param array $methods
* @param string $mockClassName
* @param bool $callOriginalClone
* @param bool $callAutoload
* @param bool $cloneArguments
* @param bool $callOriginalMethods
*
* @throws \ReflectionException
* @throws \PHPUnit\Framework\MockObject\RuntimeException
*
* @return array
*/
public function generate($type, array $methods = null, $mockClassName = '', $callOriginalClone = true, $callAutoload = true, $cloneArguments = true, $callOriginalMethods = false)
{
if (\is_array($type)) {
\sort($type);
}
if ($mockClassName === '') {
$key = \md5(
\is_array($type) ? \implode('_', $type) : $type .
\serialize($methods) .
\serialize($callOriginalClone) .
\serialize($cloneArguments) .
\serialize($callOriginalMethods)
);
if (isset(self::$cache[$key])) {
return self::$cache[$key];
}
}
$mock = $this->generateMock(
$type,
$methods,
$mockClassName,
$callOriginalClone,
$callAutoload,
$cloneArguments,
$callOriginalMethods
);
if (isset($key)) {
self::$cache[$key] = $mock;
}
return $mock;
}
/**
* @param string $wsdlFile
* @param string $className
* @param array $methods
* @param array $options
*
* @throws RuntimeException
*
* @return string
*/
public function generateClassFromWsdl($wsdlFile, $className, array $methods = [], array $options = [])
{
if (!\extension_loaded('soap')) {
throw new RuntimeException(
'The SOAP extension is required to generate a mock object from WSDL.'
);
}
$options = \array_merge($options, ['cache_wsdl' => WSDL_CACHE_NONE]);
$client = new SoapClient($wsdlFile, $options);
$_methods = \array_unique($client->__getFunctions());
unset($client);
\sort($_methods);
$methodTemplate = $this->getTemplate('wsdl_method.tpl');
$methodsBuffer = '';
foreach ($_methods as $method) {
$nameStart = \strpos($method, ' ') + 1;
$nameEnd = \strpos($method, '(');
$name = \substr($method, $nameStart, $nameEnd - $nameStart);
if (empty($methods) || \in_array($name, $methods)) {
$args = \explode(
',',
\substr(
$method,
$nameEnd + 1,
\strpos($method, ')') - $nameEnd - 1
)
);
foreach (\range(0, \count($args) - 1) as $i) {
$args[$i] = \substr($args[$i], \strpos($args[$i], '$'));
}
$methodTemplate->setVar(
[
'method_name' => $name,
'arguments' => \implode(', ', $args)
]
);
$methodsBuffer .= $methodTemplate->render();
}
}
$optionsBuffer = 'array(';
foreach ($options as $key => $value) {
$optionsBuffer .= $key . ' => ' . $value;
}
$optionsBuffer .= ')';
$classTemplate = $this->getTemplate('wsdl_class.tpl');
$namespace = '';
if (\strpos($className, '\\') !== false) {
$parts = \explode('\\', $className);
$className = \array_pop($parts);
$namespace = 'namespace ' . \implode('\\', $parts) . ';' . "\n\n";
}
$classTemplate->setVar(
[
'namespace' => $namespace,
'class_name' => $className,
'wsdl' => $wsdlFile,
'options' => $optionsBuffer,
'methods' => $methodsBuffer
]
);
return $classTemplate->render();
}
/**
* @param string $className
*
* @throws \ReflectionException
*
* @return array
*/
public function getClassMethods($className)
{
$class = new ReflectionClass($className);
$methods = [];
foreach ($class->getMethods() as $method) {
if ($method->isPublic() || $method->isAbstract()) {
$methods[] = $method->getName();
}
}
return $methods;
}
/**
* @param string $code
* @param string $className
* @param array|string $type
* @param bool $callOriginalConstructor
* @param bool $callAutoload
* @param array $arguments
* @param bool $callOriginalMethods
* @param object $proxyTarget
*
* @throws \ReflectionException
* @throws RuntimeException
*
* @return MockObject
*/
private function getObject($code, $className, $type = '', $callOriginalConstructor = false, $callAutoload = false, array $arguments = [], $callOriginalMethods = false, $proxyTarget = null)
{
$this->evalClass($code, $className);
if ($callOriginalConstructor &&
\is_string($type) &&
!\interface_exists($type, $callAutoload)) {
if (\count($arguments) === 0) {
$object = new $className;
} else {
$class = new ReflectionClass($className);
$object = $class->newInstanceArgs($arguments);
}
} else {
try {
$instantiator = new Instantiator;
$object = $instantiator->instantiate($className);
} catch (InstantiatorException $exception) {
throw new RuntimeException($exception->getMessage());
}
}
if ($callOriginalMethods) {
if (!\is_object($proxyTarget)) {
if (\count($arguments) === 0) {
$proxyTarget = new $type;
} else {
$class = new ReflectionClass($type);
$proxyTarget = $class->newInstanceArgs($arguments);
}
}
$object->__phpunit_setOriginalObject($proxyTarget);
}
return $object;
}
/**
* @param string $code
* @param string $className
*/
private function evalClass($code, $className)
{
if (!\class_exists($className, false)) {
eval($code);
}
}
/**
* @param array|string $type
* @param null|array $methods
* @param string $mockClassName
* @param bool $callOriginalClone
* @param bool $callAutoload
* @param bool $cloneArguments
* @param bool $callOriginalMethods
*
* @throws \InvalidArgumentException
* @throws \ReflectionException
* @throws RuntimeException
*
* @return array
*/
private function generateMock($type, $methods, $mockClassName, $callOriginalClone, $callAutoload, $cloneArguments, $callOriginalMethods)
{
$methodReflections = [];
$classTemplate = $this->getTemplate('mocked_class.tpl');
$additionalInterfaces = [];
$cloneTemplate = '';
$isClass = false;
$isInterface = false;
$isMultipleInterfaces = false;
if (\is_array($type)) {
foreach ($type as $_type) {
if (!\interface_exists($_type, $callAutoload)) {
throw new RuntimeException(
\sprintf(
'Interface "%s" does not exist.',
$_type
)
);
}
$isMultipleInterfaces = true;
$additionalInterfaces[] = $_type;
$typeClass = new ReflectionClass(
$this->generateClassName(
$_type,
$mockClassName,
'Mock_'
)['fullClassName']
);
foreach ($this->getClassMethods($_type) as $method) {
if (\in_array($method, $methods)) {
throw new RuntimeException(
\sprintf(
'Duplicate method "%s" not allowed.',
$method
)
);
}
$methodReflections[$method] = $typeClass->getMethod($method);
$methods[] = $method;
}
}
}
$mockClassName = $this->generateClassName(
$type,
$mockClassName,
'Mock_'
);
if (\class_exists($mockClassName['fullClassName'], $callAutoload)) {
$isClass = true;
} elseif (\interface_exists($mockClassName['fullClassName'], $callAutoload)) {
$isInterface = true;
}
if (!$isClass && !$isInterface) {
$prologue = 'class ' . $mockClassName['originalClassName'] . "\n{\n}\n\n";
if (!empty($mockClassName['namespaceName'])) {
$prologue = 'namespace ' . $mockClassName['namespaceName'] .
" {\n\n" . $prologue . "}\n\n" .
"namespace {\n\n";
$epilogue = "\n\n}";
}
$cloneTemplate = $this->getTemplate('mocked_clone.tpl');
} else {
$class = new ReflectionClass($mockClassName['fullClassName']);
if ($class->isFinal()) {
throw new RuntimeException(
\sprintf(
'Class "%s" is declared "final" and cannot be mocked.',
$mockClassName['fullClassName']
)
);
}
if ($class->hasMethod('__clone')) {
$cloneMethod = $class->getMethod('__clone');
if (!$cloneMethod->isFinal()) {
if ($callOriginalClone && !$isInterface) {
$cloneTemplate = $this->getTemplate('unmocked_clone.tpl');
} else {
$cloneTemplate = $this->getTemplate('mocked_clone.tpl');
}
}
} else {
$cloneTemplate = $this->getTemplate('mocked_clone.tpl');
}
}
if (\is_object($cloneTemplate)) {
$cloneTemplate = $cloneTemplate->render();
}
if (\is_array($methods) && empty($methods) &&
($isClass || $isInterface)) {
$methods = $this->getClassMethods($mockClassName['fullClassName']);
}
if (!\is_array($methods)) {
$methods = [];
}
$mockedMethods = '';
$configurable = [];
foreach ($methods as $methodName) {
if ($methodName !== '__construct' && $methodName !== '__clone') {
$configurable[] = \strtolower($methodName);
}
}
if (isset($class)) {
// https://github.com/sebastianbergmann/phpunit-mock-objects/issues/103
if ($isInterface && $class->implementsInterface(Traversable::class) &&
!$class->implementsInterface(Iterator::class) &&
!$class->implementsInterface(IteratorAggregate::class)) {
$additionalInterfaces[] = Iterator::class;
$methods = \array_merge($methods, $this->getClassMethods(Iterator::class));
}
foreach ($methods as $methodName) {
try {
$method = $class->getMethod($methodName);
if ($this->canMockMethod($method)) {
$mockedMethods .= $this->generateMockedMethodDefinitionFromExisting(
$method,
$cloneArguments,
$callOriginalMethods
);
}
} catch (ReflectionException $e) {
$mockedMethods .= $this->generateMockedMethodDefinition(
$mockClassName['fullClassName'],
$methodName,
$cloneArguments
);
}
}
} elseif ($isMultipleInterfaces) {
foreach ($methods as $methodName) {
if ($this->canMockMethod($methodReflections[$methodName])) {
$mockedMethods .= $this->generateMockedMethodDefinitionFromExisting(
$methodReflections[$methodName],
$cloneArguments,
$callOriginalMethods
);
}
}
} else {
foreach ($methods as $methodName) {
$mockedMethods .= $this->generateMockedMethodDefinition(
$mockClassName['fullClassName'],
$methodName,
$cloneArguments
);
}
}
$method = '';
if (!\in_array('method', $methods) && (!isset($class) || !$class->hasMethod('method'))) {
$methodTemplate = $this->getTemplate('mocked_class_method.tpl');
$method = $methodTemplate->render();
}
$classTemplate->setVar(
[
'prologue' => $prologue ?? '',
'epilogue' => $epilogue ?? '',
'class_declaration' => $this->generateMockClassDeclaration(
$mockClassName,
$isInterface,
$additionalInterfaces
),
'clone' => $cloneTemplate,
'mock_class_name' => $mockClassName['className'],
'mocked_methods' => $mockedMethods,
'method' => $method,
'configurable' => '[' . \implode(', ', \array_map(function ($m) {
return '\'' . $m . '\'';
}, $configurable)) . ']'
]
);
return [
'code' => $classTemplate->render(),
'mockClassName' => $mockClassName['className']
];
}
/**
* @param array|string $type
* @param string $className
* @param string $prefix
*
* @return array
*/
private function generateClassName($type, $className, $prefix)
{
if (\is_array($type)) {
$type = \implode('_', $type);
}
if ($type[0] === '\\') {
$type = \substr($type, 1);
}
$classNameParts = \explode('\\', $type);
if (\count($classNameParts) > 1) {
$type = \array_pop($classNameParts);
$namespaceName = \implode('\\', $classNameParts);
$fullClassName = $namespaceName . '\\' . $type;
} else {
$namespaceName = '';
$fullClassName = $type;
}
if ($className === '') {
do {
$className = $prefix . $type . '_' .
\substr(\md5(\mt_rand()), 0, 8);
} while (\class_exists($className, false));
}
return [
'className' => $className,
'originalClassName' => $type,
'fullClassName' => $fullClassName,
'namespaceName' => $namespaceName
];
}
/**
* @param array $mockClassName
* @param bool $isInterface
* @param array $additionalInterfaces
*
* @return string
*/
private function generateMockClassDeclaration(array $mockClassName, $isInterface, array $additionalInterfaces = [])
{
$buffer = 'class ';
$additionalInterfaces[] = MockObject::class;
$interfaces = \implode(', ', $additionalInterfaces);
if ($isInterface) {
$buffer .= \sprintf(
'%s implements %s',
$mockClassName['className'],
$interfaces
);
if (!\in_array($mockClassName['originalClassName'], $additionalInterfaces)) {
$buffer .= ', ';
if (!empty($mockClassName['namespaceName'])) {
$buffer .= $mockClassName['namespaceName'] . '\\';
}
$buffer .= $mockClassName['originalClassName'];
}
} else {
$buffer .= \sprintf(
'%s extends %s%s implements %s',
$mockClassName['className'],
!empty($mockClassName['namespaceName']) ? $mockClassName['namespaceName'] . '\\' : '',
$mockClassName['originalClassName'],
$interfaces
);
}
return $buffer;
}
/**
* @param ReflectionMethod $method
* @param bool $cloneArguments
* @param bool $callOriginalMethods
*
* @throws \PHPUnit\Framework\MockObject\RuntimeException
*
* @return string
*/
private function generateMockedMethodDefinitionFromExisting(ReflectionMethod $method, $cloneArguments, $callOriginalMethods)
{
if ($method->isPrivate()) {
$modifier = 'private';
} elseif ($method->isProtected()) {
$modifier = 'protected';
} else {
$modifier = 'public';
}
if ($method->isStatic()) {
$modifier .= ' static';
}
if ($method->returnsReference()) {
$reference = '&';
} else {
$reference = '';
}
if ($method->hasReturnType()) {
$returnType = (string) $method->getReturnType();
} else {
$returnType = '';
}
if (\preg_match('#\*[ \t]*+@deprecated[ \t]*+(.*?)\r?+\n[ \t]*+\*(?:[ \t]*+@|/$)#s', $method->getDocComment(), $deprecation)) {
$deprecation = \trim(\preg_replace('#[ \t]*\r?\n[ \t]*+\*[ \t]*+#', ' ', $deprecation[1]));
} else {
$deprecation = false;
}
return $this->generateMockedMethodDefinition(
$method->getDeclaringClass()->getName(),
$method->getName(),
$cloneArguments,
$modifier,
$this->getMethodParameters($method),
$this->getMethodParameters($method, true),
$returnType,
$reference,
$callOriginalMethods,
$method->isStatic(),
$deprecation,
$method->hasReturnType() && $method->getReturnType()->allowsNull()
);
}
/**
* @param string $className
* @param string $methodName
* @param bool $cloneArguments
* @param string $modifier
* @param string $argumentsForDeclaration
* @param string $argumentsForCall
* @param string $returnType
* @param string $reference
* @param bool $callOriginalMethods
* @param bool $static
* @param bool|string $deprecation
* @param bool $allowsReturnNull
*
* @throws \ReflectionException
* @throws \PHPUnit\Framework\MockObject\RuntimeException
* @throws \InvalidArgumentException
*
* @return string
*/
private function generateMockedMethodDefinition($className, $methodName, $cloneArguments = true, $modifier = 'public', $argumentsForDeclaration = '', $argumentsForCall = '', $returnType = '', $reference = '', $callOriginalMethods = false, $static = false, $deprecation = false, $allowsReturnNull = false)
{
if ($static) {
$templateFile = 'mocked_static_method.tpl';
} else {
if ($returnType === 'void') {
$templateFile = \sprintf(
'%s_method_void.tpl',
$callOriginalMethods ? 'proxied' : 'mocked'
);
} else {
$templateFile = \sprintf(
'%s_method.tpl',
$callOriginalMethods ? 'proxied' : 'mocked'
);
}
}
// @see https://bugs.php.net/bug.php?id=70722
if ($returnType === 'self') {
$returnType = $className;
}
// @see https://github.com/sebastianbergmann/phpunit-mock-objects/issues/406
if ($returnType === 'parent') {
$reflector = new ReflectionClass($className);
$parentClass = $reflector->getParentClass();
if ($parentClass === null) {
throw new RuntimeException(
\sprintf(
'Cannot mock %s::%s because "parent" return type declaration is used but %s does not have a parent class',
$className,
$methodName,
$className
)
);
}
$returnType = $parentClass->getName();
}
if (false !== $deprecation) {
$deprecation = "The $className::$methodName method is deprecated ($deprecation).";
$deprecationTemplate = $this->getTemplate('deprecation.tpl');
$deprecationTemplate->setVar(
[
'deprecation' => \var_export($deprecation, true),
]
);
$deprecation = $deprecationTemplate->render();
}
$template = $this->getTemplate($templateFile);
$template->setVar(
[
'arguments_decl' => $argumentsForDeclaration,
'arguments_call' => $argumentsForCall,
'return_delim' => $returnType ? ': ' : '',
'return_type' => $allowsReturnNull ? '?' . $returnType : $returnType,
'arguments_count' => !empty($argumentsForCall) ? \substr_count($argumentsForCall, ',') + 1 : 0,
'class_name' => $className,
'method_name' => $methodName,
'modifier' => $modifier,
'reference' => $reference,
'clone_arguments' => $cloneArguments ? 'true' : 'false',
'deprecation' => $deprecation
]
);
return $template->render();
}
/**
* @param ReflectionMethod $method
*
* @throws \ReflectionException
*
* @return bool
*/
private function canMockMethod(ReflectionMethod $method)
{
return !($method->isConstructor() || $method->isFinal() || $method->isPrivate() || $this->isMethodNameBlacklisted($method->getName()));
}
/**
* Returns whether a method name is blacklisted
*
* @param string $name
*
* @return bool
*/
private function isMethodNameBlacklisted($name)
{
return isset($this->blacklistedMethodNames[$name]);
}
/**
* Returns the parameters of a function or method.
*
* @param ReflectionMethod $method
* @param bool $forCall
*
* @throws RuntimeException
*
* @return string
*/
private function getMethodParameters(ReflectionMethod $method, $forCall = false)
{
$parameters = [];
foreach ($method->getParameters() as $i => $parameter) {
$name = '$' . $parameter->getName();
/* Note: PHP extensions may use empty names for reference arguments
* or "..." for methods taking a variable number of arguments.
*/
if ($name === '$' || $name === '$...') {
$name = '$arg' . $i;
}
if ($parameter->isVariadic()) {
if ($forCall) {
continue;
}
$name = '...' . $name;
}
$nullable = '';
$default = '';
$reference = '';
$typeDeclaration = '';
if (!$forCall) {
if ($parameter->hasType() && $parameter->allowsNull()) {
$nullable = '?';
}
if ($parameter->hasType() && (string) $parameter->getType() !== 'self') {
$typeDeclaration = (string) $parameter->getType() . ' ';
} elseif ($parameter->isArray()) {
$typeDeclaration = 'array ';
} elseif ($parameter->isCallable()) {
$typeDeclaration = 'callable ';
} else {
try {
$class = $parameter->getClass();
} catch (ReflectionException $e) {
throw new RuntimeException(
\sprintf(
'Cannot mock %s::%s() because a class or ' .
'interface used in the signature is not loaded',
$method->getDeclaringClass()->getName(),
$method->getName()
),
0,
$e
);
}
if ($class !== null) {
$typeDeclaration = $class->getName() . ' ';
}
}
if (!$parameter->isVariadic()) {
if ($parameter->isDefaultValueAvailable()) {
$value = $parameter->getDefaultValue();
$default = ' = ' . \var_export($value, true);
} elseif ($parameter->isOptional()) {
$default = ' = null';
}
}
}
if ($parameter->isPassedByReference()) {
$reference = '&';
}
$parameters[] = $nullable . $typeDeclaration . $reference . $name . $default;
}
return \implode(', ', $parameters);
}
/**
* @param string $template
*
* @throws \InvalidArgumentException
*
* @return Text_Template
*/
private function getTemplate($template)
{
$filename = __DIR__ . DIRECTORY_SEPARATOR . 'Generator' . DIRECTORY_SEPARATOR . $template;
if (!isset(self::$templates[$filename])) {
self::$templates[$filename] = new Text_Template($filename);
}
return self::$templates[$filename];
}
}
PK `TLʍp p " src/Exception/RuntimeException.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject;
class RuntimeException extends \RuntimeException implements Exception
{
}
PK `TLKٴ| | ( src/Exception/BadMethodCallException.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject;
class BadMethodCallException extends \BadMethodCallException implements Exception
{
}
PK `TLP~ ~ src/Exception/Exception.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject;
/**
* Interface for exceptions used by PHPUnit_MockObject.
*/
interface Exception
{
}
PK `TL src/Invocation/Invocation.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject;
/**
* Interface for invocations.
*/
interface Invocation
{
/**
* @return mixed mocked return value
*/
public function generateReturnValue();
public function getClassName(): string;
public function getMethodName(): string;
public function getParameters(): array;
public function getReturnType(): string;
public function isReturnTypeNullable(): bool;
}
PK `TL9$y y # src/Invocation/StaticInvocation.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Invocation;
use PHPUnit\Framework\MockObject\Generator;
use PHPUnit\Framework\MockObject\Invocation;
use PHPUnit\Framework\SelfDescribing;
use ReflectionObject;
use SebastianBergmann\Exporter\Exporter;
/**
* Represents a static invocation.
*/
class StaticInvocation implements Invocation, SelfDescribing
{
/**
* @var array
*/
private static $uncloneableExtensions = [
'mysqli' => true,
'SQLite' => true,
'sqlite3' => true,
'tidy' => true,
'xmlwriter' => true,
'xsl' => true
];
/**
* @var array
*/
private static $uncloneableClasses = [
'Closure',
'COMPersistHelper',
'IteratorIterator',
'RecursiveIteratorIterator',
'SplFileObject',
'PDORow',
'ZipArchive'
];
/**
* @var string
*/
private $className;
/**
* @var string
*/
private $methodName;
/**
* @var array
*/
private $parameters;
/**
* @var string
*/
private $returnType;
/**
* @var bool
*/
private $isReturnTypeNullable = false;
/**
* @param string $className
* @param string $methodName
* @param array $parameters
* @param string $returnType
* @param bool $cloneObjects
*/
public function __construct($className, $methodName, array $parameters, $returnType, $cloneObjects = false)
{
$this->className = $className;
$this->methodName = $methodName;
$this->parameters = $parameters;
if (\strtolower($methodName) === '__tostring') {
$returnType = 'string';
}
if (\strpos($returnType, '?') === 0) {
$returnType = \substr($returnType, 1);
$this->isReturnTypeNullable = true;
}
$this->returnType = $returnType;
if (!$cloneObjects) {
return;
}
foreach ($this->parameters as $key => $value) {
if (\is_object($value)) {
$this->parameters[$key] = $this->cloneObject($value);
}
}
}
public function getClassName(): string
{
return $this->className;
}
public function getMethodName(): string
{
return $this->methodName;
}
public function getParameters(): array
{
return $this->parameters;
}
public function getReturnType(): string
{
return $this->returnType;
}
public function isReturnTypeNullable(): bool
{
return $this->isReturnTypeNullable;
}
/**
* @throws \ReflectionException
* @throws \PHPUnit\Framework\MockObject\RuntimeException
* @throws \PHPUnit\Framework\Exception
*
* @return mixed Mocked return value
*/
public function generateReturnValue()
{
if ($this->isReturnTypeNullable) {
return;
}
switch (\strtolower($this->returnType)) {
case '':
case 'void':
return;
case 'string':
return '';
case 'float':
return 0.0;
case 'int':
return 0;
case 'bool':
return false;
case 'array':
return [];
case 'object':
return new \stdClass;
case 'callable':
case 'closure':
return function () {
};
case 'traversable':
case 'generator':
case 'iterable':
$generator = function () {
yield;
};
return $generator();
default:
$generator = new Generator;
return $generator->getMock($this->returnType, [], [], '', false);
}
}
public function toString(): string
{
$exporter = new Exporter;
return \sprintf(
'%s::%s(%s)%s',
$this->className,
$this->methodName,
\implode(
', ',
\array_map(
[$exporter, 'shortenedExport'],
$this->parameters
)
),
$this->returnType ? \sprintf(': %s', $this->returnType) : ''
);
}
/**
* @param object $original
*
* @return object
*/
private function cloneObject($original)
{
$cloneable = null;
$object = new ReflectionObject($original);
// Check the blacklist before asking PHP reflection to work around
// https://bugs.php.net/bug.php?id=53967
if ($object->isInternal() &&
isset(self::$uncloneableExtensions[$object->getExtensionName()])) {
$cloneable = false;
}
if ($cloneable === null) {
foreach (self::$uncloneableClasses as $class) {
if ($original instanceof $class) {
$cloneable = false;
break;
}
}
}
if ($cloneable === null) {
$cloneable = $object->isCloneable();
}
if ($cloneable === null && $object->hasMethod('__clone')) {
$method = $object->getMethod('__clone');
$cloneable = $method->isPublic();
}
if ($cloneable === null) {
$cloneable = true;
}
if ($cloneable) {
try {
return clone $original;
} catch (\Exception $e) {
return $original;
}
} else {
return $original;
}
}
}
PK `TL~ # src/Invocation/ObjectInvocation.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Invocation;
/**
* Represents a non-static invocation.
*/
class ObjectInvocation extends StaticInvocation
{
/**
* @var object
*/
private $object;
/**
* @param string $className
* @param string $methodName
* @param array $parameters
* @param string $returnType
* @param object $object
* @param bool $cloneObjects
*/
public function __construct($className, $methodName, array $parameters, $returnType, $object, $cloneObjects = false)
{
parent::__construct($className, $methodName, $parameters, $returnType, $cloneObjects);
$this->object = $object;
}
public function getObject()
{
return $this->object;
}
}
PK `TLJ src/Invokable.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject;
/**
* Interface for classes which can be invoked.
*
* The invocation will be taken from a mock object and passed to an object
* of this class.
*/
interface Invokable extends Verifiable
{
/**
* Invokes the invocation object $invocation so that it can be checked for
* expectations or matched against stubs.
*
* @param Invocation $invocation The invocation object passed from mock object
*
* @return object
*/
public function invoke(Invocation $invocation);
/**
* Checks if the invocation matches.
*
* @param Invocation $invocation The invocation object passed from mock object
*
* @return bool
*/
public function matches(Invocation $invocation);
}
PK `TL1 src/InvocationMocker.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject;
use Exception;
use PHPUnit\Framework\MockObject\Builder\InvocationMocker as BuilderInvocationMocker;
use PHPUnit\Framework\MockObject\Builder\Match;
use PHPUnit\Framework\MockObject\Builder\NamespaceMatch;
use PHPUnit\Framework\MockObject\Matcher\Invocation as MatcherInvocation;
use PHPUnit\Framework\MockObject\Stub\MatcherCollection;
/**
* Mocker for invocations which are sent from
* MockObject objects.
*
* Keeps track of all expectations and stubs as well as registering
* identifications for builders.
*/
class InvocationMocker implements MatcherCollection, Invokable, NamespaceMatch
{
/**
* @var MatcherInvocation[]
*/
private $matchers = [];
/**
* @var Match[]
*/
private $builderMap = [];
/**
* @var string[]
*/
private $configurableMethods = [];
/**
* @param array $configurableMethods
*/
public function __construct(array $configurableMethods)
{
$this->configurableMethods = $configurableMethods;
}
/**
* @param MatcherInvocation $matcher
*/
public function addMatcher(MatcherInvocation $matcher)
{
$this->matchers[] = $matcher;
}
public function hasMatchers()
{
foreach ($this->matchers as $matcher) {
if ($matcher->hasMatchers()) {
return true;
}
}
return false;
}
/**
* @param mixed $id
*
* @return null|bool
*/
public function lookupId($id)
{
if (isset($this->builderMap[$id])) {
return $this->builderMap[$id];
}
return;
}
/**
* @param mixed $id
* @param Match $builder
*
* @throws RuntimeException
*/
public function registerId($id, Match $builder)
{
if (isset($this->builderMap[$id])) {
throw new RuntimeException(
'Match builder with id <' . $id . '> is already registered.'
);
}
$this->builderMap[$id] = $builder;
}
/**
* @param MatcherInvocation $matcher
*
* @return BuilderInvocationMocker
*/
public function expects(MatcherInvocation $matcher)
{
return new BuilderInvocationMocker(
$this,
$matcher,
$this->configurableMethods
);
}
/**
* @param Invocation $invocation
*
* @throws Exception
*
* @return mixed
*/
public function invoke(Invocation $invocation)
{
$exception = null;
$hasReturnValue = false;
$returnValue = null;
foreach ($this->matchers as $match) {
try {
if ($match->matches($invocation)) {
$value = $match->invoked($invocation);
if (!$hasReturnValue) {
$returnValue = $value;
$hasReturnValue = true;
}
}
} catch (Exception $e) {
$exception = $e;
}
}
if ($exception !== null) {
throw $exception;
}
if ($hasReturnValue) {
return $returnValue;
}
return $invocation->generateReturnValue();
}
/**
* @param Invocation $invocation
*
* @return bool
*/
public function matches(Invocation $invocation)
{
foreach ($this->matchers as $matcher) {
if (!$matcher->matches($invocation)) {
return false;
}
}
return true;
}
/**
* @throws \PHPUnit\Framework\ExpectationFailedException
*
* @return bool
*/
public function verify()
{
foreach ($this->matchers as $matcher) {
$matcher->verify();
}
}
}
PK `TL\Gƫ src/Verifiable.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject;
use PHPUnit\Framework\ExpectationFailedException;
/**
* Interface for classes which must verify a given expectation.
*/
interface Verifiable
{
/**
* Verifies that the current expectation is valid. If everything is OK the
* code should just return, if not it must throw an exception.
*
* @throws ExpectationFailedException
*/
public function verify();
}
PK `TLx " src/Matcher/InvokedAtLeastOnce.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Matcher;
use PHPUnit\Framework\ExpectationFailedException;
/**
* Invocation matcher which checks if a method has been invoked at least one
* time.
*
* If the number of invocations is 0 it will throw an exception in verify.
*/
class InvokedAtLeastOnce extends InvokedRecorder
{
/**
* @return string
*/
public function toString(): string
{
return 'invoked at least once';
}
/**
* Verifies that the current expectation is valid. If everything is OK the
* code should just return, if not it must throw an exception.
*
* @throws ExpectationFailedException
*/
public function verify()
{
$count = $this->getInvocationCount();
if ($count < 1) {
throw new ExpectationFailedException(
'Expected invocation at least once but it never occurred.'
);
}
}
}
PK `TL(W W src/Matcher/MethodName.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Matcher;
use PHPUnit\Framework\Constraint\Constraint;
use PHPUnit\Framework\Constraint\IsEqual;
use PHPUnit\Framework\MockObject\Invocation as BaseInvocation;
use PHPUnit\Util\InvalidArgumentHelper;
/**
* Invocation matcher which looks for a specific method name in the invocations.
*
* Checks the method name all incoming invocations, the name is checked against
* the defined constraint $constraint. If the constraint is met it will return
* true in matches().
*/
class MethodName extends StatelessInvocation
{
/**
* @var Constraint
*/
private $constraint;
/**
* @param Constraint|string
* @param mixed $constraint
*
* @throws Constraint
* @throws \PHPUnit\Framework\Exception
*/
public function __construct($constraint)
{
if (!$constraint instanceof Constraint) {
if (!\is_string($constraint)) {
throw InvalidArgumentHelper::factory(1, 'string');
}
$constraint = new IsEqual(
$constraint,
0,
10,
false,
true
);
}
$this->constraint = $constraint;
}
/**
* @return string
*/
public function toString(): string
{
return 'method name ' . $this->constraint->toString();
}
/**
* @param BaseInvocation $invocation
*
* @return bool
*/
public function matches(BaseInvocation $invocation)
{
return $this->constraint->evaluate($invocation->getMethodName(), '', true);
}
}
PK `TLDg g src/Matcher/Parameters.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Matcher;
use PHPUnit\Framework\Constraint\Constraint;
use PHPUnit\Framework\Constraint\IsAnything;
use PHPUnit\Framework\Constraint\IsEqual;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\MockObject\Invocation as BaseInvocation;
/**
* Invocation matcher which looks for specific parameters in the invocations.
*
* Checks the parameters of all incoming invocations, the parameter list is
* checked against the defined constraints in $parameters. If the constraint
* is met it will return true in matches().
*/
class Parameters extends StatelessInvocation
{
/**
* @var Constraint[]
*/
private $parameters = [];
/**
* @var BaseInvocation
*/
private $invocation;
/**
* @var ExpectationFailedException
*/
private $parameterVerificationResult;
/**
* @param array $parameters
*
* @throws \PHPUnit\Framework\Exception
*/
public function __construct(array $parameters)
{
foreach ($parameters as $parameter) {
if (!($parameter instanceof Constraint)) {
$parameter = new IsEqual(
$parameter
);
}
$this->parameters[] = $parameter;
}
}
/**
* @return string
*/
public function toString(): string
{
$text = 'with parameter';
foreach ($this->parameters as $index => $parameter) {
if ($index > 0) {
$text .= ' and';
}
$text .= ' ' . $index . ' ' . $parameter->toString();
}
return $text;
}
/**
* @param BaseInvocation $invocation
*
* @throws \Exception
*
* @return bool
*/
public function matches(BaseInvocation $invocation)
{
$this->invocation = $invocation;
$this->parameterVerificationResult = null;
try {
$this->parameterVerificationResult = $this->verify();
return $this->parameterVerificationResult;
} catch (ExpectationFailedException $e) {
$this->parameterVerificationResult = $e;
throw $this->parameterVerificationResult;
}
}
/**
* Checks if the invocation $invocation matches the current rules. If it
* does the matcher will get the invoked() method called which should check
* if an expectation is met.
*
* @throws ExpectationFailedException
*
* @return bool
*/
public function verify()
{
if (isset($this->parameterVerificationResult)) {
return $this->guardAgainstDuplicateEvaluationOfParameterConstraints();
}
if ($this->invocation === null) {
throw new ExpectationFailedException('Mocked method does not exist.');
}
if (\count($this->invocation->getParameters()) < \count($this->parameters)) {
$message = 'Parameter count for invocation %s is too low.';
// The user called `->with($this->anything())`, but may have meant
// `->withAnyParameters()`.
//
// @see https://github.com/sebastianbergmann/phpunit-mock-objects/issues/199
if (\count($this->parameters) === 1 &&
\get_class($this->parameters[0]) === IsAnything::class) {
$message .= "\nTo allow 0 or more parameters with any value, omit ->with() or use ->withAnyParameters() instead.";
}
throw new ExpectationFailedException(
\sprintf($message, $this->invocation->toString())
);
}
foreach ($this->parameters as $i => $parameter) {
$parameter->evaluate(
$this->invocation->getParameters()[$i],
\sprintf(
'Parameter %s for invocation %s does not match expected ' .
'value.',
$i,
$this->invocation->toString()
)
);
}
return true;
}
/**
* @throws ExpectationFailedException
*
* @return bool
*/
private function guardAgainstDuplicateEvaluationOfParameterConstraints()
{
if ($this->parameterVerificationResult instanceof \Exception) {
throw $this->parameterVerificationResult;
}
return (bool) $this->parameterVerificationResult;
}
}
PK `TL] # src/Matcher/InvokedAtLeastCount.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Matcher;
use PHPUnit\Framework\ExpectationFailedException;
/**
* Invocation matcher which checks if a method has been invoked at least
* N times.
*/
class InvokedAtLeastCount extends InvokedRecorder
{
/**
* @var int
*/
private $requiredInvocations;
/**
* @param int $requiredInvocations
*/
public function __construct($requiredInvocations)
{
$this->requiredInvocations = $requiredInvocations;
}
/**
* @return string
*/
public function toString(): string
{
return 'invoked at least ' . $this->requiredInvocations . ' times';
}
/**
* Verifies that the current expectation is valid. If everything is OK the
* code should just return, if not it must throw an exception.
*
* @throws ExpectationFailedException
*/
public function verify()
{
$count = $this->getInvocationCount();
if ($count < $this->requiredInvocations) {
throw new ExpectationFailedException(
'Expected invocation at least ' . $this->requiredInvocations .
' times but it occurred ' . $count . ' time(s).'
);
}
}
}
PK `TL&p# # src/Matcher/InvokedCount.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Matcher;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\MockObject\Invocation as BaseInvocation;
/**
* Invocation matcher which checks if a method has been invoked a certain amount
* of times.
* If the number of invocations exceeds the value it will immediately throw an
* exception,
* If the number is less it will later be checked in verify() and also throw an
* exception.
*/
class InvokedCount extends InvokedRecorder
{
/**
* @var int
*/
private $expectedCount;
/**
* @param int $expectedCount
*/
public function __construct($expectedCount)
{
$this->expectedCount = $expectedCount;
}
/**
* @return bool
*/
public function isNever()
{
return $this->expectedCount === 0;
}
/**
* @return string
*/
public function toString(): string
{
return 'invoked ' . $this->expectedCount . ' time(s)';
}
/**
* @param BaseInvocation $invocation
*
* @throws ExpectationFailedException
*/
public function invoked(BaseInvocation $invocation)
{
parent::invoked($invocation);
$count = $this->getInvocationCount();
if ($count > $this->expectedCount) {
$message = $invocation->toString() . ' ';
switch ($this->expectedCount) {
case 0:
$message .= 'was not expected to be called.';
break;
case 1:
$message .= 'was not expected to be called more than once.';
break;
default:
$message .= \sprintf(
'was not expected to be called more than %d times.',
$this->expectedCount
);
}
throw new ExpectationFailedException($message);
}
}
/**
* Verifies that the current expectation is valid. If everything is OK the
* code should just return, if not it must throw an exception.
*
* @throws ExpectationFailedException
*/
public function verify()
{
$count = $this->getInvocationCount();
if ($count !== $this->expectedCount) {
throw new ExpectationFailedException(
\sprintf(
'Method was expected to be called %d times, ' .
'actually called %d times.',
$this->expectedCount,
$count
)
);
}
}
}
PK `TLTuf # src/Matcher/StatelessInvocation.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Matcher;
use PHPUnit\Framework\MockObject\Invocation as BaseInvocation;
/**
* Invocation matcher which does not care about previous state from earlier
* invocations.
*
* This abstract class can be implemented by matchers which does not care about
* state but only the current run-time value of the invocation itself.
*/
abstract class StatelessInvocation implements Invocation
{
/**
* Registers the invocation $invocation in the object as being invoked.
* This will only occur after matches() returns true which means the
* current invocation is the correct one.
*
* The matcher can store information from the invocation which can later
* be checked in verify(), or it can check the values directly and throw
* and exception if an expectation is not met.
*
* If the matcher is a stub it will also have a return value.
*
* @param BaseInvocation $invocation Object containing information on a mocked or stubbed method which was invoked
*
* @return mixed
*/
public function invoked(BaseInvocation $invocation)
{
}
/**
* Checks if the invocation $invocation matches the current rules. If it does
* the matcher will get the invoked() method called which should check if an
* expectation is met.
*
* @param Invocation $invocation Object containing information on a mocked or stubbed method which was invoked
*
* @return bool
*/
public function verify()
{
}
}
PK `TLt src/Matcher/InvokedAtIndex.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Matcher;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\MockObject\Invocation as BaseInvocation;
/**
* Invocation matcher which checks if a method was invoked at a certain index.
*
* If the expected index number does not match the current invocation index it
* will not match which means it skips all method and parameter matching. Only
* once the index is reached will the method and parameter start matching and
* verifying.
*
* If the index is never reached it will throw an exception in index.
*/
class InvokedAtIndex implements Invocation
{
/**
* @var int
*/
private $sequenceIndex;
/**
* @var int
*/
private $currentIndex = -1;
/**
* @param int $sequenceIndex
*/
public function __construct($sequenceIndex)
{
$this->sequenceIndex = $sequenceIndex;
}
/**
* @return string
*/
public function toString(): string
{
return 'invoked at sequence index ' . $this->sequenceIndex;
}
/**
* @param BaseInvocation $invocation
*
* @return bool
*/
public function matches(BaseInvocation $invocation)
{
$this->currentIndex++;
return $this->currentIndex == $this->sequenceIndex;
}
/**
* @param BaseInvocation $invocation
*/
public function invoked(BaseInvocation $invocation)
{
}
/**
* Verifies that the current expectation is valid. If everything is OK the
* code should just return, if not it must throw an exception.
*
* @throws ExpectationFailedException
*/
public function verify()
{
if ($this->currentIndex < $this->sequenceIndex) {
throw new ExpectationFailedException(
\sprintf(
'The expected invocation at index %s was never reached.',
$this->sequenceIndex
)
);
}
}
}
PK `TL " src/Matcher/InvokedAtMostCount.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Matcher;
use PHPUnit\Framework\ExpectationFailedException;
/**
* Invocation matcher which checks if a method has been invoked at least
* N times.
*/
class InvokedAtMostCount extends InvokedRecorder
{
/**
* @var int
*/
private $allowedInvocations;
/**
* @param int $allowedInvocations
*/
public function __construct($allowedInvocations)
{
$this->allowedInvocations = $allowedInvocations;
}
/**
* @return string
*/
public function toString(): string
{
return 'invoked at most ' . $this->allowedInvocations . ' times';
}
/**
* Verifies that the current expectation is valid. If everything is OK the
* code should just return, if not it must throw an exception.
*
* @throws ExpectationFailedException
*/
public function verify()
{
$count = $this->getInvocationCount();
if ($count > $this->allowedInvocations) {
throw new ExpectationFailedException(
'Expected invocation at most ' . $this->allowedInvocations .
' times but it occurred ' . $count . ' time(s).'
);
}
}
}
PK `TLK/ src/Matcher/Invocation.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Matcher;
use PHPUnit\Framework\MockObject\Invocation as BaseInvocation;
use PHPUnit\Framework\MockObject\Verifiable;
use PHPUnit\Framework\SelfDescribing;
/**
* Interface for classes which matches an invocation based on its
* method name, argument, order or call count.
*/
interface Invocation extends SelfDescribing, Verifiable
{
/**
* Registers the invocation $invocation in the object as being invoked.
* This will only occur after matches() returns true which means the
* current invocation is the correct one.
*
* The matcher can store information from the invocation which can later
* be checked in verify(), or it can check the values directly and throw
* and exception if an expectation is not met.
*
* If the matcher is a stub it will also have a return value.
*
* @param BaseInvocation $invocation Object containing information on a mocked or stubbed method which was invoked
*
* @return mixed
*/
public function invoked(BaseInvocation $invocation);
/**
* Checks if the invocation $invocation matches the current rules. If it does
* the matcher will get the invoked() method called which should check if an
* expectation is met.
*
* @param BaseInvocation $invocation Object containing information on a mocked or stubbed method which was invoked
*
* @return bool
*/
public function matches(BaseInvocation $invocation);
}
PK `TLA¶ src/Matcher/InvokedRecorder.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Matcher;
use PHPUnit\Framework\MockObject\Invocation as BaseInvocation;
/**
* Records invocations and provides convenience methods for checking them later
* on.
* This abstract class can be implemented by matchers which needs to check the
* number of times an invocation has occurred.
*/
abstract class InvokedRecorder implements Invocation
{
/**
* @var BaseInvocation[]
*/
private $invocations = [];
/**
* @return int
*/
public function getInvocationCount()
{
return \count($this->invocations);
}
/**
* @return BaseInvocation[]
*/
public function getInvocations()
{
return $this->invocations;
}
/**
* @return bool
*/
public function hasBeenInvoked()
{
return \count($this->invocations) > 0;
}
/**
* @param BaseInvocation $invocation
*/
public function invoked(BaseInvocation $invocation)
{
$this->invocations[] = $invocation;
}
/**
* @param BaseInvocation $invocation
*
* @return bool
*/
public function matches(BaseInvocation $invocation)
{
return true;
}
}
PK `TL|m % src/Matcher/ConsecutiveParameters.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Matcher;
use PHPUnit\Framework\Constraint\Constraint;
use PHPUnit\Framework\Constraint\IsEqual;
use PHPUnit\Framework\ExpectationFailedException;
use PHPUnit\Framework\MockObject\Invocation as BaseInvocation;
/**
* Invocation matcher which looks for sets of specific parameters in the invocations.
*
* Checks the parameters of the incoming invocations, the parameter list is
* checked against the defined constraints in $parameters. If the constraint
* is met it will return true in matches().
*
* It takes a list of match groups and and increases a call index after each invocation.
* So the first invocation uses the first group of constraints, the second the next and so on.
*/
class ConsecutiveParameters extends StatelessInvocation
{
/**
* @var array
*/
private $parameterGroups = [];
/**
* @var array
*/
private $invocations = [];
/**
* @param array $parameterGroups
*
* @throws \PHPUnit\Framework\Exception
*/
public function __construct(array $parameterGroups)
{
foreach ($parameterGroups as $index => $parameters) {
foreach ($parameters as $parameter) {
if (!$parameter instanceof Constraint) {
$parameter = new IsEqual($parameter);
}
$this->parameterGroups[$index][] = $parameter;
}
}
}
/**
* @return string
*/
public function toString(): string
{
return 'with consecutive parameters';
}
/**
* @param BaseInvocation $invocation
*
* @throws \PHPUnit\Framework\ExpectationFailedException
*
* @return bool
*/
public function matches(BaseInvocation $invocation)
{
$this->invocations[] = $invocation;
$callIndex = \count($this->invocations) - 1;
$this->verifyInvocation($invocation, $callIndex);
return false;
}
public function verify()
{
foreach ($this->invocations as $callIndex => $invocation) {
$this->verifyInvocation($invocation, $callIndex);
}
}
/**
* Verify a single invocation
*
* @param BaseInvocation $invocation
* @param int $callIndex
*
* @throws ExpectationFailedException
*/
private function verifyInvocation(BaseInvocation $invocation, $callIndex)
{
if (isset($this->parameterGroups[$callIndex])) {
$parameters = $this->parameterGroups[$callIndex];
} else {
// no parameter assertion for this call index
return;
}
if ($invocation === null) {
throw new ExpectationFailedException(
'Mocked method does not exist.'
);
}
if (\count($invocation->getParameters()) < \count($parameters)) {
throw new ExpectationFailedException(
\sprintf(
'Parameter count for invocation %s is too low.',
$invocation->toString()
)
);
}
foreach ($parameters as $i => $parameter) {
$parameter->evaluate(
$invocation->getParameters()[$i],
\sprintf(
'Parameter %s for invocation #%d %s does not match expected ' .
'value.',
$i,
$callIndex,
$invocation->toString()
)
);
}
}
}
PK `TL$
src/Matcher/AnyInvokedCount.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Matcher;
/**
* Invocation matcher which checks if a method has been invoked zero or more
* times. This matcher will always match.
*/
class AnyInvokedCount extends InvokedRecorder
{
/**
* @return string
*/
public function toString(): string
{
return 'invoked zero or more times';
}
public function verify()
{
}
}
PK `TLwji src/Matcher/AnyParameters.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Matcher;
use PHPUnit\Framework\MockObject\Invocation as BaseInvocation;
/**
* Invocation matcher which allows any parameters to a method.
*/
class AnyParameters extends StatelessInvocation
{
/**
* @return string
*/
public function toString(): string
{
return 'with any parameters';
}
/**
* @param BaseInvocation $invocation
*
* @return bool
*/
public function matches(BaseInvocation $invocation)
{
return true;
}
}
PK `TL@U src/Stub.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject;
use PHPUnit\Framework\SelfDescribing;
/**
* An object that stubs the process of a normal method for a mock object.
*
* The stub object will replace the code for the stubbed method and return a
* specific value instead of the original value.
*/
interface Stub extends SelfDescribing
{
/**
* Fakes the processing of the invocation $invocation by returning a
* specific value.
*
* @param Invocation $invocation The invocation which was mocked and matched by the current method and argument matchers
*
* @return mixed
*/
public function invoke(Invocation $invocation);
}
PK `TLUs s src/Builder/Identity.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Builder;
/**
* Builder interface for unique identifiers.
*
* Defines the interface for recording unique identifiers. The identifiers
* can be used to define the invocation order of expectations. The expectation
* is recorded using id() and then defined in order using
* PHPUnit\Framework\MockObject\Builder\Match::after().
*/
interface Identity
{
/**
* Sets the identification of the expectation to $id.
*
* @note The identifier is unique per mock object.
*
* @param string $id unique identification of expectation
*/
public function id($id);
}
PK `TL src/Builder/Match.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Builder;
/**
* Builder interface for invocation order matches.
*/
interface Match extends Stub
{
/**
* Defines the expectation which must occur before the current is valid.
*
* @param string $id the identification of the expectation that should
* occur before this one
*
* @return Stub
*/
public function after($id);
}
PK `TL4 src/Builder/MethodNameMatch.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Builder;
/**
* Builder interface for matcher of method names.
*/
interface MethodNameMatch extends ParametersMatch
{
/**
* Adds a new method name match and returns the parameter match object for
* further matching possibilities.
*
* @param \PHPUnit\Framework\Constraint\Constraint $name Constraint for matching method, if a string is passed it will use the PHPUnit_Framework_Constraint_IsEqual
*
* @return ParametersMatch
*/
public function method($name);
}
PK `TLC C src/Builder/InvocationMocker.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Builder;
use PHPUnit\Framework\Constraint\Constraint;
use PHPUnit\Framework\MockObject\Matcher;
use PHPUnit\Framework\MockObject\Matcher\Invocation;
use PHPUnit\Framework\MockObject\RuntimeException;
use PHPUnit\Framework\MockObject\Stub;
use PHPUnit\Framework\MockObject\Stub\MatcherCollection;
/**
* Builder for mocked or stubbed invocations.
*
* Provides methods for building expectations without having to resort to
* instantiating the various matchers manually. These methods also form a
* more natural way of reading the expectation. This class should be together
* with the test case PHPUnit\Framework\MockObject\TestCase.
*/
class InvocationMocker implements MethodNameMatch
{
/**
* @var MatcherCollection
*/
private $collection;
/**
* @var Matcher
*/
private $matcher;
/**
* @var string[]
*/
private $configurableMethods = [];
/**
* @param MatcherCollection $collection
* @param Invocation $invocationMatcher
* @param array $configurableMethods
*/
public function __construct(MatcherCollection $collection, Invocation $invocationMatcher, array $configurableMethods)
{
$this->collection = $collection;
$this->matcher = new Matcher($invocationMatcher);
$this->collection->addMatcher($this->matcher);
$this->configurableMethods = $configurableMethods;
}
/**
* @return Matcher
*/
public function getMatcher()
{
return $this->matcher;
}
/**
* @param mixed $id
*
* @return InvocationMocker
*/
public function id($id)
{
$this->collection->registerId($id, $this);
return $this;
}
/**
* @param Stub $stub
*
* @return InvocationMocker
*/
public function will(Stub $stub)
{
$this->matcher->setStub($stub);
return $this;
}
/**
* @param mixed $value
* @param mixed $nextValues, ...
*
* @return InvocationMocker
*/
public function willReturn($value, ...$nextValues)
{
if (\count($nextValues) === 0) {
$stub = new Stub\ReturnStub($value);
} else {
$stub = new Stub\ConsecutiveCalls(
\array_merge([$value], $nextValues)
);
}
return $this->will($stub);
}
/**
* @param mixed $reference
*
* @return InvocationMocker
*/
public function willReturnReference(&$reference)
{
$stub = new Stub\ReturnReference($reference);
return $this->will($stub);
}
/**
* @param array $valueMap
*
* @return InvocationMocker
*/
public function willReturnMap(array $valueMap)
{
$stub = new Stub\ReturnValueMap($valueMap);
return $this->will($stub);
}
/**
* @param mixed $argumentIndex
*
* @return InvocationMocker
*/
public function willReturnArgument($argumentIndex)
{
$stub = new Stub\ReturnArgument($argumentIndex);
return $this->will($stub);
}
/**
* @param callable $callback
*
* @return InvocationMocker
*/
public function willReturnCallback($callback)
{
$stub = new Stub\ReturnCallback($callback);
return $this->will($stub);
}
/**
* @return InvocationMocker
*/
public function willReturnSelf()
{
$stub = new Stub\ReturnSelf;
return $this->will($stub);
}
/**
* @param mixed $values, ...
*
* @return InvocationMocker
*/
public function willReturnOnConsecutiveCalls(...$values)
{
$stub = new Stub\ConsecutiveCalls($values);
return $this->will($stub);
}
/**
* @param \Exception $exception
*
* @return InvocationMocker
*/
public function willThrowException(\Exception $exception)
{
$stub = new Stub\Exception($exception);
return $this->will($stub);
}
/**
* @param mixed $id
*
* @return InvocationMocker
*/
public function after($id)
{
$this->matcher->setAfterMatchBuilderId($id);
return $this;
}
/**
* @param array ...$arguments
*
* @throws RuntimeException
*
* @return InvocationMocker
*/
public function with(...$arguments)
{
$this->canDefineParameters();
$this->matcher->setParametersMatcher(new Matcher\Parameters($arguments));
return $this;
}
/**
* @param array ...$arguments
*
* @throws RuntimeException
*
* @return InvocationMocker
*/
public function withConsecutive(...$arguments)
{
$this->canDefineParameters();
$this->matcher->setParametersMatcher(new Matcher\ConsecutiveParameters($arguments));
return $this;
}
/**
* @throws RuntimeException
*
* @return InvocationMocker
*/
public function withAnyParameters()
{
$this->canDefineParameters();
$this->matcher->setParametersMatcher(new Matcher\AnyParameters);
return $this;
}
/**
* @param Constraint|string $constraint
*
* @throws RuntimeException
*
* @return InvocationMocker
*/
public function method($constraint)
{
if ($this->matcher->hasMethodNameMatcher()) {
throw new RuntimeException(
'Method name matcher is already defined, cannot redefine'
);
}
if (\is_string($constraint) && !\in_array(\strtolower($constraint), $this->configurableMethods)) {
throw new RuntimeException(
\sprintf(
'Trying to configure method "%s" which cannot be configured because it does not exist, has not been specified, is final, or is static',
$constraint
)
);
}
$this->matcher->setMethodNameMatcher(new Matcher\MethodName($constraint));
return $this;
}
/**
* Validate that a parameters matcher can be defined, throw exceptions otherwise.
*
* @throws RuntimeException
*/
private function canDefineParameters()
{
if (!$this->matcher->hasMethodNameMatcher()) {
throw new RuntimeException(
'Method name matcher is not defined, cannot define parameter ' .
'matcher without one'
);
}
if ($this->matcher->hasParametersMatcher()) {
throw new RuntimeException(
'Parameter matcher is already defined, cannot redefine'
);
}
}
}
PK `TLH[D src/Builder/Stub.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Builder;
use PHPUnit\Framework\MockObject\Stub as BaseStub;
/**
* Builder interface for stubs which are actions replacing an invocation.
*/
interface Stub extends Identity
{
/**
* Stubs the matching method with the stub object $stub. Any invocations of
* the matched method will now be handled by the stub instead.
*
* @param BaseStub $stub
*
* @return Identity
*/
public function will(BaseStub $stub);
}
PK `TL+J src/Builder/ParametersMatch.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Builder;
use PHPUnit\Framework\MockObject\Matcher\AnyParameters;
/**
* Builder interface for parameter matchers.
*/
interface ParametersMatch extends Match
{
/**
* Sets the parameters to match for, each parameter to this function will
* be part of match. To perform specific matches or constraints create a
* new PHPUnit\Framework\Constraint\Constraint and use it for the parameter.
* If the parameter value is not a constraint it will use the
* PHPUnit\Framework\Constraint\IsEqual for the value.
*
* Some examples:
*
* // match first parameter with value 2
* $b->with(2);
* // match first parameter with value 'smock' and second identical to 42
* $b->with('smock', new PHPUnit\Framework\Constraint\IsEqual(42));
*
*
* @return ParametersMatch
*/
public function with(...$arguments);
/**
* Sets a matcher which allows any kind of parameters.
*
* Some examples:
*
* // match any number of parameters
* $b->withAnyParameters();
*
*
* @return AnyParameters
*/
public function withAnyParameters();
}
PK `TLO 9 9 src/Builder/NamespaceMatch.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Builder;
/**
* Interface for builders which can register builders with a given identification.
*
* This interface relates to Identity.
*/
interface NamespaceMatch
{
/**
* Looks up the match builder with identification $id and returns it.
*
* @param string $id The identification of the match builder
*
* @return Match
*/
public function lookupId($id);
/**
* Registers the match builder $builder with the identification $id. The
* builder can later be looked up using lookupId() to figure out if it
* has been invoked.
*
* @param string $id The identification of the match builder
* @param Match $builder The builder which is being registered
*/
public function registerId($id, Match $builder);
}
PK `TL]9{ src/Stub/ReturnStub.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Stub;
use PHPUnit\Framework\MockObject\Invocation;
use PHPUnit\Framework\MockObject\Stub;
use SebastianBergmann\Exporter\Exporter;
/**
* Stubs a method by returning a user-defined value.
*/
class ReturnStub implements Stub
{
/**
* @var mixed
*/
private $value;
public function __construct($value)
{
$this->value = $value;
}
public function invoke(Invocation $invocation)
{
return $this->value;
}
public function toString(): string
{
$exporter = new Exporter;
return \sprintf(
'return user-specified value %s',
$exporter->export($this->value)
);
}
}
PK `TL$b src/Stub/ConsecutiveCalls.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Stub;
use PHPUnit\Framework\MockObject\Invocation;
use PHPUnit\Framework\MockObject\Stub;
use SebastianBergmann\Exporter\Exporter;
/**
* Stubs a method by returning a user-defined stack of values.
*/
class ConsecutiveCalls implements Stub
{
/**
* @var array
*/
private $stack;
/**
* @var mixed
*/
private $value;
public function __construct(array $stack)
{
$this->stack = $stack;
}
public function invoke(Invocation $invocation)
{
$this->value = \array_shift($this->stack);
if ($this->value instanceof Stub) {
$this->value = $this->value->invoke($invocation);
}
return $this->value;
}
public function toString(): string
{
$exporter = new Exporter;
return \sprintf(
'return user-specified value %s',
$exporter->export($this->value)
);
}
}
PK `TL src/Stub/ReturnArgument.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Stub;
use PHPUnit\Framework\MockObject\Invocation;
use PHPUnit\Framework\MockObject\Stub;
/**
* Stubs a method by returning an argument that was passed to the mocked method.
*/
class ReturnArgument implements Stub
{
/**
* @var int
*/
private $argumentIndex;
public function __construct($argumentIndex)
{
$this->argumentIndex = $argumentIndex;
}
public function invoke(Invocation $invocation)
{
if (isset($invocation->getParameters()[$this->argumentIndex])) {
return $invocation->getParameters()[$this->argumentIndex];
}
return;
}
public function toString(): string
{
return \sprintf('return argument #%d', $this->argumentIndex);
}
}
PK `TL src/Stub/ReturnReference.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Stub;
use PHPUnit\Framework\MockObject\Invocation;
use PHPUnit\Framework\MockObject\Stub;
use SebastianBergmann\Exporter\Exporter;
/**
* Stubs a method by returning a user-defined reference to a value.
*/
class ReturnReference implements Stub
{
/**
* @var mixed
*/
private $reference;
public function __construct(&$reference)
{
$this->reference = &$reference;
}
public function invoke(Invocation $invocation)
{
return $this->reference;
}
public function toString(): string
{
$exporter = new Exporter;
return \sprintf(
'return user-specified reference %s',
$exporter->export($this->reference)
);
}
}
PK `TL5Ͷ src/Stub/MatcherCollection.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Stub;
use PHPUnit\Framework\MockObject\Matcher\Invocation;
/**
* Stubs a method by returning a user-defined value.
*/
interface MatcherCollection
{
/**
* Adds a new matcher to the collection which can be used as an expectation
* or a stub.
*
* @param Invocation $matcher Matcher for invocations to mock objects
*/
public function addMatcher(Invocation $matcher);
}
PK `TL; src/Stub/Exception.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Stub;
use PHPUnit\Framework\MockObject\Invocation;
use PHPUnit\Framework\MockObject\Stub;
use SebastianBergmann\Exporter\Exporter;
/**
* Stubs a method by raising a user-defined exception.
*/
class Exception implements Stub
{
private $exception;
public function __construct(\Throwable $exception)
{
$this->exception = $exception;
}
public function invoke(Invocation $invocation)
{
throw $this->exception;
}
public function toString(): string
{
$exporter = new Exporter;
return \sprintf(
'raise user-specified exception %s',
$exporter->export($this->exception)
);
}
}
PK `TLqn src/Stub/ReturnSelf.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Stub;
use PHPUnit\Framework\MockObject\Invocation;
use PHPUnit\Framework\MockObject\Invocation\ObjectInvocation;
use PHPUnit\Framework\MockObject\RuntimeException;
use PHPUnit\Framework\MockObject\Stub;
/**
* Stubs a method by returning the current object.
*/
class ReturnSelf implements Stub
{
public function invoke(Invocation $invocation)
{
if (!$invocation instanceof ObjectInvocation) {
throw new RuntimeException(
'The current object can only be returned when mocking an ' .
'object, not a static class.'
);
}
return $invocation->getObject();
}
public function toString(): string
{
return 'return the current object';
}
}
PK `TLz src/Stub/ReturnCallback.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Stub;
use PHPUnit\Framework\MockObject\Invocation;
use PHPUnit\Framework\MockObject\Stub;
class ReturnCallback implements Stub
{
private $callback;
public function __construct($callback)
{
$this->callback = $callback;
}
public function invoke(Invocation $invocation)
{
return \call_user_func_array($this->callback, $invocation->getParameters());
}
public function toString(): string
{
if (\is_array($this->callback)) {
if (\is_object($this->callback[0])) {
$class = \get_class($this->callback[0]);
$type = '->';
} else {
$class = $this->callback[0];
$type = '::';
}
return \sprintf(
'return result of user defined callback %s%s%s() with the ' .
'passed arguments',
$class,
$type,
$this->callback[1]
);
}
return 'return result of user defined callback ' . $this->callback .
' with the passed arguments';
}
}
PK `TLL# src/Stub/ReturnValueMap.phpnu W+A
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace PHPUnit\Framework\MockObject\Stub;
use PHPUnit\Framework\MockObject\Invocation;
use PHPUnit\Framework\MockObject\Stub;
/**
* Stubs a method by returning a value from a map.
*/
class ReturnValueMap implements Stub
{
/**
* @var array
*/
private $valueMap;
public function __construct(array $valueMap)
{
$this->valueMap = $valueMap;
}
public function invoke(Invocation $invocation)
{
$parameterCount = \count($invocation->getParameters());
foreach ($this->valueMap as $map) {
if (!\is_array($map) || $parameterCount !== (\count($map) - 1)) {
continue;
}
$return = \array_pop($map);
if ($invocation->getParameters() === $map) {
return $return;
}
}
return;
}
public function toString(): string
{
return 'return value from a map';
}
}
PK `TLd * src/Generator/mocked_class_method.tpl.distnu W+A
public function method()
{
$any = new \PHPUnit\Framework\MockObject\Matcher\AnyInvokedCount;
$expects = $this->expects($any);
return call_user_func_array([$expects, 'method'], func_get_args());
}
PK `TL[$~7 7 " src/Generator/trait_class.tpl.distnu W+A {prologue}class {class_name}
{
use {trait_name};
}
PK `TL8W}؟ % src/Generator/unmocked_clone.tpl.distnu W+A public function __clone()
{
$this->__phpunit_invocationMocker = clone $this->__phpunit_getInvocationMocker();
parent::__clone();
}
PK `TLWHi * src/Generator/proxied_method_void.tpl.distnu W+A
{modifier} function {reference}{method_name}({arguments_decl}){return_delim}{return_type}
{
$arguments = [{arguments_call}];
$count = func_num_args();
if ($count > {arguments_count}) {
$_arguments = func_get_args();
for ($i = {arguments_count}; $i < $count; $i++) {
$arguments[] = $_arguments[$i];
}
}
$this->__phpunit_getInvocationMocker()->invoke(
new \PHPUnit\Framework\MockObject\Invocation\ObjectInvocation(
'{class_name}', '{method_name}', $arguments, '{return_type}', $this, {clone_arguments}
)
);
call_user_func_array(array($this->__phpunit_originalObject, "{method_name}"), $arguments);
}
PK `TLO5s; ; " src/Generator/deprecation.tpl.distnu W+A
@trigger_error({deprecation}, E_USER_DEPRECATED);
PK `TLb/ # src/Generator/mocked_class.tpl.distnu W+A {prologue}{class_declaration}
{
private $__phpunit_invocationMocker;
private $__phpunit_originalObject;
private $__phpunit_configurable = {configurable};
{clone}{mocked_methods}
public function expects(\PHPUnit\Framework\MockObject\Matcher\Invocation $matcher)
{
return $this->__phpunit_getInvocationMocker()->expects($matcher);
}
{method}
public function __phpunit_setOriginalObject($originalObject)
{
$this->__phpunit_originalObject = $originalObject;
}
public function __phpunit_getInvocationMocker()
{
if ($this->__phpunit_invocationMocker === null) {
$this->__phpunit_invocationMocker = new \PHPUnit\Framework\MockObject\InvocationMocker($this->__phpunit_configurable);
}
return $this->__phpunit_invocationMocker;
}
public function __phpunit_hasMatchers()
{
return $this->__phpunit_getInvocationMocker()->hasMatchers();
}
public function __phpunit_verify($unsetInvocationMocker = true)
{
$this->__phpunit_getInvocationMocker()->verify();
if ($unsetInvocationMocker) {
$this->__phpunit_invocationMocker = null;
}
}
}{epilogue}
PK `TLw&S