Prophecy

https://github.com/phpspec/prophecy
Admin
Prophecy is a flexible PHP object mocking framework designed for testing, allowing developers to...
Tokens:126,586
Snippets:959
Trust Score:6.5
License:MIT
Update:1 week ago
Show doc for...
Tokens:
Raw
### Composer Install Command

Source: https://github.com/phpspec/prophecy/blob/master/README.md

Installs the dependencies with Composer using the --prefer-dist flag.

```bash
$> composer install --prefer-dist
```

--------------------------------

### Usage Examples

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument-tokens-array.md

Examples of using Argument::not() and other argument tokens in Prophecy configurations.

```APIDOC
## Usage Examples

### Description
Demonstrates how to use `Argument::not()` and other argument tokens in Prophecy method configurations.

### Code
```php
use Prophecy\Argument;

$prophecy->configure(Argument::withEntry('debug', true))->willReturn('debug mode');
$prophecy->configure(Argument::withEveryEntry(Argument::type('string')))->willReturn('all strings');
$prophecy->configure(Argument::size(2))->willReturn('two items');
$prophecy->configure(Argument::allOf(Argument::withKey('id'), Argument::not(Argument::size(0))))->willReturn('non-empty with id');
$prophecy->configure(Argument::not(Argument::type('int')))->willReturn('not an int');
```
```

--------------------------------

### makeCall usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/call-center.md

Example of instantiating CallCenter and invoking makeCall to execute the winning promise for a method call.

```php
$center = new \Prophecy\Call\CallCenter();
$rv = $center->makeCall($prophecy, 'read', ['123']); // executes winning promise
```

--------------------------------

### should() usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/method-prophecy.md

Shows how to use should() with a prediction, or the shortcuts below.

```php
$em->flush()->should($prediction); // or the shortcuts below
```

--------------------------------

### Getters usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/method-prophecy.md

Shows how to retrieve the promise, object prophecy, arguments wildcard, and return type information from a MethodProphecy instance.

```php
$mp = $prophecy->read('123')->willReturn('x');
$mp->getPromise();                 // ReturnPromise instance
$mp->getObjectProphecy();          // $prophecy
$mp->getArgumentsWildcard();       // ArgumentsWildcard with one ExactValueToken('123')
$mp->hasReturnVoid();              // false for read()
```

--------------------------------

### Usage examples for Argument methods

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument.md

Shows practical usage of various Argument static methods in method calls. Demonstrates exact, type, any, cetera, that, containing, approximate, not, is, and in matchers.

```php
use Prophecy\Argument;

$user->setName(Argument::exact('everzet'));       // exact value
$user->setName(Argument::type('string'));          // any string
$user->save(Argument::any());                      // any single argument
$user->setRoles(Argument::cetera());               // any remaining arguments
$user->setPassword(Argument::that(fn ($p) => strlen($p) > 8));
$user->setTags(Argument::containing('urgent'));    // array contains value
$user->setId(Argument::approximate(10.5, 1));      // ~10.5, 1 decimal
$user->setStatus(Argument::not('disabled'));       // anything but 'disabled'
$user->setName(Argument::is('everzet'));           // strict identity
$user->setRoles(Argument::in(['admin', 'user']));
```

--------------------------------

### Prophet Usage Example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/README.md

Demonstrates the primary usage pattern of the Prophecy library: creating a Prophet instance, prophesizing a class, revealing the prophecy, setting expectations, and checking predictions.

```APIDOC
## Prophet Usage Example

### Description
This example shows the standard workflow for using Prophecy: instantiate a Prophet, create a prophecy for a class, reveal it to get the actual object, set method expectations, and verify predictions in teardown.

### Code Example
```php
use Prophecy\Prophet;

$prophet  = new Prophet();
$prophecy = $prophet->prophesize('App\Security\Hasher');
$hasher   = $prophecy->reveal();

$prophecy->generateHash($user, 'qwerty')->willReturn('hashed_pass');

// ... exercise $hasher ...

// in tearDown():
$prophet->checkPredictions();
```
```

--------------------------------

### Prophet constructor usage examples

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/prophet.md

Shows default instantiation with no arguments and a custom configuration with explicit doubler, revealer, and non-verbose stringifier.

```php
$prophet = new \Prophecy\Prophet();                    // defaults

$custom = new \Prophecy\Prophet(
    new \Prophecy\Doubler\CachedDoubler(),             // custom doubler
    new \Prophecy\Prophecy\Revealer(),                 // custom revealer
    new \Prophecy\Util\StringUtil(false)               // non-verbose stringifier
);
```

--------------------------------

### willReturn usage examples

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/method-prophecy.md

Shows how to use willReturn with a single value and with multiple values. Each call returns the next value; after exhausting them the last value repeats.

```php
$prophecy->read('123')->willReturn('value');
$prophecy->read('456')->willReturn(1, 2, 3); // 1, 2, 3, then 3 ...
```

--------------------------------

### will usage examples

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/method-prophecy.md

Shows two ways to use will: with a ReturnPromise instance and with a callable that receives arguments, object, and method. Callables are wrapped into CallbackPromise.

```php
$mp->will(new \Prophecy\Promise\ReturnPromise(['value']));
$mp->will(function ($args, $object, $method) { return $args[0]; }); // callable form
```

--------------------------------

### getProphecies() usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/prophet.md

Shows how to retrieve all prophecies created so far and count them.

```php
$prophet->prophesize('App\A');
$prophet->prophesize('App\B');
$count = count($prophet->getProphecies()); // 2
```

--------------------------------

### StringUtil usage examples

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/util.md

Examples of using StringUtil::stringify with default verbose mode and with verbose disabled. The verbose=false constructor truncates strings longer than 50 characters.

```php
$util = new \Prophecy\Util\StringUtil();
$util->stringify(['a', 1]);            // "[\"a\", 1]" — note: array of values
$util->stringify(true);                // "true"
$util->stringify(null);                // "null"
$util->stringify('very long');         // "\"very long\""

$util = new \Prophecy\Util\StringUtil(false);
$util->stringify(str_repeat('x', 100)); // truncated: "\"xxxxx...\"..."
```

--------------------------------

### findCalls usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/call-center.md

Example of using findCalls to retrieve calls matching a method name and wildcard.

```php
$calls = $center->findCalls('flush', $wildcard);
```

--------------------------------

### Custom revealer example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/prophecy-interfaces.md

Shows how to implement a custom RevealerInterface that delegates to the default Revealer, and how to pass it to Prophet's constructor.

```php
class LoggingRevealer implements \Prophecy\Prophecy\RevealerInterface
{
    public function reveal($value)
    {
        // delegate to the default behavior
        return (new \Prophecy\Prophecy\Revealer())->reveal($value);
    }
}

$prophet = new \Prophecy\Prophet(null, new LoggingRevealer());
```

--------------------------------

### Usage examples for prophesize()

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/prophet.md

Shows how to create prophecies by class name, interface name, or without arguments for a stdClass-based double. Also demonstrates catching ClassNotFoundException when the class does not exist.

```php
$prophet = new \Prophecy\Prophet();

// by class name
$mailer = $prophet->prophesize('App\Service\Mailer');

// by interface name
$repo = $prophet->prophesize('App\Repository\UserRepository');

// untyped prophecy (double of stdClass)
$generic = $prophet->prophesize();

// error handling
try {
    $prophet->prophesize('App\Service\DoesNotExist');
} catch (\Prophecy\Exception\Doubler\ClassNotFoundException $e) {
    echo $e->getClassname(); // "App\Service\DoesNotExist"
}
```

--------------------------------

### withArguments usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/method-prophecy.md

Shows how to call withArguments with an array of argument tokens, replacing the wildcard. Plain arrays wrap values in ExactValueToken.

```php
$mp->withArguments([\Prophecy\Argument::type('string'), \Prophecy\Argument::any()]);
```

--------------------------------

### ExportUtil::export usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/util.md

Example of using ExportUtil::export to format an array. The output shows the formatted form with indentation.

```php
$str = \Prophecy\Util\ExportUtil::export(['x' => 1]);
// "Array &0 (
//     0 => 'x' => 1
// )"  (formatted form)
```

--------------------------------

### ClassNode usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/generator-nodes.md

Demonstrates creating a ClassNode, setting parent class, adding an interface, property, and method, then checking method existence, read-only status, and parent class.

```php
$node = new \Prophecy\Doubler\Generator\Node\ClassNode();
$node->setParentClass('App\Entity\User');
$node->addInterface('Countable');
$node->addProperty('id', 'private');
$node->addMethod(new \Prophecy\Doubler\Generator\Node\MethodNode('save'));
$node->hasMethod('save');    // true
$node->isReadOnly();         // false
$node->getParentClass();     // "App\Entity\User"
```

--------------------------------

### getMethodProphecies usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/object-prophecy.md

Shows how to retrieve all method prophecies or those for a specific method name.

```php
$all = $prophecy->getMethodProphecies();
$forSend = $prophecy->getMethodProphecies('send');
```

--------------------------------

### InArrayToken usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument-tokens-value.md

Usage example for InArrayToken created by Argument::in(['admin', 'user']). scoreArgument returns 8 for 'admin' and false for 'root'.

```php
$token = \Prophecy\Argument::in(['admin', 'user']);
$token->scoreArgument('admin');   // 8
$token->scoreArgument('root');    // false
```

--------------------------------

### IdenticalValueToken usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument-tokens-value.md

Usage example for IdenticalValueToken created by Argument::is($user). scoreArgument returns 11 for the same instance and false for a clone.

```php
$token = \Prophecy\Argument::is($user);
$token->scoreArgument($user);   // 11 (same instance)
$token->scoreArgument(clone $user); // false
```

--------------------------------

### Full lifecycle example using Prophecy\Call\CallCenter

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/call-center.md

Shows how to instantiate CallCenter, create a prophecy, reveal it, and make calls. The first call returns 'v' via ReturnPromise, while an unmatched call is recorded as unexpected; findCalls('purge', ...) returns non-empty and later Prophet::checkPredictions() throws UnexpectedCallException.

```php
use Prophecy\Call\CallCenter;
use Prophecy\Argument;

$center = new CallCenter();
$prophecy = $prophet->prophesize('App\Service\Cache');
$prophecy->get('k')->willReturn('v');

$double = $prophecy->reveal();
$double->get('k');                       // makeCall -> ReturnPromise -> "v"
$double->purge();                        // unmatched -> recorded as unexpected

$calls = $center->findCalls('purge', new \Prophecy\Argument\ArgumentsWildcard([]));
// $calls non-empty; later Prophet::checkPredictions() throws UnexpectedCallException
```

--------------------------------

### willThrow usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/method-prophecy.md

Configures the connect() prophecy to throw either a RuntimeException by class name or a DomainException instance.

```php
$prophecy->connect()->willThrow('RuntimeException');
$prophecy->connect()->willThrow(new \DomainException('boom'));
```

--------------------------------

### checkUnexpectedCalls usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/call-center.md

Example of calling checkUnexpectedCalls and catching UnexpectedCallException to access the unexpected method name and arguments.

```php
try {
    $center->checkUnexpectedCalls();
} catch (\Prophecy\Exception\Call\UnexpectedCallException $e) {
    echo $e->getMethodName(); // the unexpected method
    print_r($e->getArguments());
}
```

--------------------------------

### willBeConstructedWith usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/object-prophecy.md

Passes constructor arguments and then reveals the double, which is constructed with those args.

```php
$prophecy->willBeConstructedWith(['dsn' => 'sqlite::memory:']);
$double = $prophecy->reveal();   // constructed with those args
```

--------------------------------

### Run Prophecy test suite with Composer, PhpSpec, and PHPUnit

Source: https://github.com/phpspec/prophecy/blob/master/CONTRIBUTING.md

Install dependencies and run the test suite to verify changes. Use after making a feature addition or bug fix to ensure nothing is broken.

```bash
$> composer install --prefer-dist
$> vendor/bin/phpspec run
$> vendor/bin/phpunit
```

--------------------------------

### Simple Prophecy Example with PHPUnit

Source: https://github.com/phpspec/prophecy/blob/master/README.md

Shows a basic usage of Prophecy in a PHPUnit test case. It creates a prophecy for a hasher, sets up a return value, and verifies predictions in tearDown.

```php
<?php

class UserTest extends PHPUnit\Framework\TestCase
{
    private $prophet;

    public function testPasswordHashing()
    {
        $hasher = $this->prophet->prophesize('App\Security\Hasher');
        $user   = new App\Entity\User($hasher->reveal());

        $hasher->generateHash($user, 'qwerty')->willReturn('hashed_pass');

        $user->setPassword('qwerty');

        $this->assertEquals('hashed_pass', $user->getPassword());
    }

    protected function setUp()
    {
        $this->prophet = new \Prophecy\Prophet;
    }

    protected function tearDown()
    {
        $this->prophet->checkPredictions();
    }
}
```

--------------------------------

### ArgumentNode usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/generator-argument-nodes.md

Shows how to create an ArgumentNode, set its type node to a builtin int type, set a default value, and check optional and default status.

```php
$arg = new \Prophecy\Doubler\Generator\Node\ArgumentNode('id');
$arg->setTypeNode(new \Prophecy\Doubler\Generator\Node\ArgumentTypeNode(
    new \Prophecy\Doubler\Generator\Node\Type\BuiltinType('int')
));
$arg->setDefault(null);
$arg->isOptional();   // true
$arg->hasDefault();   // true
```

--------------------------------

### Usage examples with various argument tokens

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument-tokens-array.md

Demonstrates combining LogicalNotToken with other argument tokens like withEntry, withEveryEntry, size, allOf, and type. These tokens combine freely with value and match tokens.

```php
use Prophecy\Argument;

$prophecy->configure(Argument::withEntry('debug', true))->willReturn('debug mode');
$prophecy->configure(Argument::withEveryEntry(Argument::type('string')))->willReturn('all strings');
$prophecy->configure(Argument::size(2))->willReturn('two items');
$prophecy->configure(Argument::allOf(Argument::withKey('id'), Argument::not(Argument::size(0))))->willReturn('non-empty with id');
$prophecy->configure(Argument::not(Argument::type('int')))->willReturn('not an int');
```

--------------------------------

### ExactValueToken usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument-tokens-value.md

Shows creating an ExactValueToken via Argument::exact and testing scoreArgument with matching and non-matching values. Demonstrates that scoreArgument returns 10 for an exact match and false otherwise, and getValue returns the original value.

```php
$token = \Prophecy\Argument::exact('everzet');
$token->scoreArgument('everzet');  // 10
$token->scoreArgument('other');    // false
$token->getValue();                // "everzet"
```

--------------------------------

### willImplement usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/object-prophecy.md

Calls willImplement twice to make the double implement both SessionHandlerInterface and Countable.

```php
$prophecy->willImplement('SessionHandlerInterface');
$prophecy->willImplement('Countable');   // both are implemented
```

--------------------------------

### ReturnPromise usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/promises.md

Demonstrates the sequence semantics of ReturnPromise: values are returned in order, and after the list is exhausted the last value is repeated forever.

```php
$promise = new \Prophecy\Promise\ReturnPromise(['a', 'b']);
$promise->execute([], $prophecy, $mp); // 'a'
$promise->execute([], $prophecy, $mp); // 'b'
$promise->execute([], $prophecy, $mp); // 'b' (repeats last value)
```

--------------------------------

### Customizing the doubler via constructor injection

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/configuration.md

Example of injecting a custom Doubler with an extra class patch into Prophet to alter double behavior globally.

```php
// Customizing the doubler via constructor injection
$doubler = new \Prophecy\Doubler\Doubler();
$doubler->registerClassPatch(new MyCustomPatch());
$prophet = new \Prophecy\Prophet($doubler);
```

--------------------------------

### CallbackPromise usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/promises.md

Creates a CallbackPromise with a closure that uppercases the first argument. Calling execute with ['hi'] returns 'HI'.

```php
$promise = new \Prophecy\Promise\CallbackPromise(function ($args) {
    return strtoupper($args[0]);
});
$promise->execute(['hi'], $prophecy, $mp); // "HI"
```

--------------------------------

### willReturnArgument usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/method-prophecy.md

Configures the save() prophecy to return the first argument passed to the call.

```php
$prophecy->save($anything)->willReturnArgument(0);
```

--------------------------------

### shouldHaveBeenCalled() spy check usage

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/method-prophecy.md

Example of using shouldHaveBeenCalled() as a spy check after exercising the code.

```php
$em->flush()->shouldHaveBeenCalled(); // spy check after exercising the code
```

--------------------------------

### Creating and using a Call object

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/call-center.md

Example of instantiating a Call for a 'save' method with arguments, return value, and caller location. Shows getMethodName(), getCallPlace(), and getScore() usage. The getScore() method requires an ArgumentsWildcard and returns an int score or false.

```php
$call = new \Prophecy\Call\Call('save', [['id' => 1]], true, null, '/app/User.php', 42);
$call->getMethodName();   // "save"
$call->getCallPlace();    // "/app/User.php:42"
$call->getScore($wildcard); // int score or false
```

--------------------------------

### willYield usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/method-prophecy.md

Configures the getRows() prophecy to yield an array of rows. The generator will yield each row in sequence.

```php
$prophecy->getRows()->willYield([['id' => 1], ['id' => 2]]);
```

--------------------------------

### findProphecyMethodCalls usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/object-prophecy.md

Finds recorded calls for a method with an empty arguments wildcard, returning a list of Prophecy\Call\Call objects.

```php
$calls = $prophecy->findProphecyMethodCalls('flush', new \Prophecy\Argument\ArgumentsWildcard([]));
// list of Prophecy\Call\Call
```

--------------------------------

### ClassCreator usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/generator.md

Creates a double class in the runtime environment using eval(). The class will exist after the call.

```php
$creator = new \Prophecy\Doubler\Generator\ClassCreator();
$creator->create('Double\App\Foo\P1', $node);
// class now exists in the runtime environment
```

--------------------------------

### ReturnArgumentPromise usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/promises.md

Shows how to instantiate ReturnArgumentPromise with index 1 and call execute. Returns 'b' when enough arguments, null when not. Throws InvalidArgumentException for negative index.

```php
$promise = new \Prophecy\Promise\ReturnArgumentPromise(1);
$promise->execute(['a', 'b', 'c'], $prophecy, $mp); // 'b'
$promise->execute(['only'], $prophecy, $mp);        // null

try {
    new \Prophecy\Promise\ReturnArgumentPromise(-1);
} catch (\Prophecy\Exception\InvalidArgumentException $e) {
    // "Zero-based index expected ... but got -1."
}
```

--------------------------------

### Using ClassMirror to reflect a class

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/generator.md

Example usage of ClassMirror::reflect() to create a class node for a given class. Shows how to access the parent class and methods.

```php
$mirror = new \Prophecy\Doubler\Generator\ClassMirror();
$node   = $mirror->reflect(new \ReflectionClass('App\Entity\User'), []);
$node->getParentClass();       // "App\Entity\User"
$node->getMethods();           // array<string, MethodNode>
```

--------------------------------

### scoreArguments usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument.md

Shows how to use scoreArguments with a wildcard containing a type token and an any token. The first call returns 8 (5 + 3), the second returns false because the second argument is missing.

```php
$wildcard = new \Prophecy\Argument\ArgumentsWildcard(
    [\Prophecy\Argument::type('string'), \Prophecy\Argument::any()]
);
$wildcard->scoreArguments(['hello', 42]); // 5 + 3 = 8
$wildcard->scoreArguments(['hello']);      // false (missing second argument)

```

--------------------------------

### willReturn void method error example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/method-prophecy.md

Shows the error when calling willReturn on a method with a void return type. Throws MethodProphecyException with the message 'has a void return type'.

```php
// void method error
$prophecy->save()->willReturn(true); // MethodProphecyException: "has a void return type"
```

--------------------------------

### LogicalAndToken usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument-tokens-array.md

Shows how to use Argument::allOf with type and not tokens to score arguments. The token returns the maximum score of inner tokens when all pass, and false if any fails.

```php
$token = \Prophecy\Argument::allOf(\Prophecy\Argument::type('int'), \Prophecy\Argument::not(5));
$token->scoreArgument(7);   // max(5, 4) = 5
$token->scoreArgument(5);   // false (not(5) fails)
$token->scoreArgument('a'); // false (type fails)
```

--------------------------------

### ThrowPromise usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/promises.md

Shows throwing by class name and by instance. Class name 'RuntimeException' throws that exception. Instance of DomainException is thrown as-is with message 'boom'.

```php
$promise = new \Prophecy\Promise\ThrowPromise('RuntimeException');
$promise->execute([], $prophecy, $mp); // throws RuntimeException

$promise = new \Prophecy\Promise\ThrowPromise(new \DomainException('boom'));
try {
    $promise->execute([], $prophecy, $mp);
} catch (\DomainException $e) {
    echo $e->getMessage(); // "boom"
}
```

--------------------------------

### Typical internal usage in MagicCallPatch::apply

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/phpdocumentor.md

Shows how to instantiate ClassAndInterfaceTagRetriever and iterate over retrieved tags to get method names and static flags.

```php
// typical internal usage (MagicCallPatch::apply):
$retriever = new \Prophecy\PhpDocumentor\ClassAndInterfaceTagRetriever();
$tags = $retriever->getTagList(new \ReflectionClass(\App\MagicService::class));
foreach ($tags as $tag) {
    $methodName = $tag->getMethodName();        // e.g. "findByEmail"
    $isStatic   = $tag->isStatic();
}
```

--------------------------------

### ReturnTypeNode usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/generator-argument-nodes.md

Shows how to instantiate ReturnTypeNode with a BuiltinType('void') and call hasReturnStatement() and isVoid(). hasReturnStatement() returns false for void, while isVoid() returns true.

```php
$rt = new \Prophecy\Doubler\Generator\Node\ReturnTypeNode(
    new \Prophecy\Doubler\Generator\Node\Type\BuiltinType('void')
);
$rt->hasReturnStatement(); // false
$rt->isVoid();             // true
```

--------------------------------

### ArrayEveryEntryToken usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument-tokens-array.md

Shows how to use Argument::withEveryEntry('x') to create a token and score arguments. The token scores 10.0 for an array of matching values, and false if any entry does not match.

```php
$token = \Prophecy\Argument::withEveryEntry('x');
$token->scoreArgument(['x', 'x']);         // 10.0
$token->scoreArgument(['x', 'y']);         // false
```

--------------------------------

### StringContainsToken usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument-tokens-value.md

Shows how to use Argument::containingString('@example.com') to create a token. scoreArgument returns 6 for a string containing the substring, false otherwise. getValue returns the preset substring.

```php
$token = \Prophecy\Argument::containingString('@example.com');
$token->scoreArgument('john@example.com'); // 6
$token->scoreArgument('john@other.org');   // false
$token->getValue();                        // "@example.com"
```

--------------------------------

### ApproximateValueToken usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument-tokens-value.md

Usage example for ApproximateValueToken created by Argument::approximate(3.14159, 2). scoreArgument returns 10 for 3.14 (rounds to 3.14) and false for 3.145 (rounds to 3.15).

```php
$token = \Prophecy\Argument::approximate(3.14159, 2);
$token->scoreArgument(3.14);    // 10
$token->scoreArgument(3.145);   // false (rounds to 3.15)
```

--------------------------------

### Using Argument::cetera() with ArgumentsWildcard

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument-tokens-match.md

Creates a wildcard with a type token and cetera token. scoreArguments returns 7 for the example call, ignoring the rest after the first argument.

```php
$wildcard = new \Prophecy\Argument\ArgumentsWildcard(
    [\Prophecy\Argument::type('string'), \Prophecy\Argument::cetera()]
);
$wildcard->scoreArguments(['go', 1, 2, 3]); // 5 + 2 = 7 (rest ignored)
```

--------------------------------

### NameGenerator usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/doubler.md

Shows how to instantiate NameGenerator and call name() with different arguments. The first call with null and empty array returns "Double\stdClass\P1", the second with a ReflectionClass for 'App\Foo' returns "Double\App\Foo\P2".

```php
$namer = new \Prophecy\Doubler\NameGenerator();
$namer->name(null, []);                        // "Double\stdClass\P1"
$namer->name(new \ReflectionClass('App\Foo'), []); // "Double\App\Foo\P2"
```

--------------------------------

### getDoubler() usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/prophet.md

Retrieves the Doubler instance and accesses its class patches.

```php
$prophet = new \Prophecy\Prophet();
$doubler = $prophet->getDoubler();
$patches = $doubler->getClassPatches(); // the 8 default patches
```

--------------------------------

### Using Argument::withEntry(), containing(), and withKey()

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument-tokens-array.md

Demonstrates creating tokens with Argument::withEntry('role', 'admin'), Argument::containing('urgent'), and Argument::withKey('id'). Shows scoreArgument results and how getKey()/getValue() return ExactValueToken instances.

```php
$token = \Prophecy\Argument::withEntry('role', 'admin');
$token->scoreArgument(['role' => 'admin']);        // 8  (exact+exact → min(8, (10+10)/2))
$token->scoreArgument(['role' => 'guest']);        // false

\Prophecy\Argument::containing('urgent');          // entry whose value contains 'urgent'
\Prophecy\Argument::withKey('id');                 // entry with key 'id'

$token->getKey();   // ExactValueToken('role')
$token->getValue(); // ExactValueToken('admin')
```

--------------------------------

### Create a Prophet instance

Source: https://github.com/phpspec/prophecy/blob/master/README.md

Instantiates the Prophecy\Prophet class, which is the entry point for creating object prophecies.

```php
$prophet = new Prophecy\Prophet;
```

--------------------------------

### willExtend usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/object-prophecy.md

Calls willExtend with 'stdClass' to make the double extend that class.

```php
$prophecy->willExtend('stdClass');
```

--------------------------------

### makeProphecyMethodCall usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/object-prophecy.md

Calls the prophecy method with given arguments and returns the revealed value.

```php
$value = $prophecy->makeProphecyMethodCall('get', ['id']);
```

--------------------------------

### ExactValueToken::__construct

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/configuration.md

Creates a token that matches an exact value, with optional object comparison utilities.

```APIDOC
## ExactValueToken::__construct

### Description
Creates a token that matches an exact value, with optional object comparison utilities.

### Method
ExactValueToken::__construct

### Parameters
- **$value** (mixed) - Required - The exact value to match.
- **$util** (?StringUtil) - Optional - String utility for comparison.
- **$comparatorFactory** (?ComparatorFactory) - Optional - Factory for object comparison.
```

--------------------------------

### ObjectType usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/generator-types.md

Shows instantiation with 'App\\Foo'. echo outputs '\App\Foo', getType returns 'App\Foo'.

```php
$foo = new \Prophecy\Doubler\Generator\Node\Type\ObjectType('App\\Foo');
echo $foo;      // "\App\Foo"
$foo->getType(); // "App\Foo"
```

--------------------------------

### Creating and configuring a MethodNode

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/generator-nodes.md

Shows how to instantiate a MethodNode with a name and body, set visibility, static flag, and return type, then retrieve the code or use parent code. The getCode() method returns the body, and useParentCode() changes the body to call the parent method.

```php
$method = new \Prophecy\Doubler\Generator\Node\MethodNode('save', 'return true;');
$method->setVisibility('protected');
$method->setStatic();
$method->setReturnTypeNode(new \Prophecy\Doubler\Generator\Node\ReturnTypeNode(
    new \Prophecy\Doubler\Generator\Node\Type\BuiltinType('bool')
));
$method->getCode();            // "return true;"
$method->useParentCode();      // body becomes "return parent::save();"
```

--------------------------------

### Get registered class patches

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/doubler.md

Returns registered patches in currently sorted (descending priority) order.

```php
$doubler = new \Prophecy\Doubler\Doubler();
$patches = $doubler->getClassPatches();
```

--------------------------------

### Basic Prophecy Usage Pattern

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/README.md

Shows the top-level usage pattern for creating a prophecy, revealing it, setting a return value, and checking predictions in tearDown().

```php
use Prophecy\Prophet;

$prophet  = new Prophet();
$prophecy = $prophet->prophesize('App\Security\Hasher');
$hasher   = $prophecy->reveal();

$prophecy->generateHash($user, 'qwerty')->willReturn('hashed_pass');

// ... exercise $hasher ...

// in tearDown():
$prophet->checkPredictions();
```

--------------------------------

### Create a stub with willReturn

Source: https://github.com/phpspec/prophecy/blob/master/README.md

Creates a stub by making an arbitrary call on the prophecy and using willReturn to define the return value. The call returns a MethodProphecy instance.

```php
$prophecy->read('123')->willReturn('value');
```

--------------------------------

### Prophecy\Prophet::__construct()

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/configuration.md

Constructor for the main entry point of Prophecy. It initializes the Prophet with optional custom doubler, revealer, and string utility instances.

```APIDOC
## Constructor: Prophecy\Prophet::__construct()

### Description
Creates a new Prophet instance, the main entry point for object prophecy. Allows customization of the doubler, revealer, and string utility used for error messages.

### Method
Constructor

### Signature
```php
public function __construct(
    ?Doubler $doubler = null,
    ?RevealerInterface $revealer = null,
    ?StringUtil $util = null
)
```

### Parameters
- `$doubler` (?Doubler) - Optional - Default: `new CachedDoubler()` pre-registered with 8 class patches: `SplFileInfoPatch`, `TraversablePatch`, `ThrowablePatch`, `DisableConstructorPatch`, `ProphecySubjectPatch`, `ReflectionClassNewInstancePatch`, `MagicCallPatch`, `KeywordPatch`. The double generator. Inject a customized `Doubler` (e.g. with extra `ClassPatchInterface` registrations) to alter double behavior globally.
- `$revealer` (?RevealerInterface) - Optional - Default: `new Revealer()`. Unwraps `ProphecyInterface` values found in method-call arguments/return values into their doubles.
- `$util` (?StringUtil) - Optional - Default: `new StringUtil()`. Used for argument stringification in error messages.

### Example
```php
// Customizing the doubler via constructor injection
$doubler = new \Prophecy\Doubler\Doubler();
$doubler->registerClassPatch(new MyCustomPatch());
$prophet = new \Prophecy\Prophet($doubler);
```
```

--------------------------------

### ClassCodeGenerator::generate() usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/generator.md

Generates PHP source code for a double class without executing it.

```php
$code = (new \Prophecy\Doubler\Generator\ClassCodeGenerator())->generate('Double\X\P1', $node);
// string of PHP source (not executed)
```

--------------------------------

### CallbackToken::__construct

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/configuration.md

Creates a token that uses a callback for comparison, with an optional custom string representation.

```APIDOC
## CallbackToken::__construct

### Description
Creates a token that uses a callback for comparison, with an optional custom string representation.

### Method
CallbackToken::__construct

### Parameters
- **$callback** (callable) - Required - The callback to use.
- **$customStringRepresentation** (?string) - Optional - Overrides __toString(). Defaults to null.
```

--------------------------------

### Usage inside a prophecy (all of them)

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument-tokens-value.md

Demonstrates how to use all argument tokens within a prophecy registration. Shows the expected return values for each token type.

```APIDOC
## Usage inside a prophecy (all of them)

### Description
Demonstrates usage of all argument tokens within a prophecy registration.

### Example
```php
use Prophecy\Argument;

$prophecy->register(Argument::exact('a'))->willReturn(1);
$prophecy->register(Argument::is('a'))->willReturn(2);      // identical wins (11 > 10)
$prophecy->register(Argument::containingString('a'))->willReturn(3);
$prophecy->register(Argument::in(['x', 'y']))->willReturn(4);
$prophecy->register(Argument::notIn(['z']))->willReturn(5);
$prophecy->register(Argument::approximate(0.5, 1))->willReturn(6);
```
```

--------------------------------

### Promise selection shortcuts

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/promises.md

Demonstrates the full set of promise shortcuts: willReturn for fixed values, willReturnArgument to echo an argument, willThrow to throw an exception, and will with a callable for arbitrary logic.

```php
// full set
$prophecy->status()->willReturn('ok');
$prophecy->ping(Argument::any())->willReturnArgument(0);
$prophecy->fail()->willThrow(new \LogicException('nope'));
$prophecy->transform('x')->will(fn ($args) => strrev($args[0]));
```

--------------------------------

### NoCallsPrediction usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/predictions.md

Shows how to instantiate and call NoCallsPrediction. Throws UnexpectedCallsException on failure, with message using 'was'/'were' for 1/many calls.

```php
$prediction = new \Prophecy\Prediction\NoCallsPrediction();
$prediction->check([$someCall], $prophecy, $mp);
// UnexpectedCallsException: "No calls expected that match: ... but 1 was made: ..."
```

--------------------------------

### MethodProphecy::willReturnArgument

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/configuration.md

Returns the call's Nth argument, or null when missing.

```APIDOC
## MethodProphecy::willReturnArgument

### Description
Returns the call's Nth argument, or null when missing.

### Method
MethodProphecy::willReturnArgument

### Parameters
- **$index** (int) - Optional - The 0-based argument index. Defaults to 0.
```

--------------------------------

### Prophecy\Prophet::__construct() signature

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/configuration.md

Main entry point constructor with optional Doubler, RevealerInterface, and StringUtil parameters. Defaults: new CachedDoubler() pre-registered with 8 class patches, new Revealer(), and new StringUtil().

```php
public function __construct(
    ?Doubler $doubler = null,
    ?RevealerInterface $revealer = null,
    ?StringUtil $util = null
)
```

--------------------------------

### FactoryProvider usage

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/comparator.md

Retrieves the singleton factory instance; the same instance is returned on every call.

```php
$factory = \Prophecy\Comparator\FactoryProvider::getInstance();
// same instance on every call
```

--------------------------------

### Returning different values per call with willReturn

Source: https://github.com/phpspec/prophecy/blob/master/README.md

Shows the syntax to return different values for each call when a method is called several times. Note: not recommended for most cases as it makes tests fragile.

```php
$prophecy->read('123')->willReturn(1, 2, 3);
```

--------------------------------

### Argument class method signatures

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument.md

Lists all static factory methods of Prophecy\Argument with their parameters and return token types. Use as a quick reference for available argument matching tokens.

```php
class Argument
{
    public static function exact($value);                                    // Token\ExactValueToken
    public static function type($type);                                      // Token\TypeToken
    public static function which($methodName, $value);                       // Token\ObjectStateToken
    public static function that($callback, ?string $customStringRepresentation = null); // Token\CallbackToken
    public static function any();                                            // Token\AnyValueToken
    public static function cetera();                                         // Token\AnyValuesToken
    public static function allOf(...$tokens);                                // Token\LogicalAndToken
    public static function size($value);                                     // Token\ArrayCountToken
    public static function withEntry($key, $value);                          // Token\ArrayEntryToken
    public static function withEveryEntry($value);                           // Token\ArrayEveryEntryToken
    public static function containing($value);                               // Token\ArrayEntryToken (any key)
    public static function withKey($key);                                    // Token\ArrayEntryToken (any value)
    public static function not($value);                                      // Token\LogicalNotToken
    public static function containingString($value);                         // Token\StringContainsToken
    public static function is($value);                                       // Token\IdenticalValueToken
    public static function approximate($value, $precision = 0);              // Token\ApproximateValueToken
    public static function in($value);                                       // Token\InArrayToken
    public static function notIn($value);                                    // Token\NotInArrayToken
}
```

--------------------------------

### CallTimesPrediction usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/predictions.md

Shows how to instantiate and call CallTimesPrediction with an expected count of 3. Catches UnexpectedCallsCountException and accesses expected count and recorded calls.

```php
$prediction = new \Prophecy\Prediction\CallTimesPrediction(3);

try {
    $prediction->check([], $prophecy, $mp);
} catch (\Prophecy\Exception\Prediction\UnexpectedCallsCountException $e) {
    echo $e->getExpectedCount();  // 3
    $e->getCalls();               // list<Call>
}
```

--------------------------------

### ArgumentsWildcard class constructor

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument.md

Defines the ArgumentsWildcard class with a private token list and memoized string. The constructor converts every non-token value into an ExactValueToken.

```php
class ArgumentsWildcard
{
    /** @var list<Token\TokenInterface> */
    private $tokens = array();
    /** @var string|null */
    private $string;

    /**
     * Initializes wildcard.
     *
     * @param array<mixed> $arguments Array of argument tokens or values
     */
    public function __construct(array $arguments)
}
```

--------------------------------

### Argument::exact shortcut for exact value token

Source: https://github.com/phpspec/prophecy/blob/master/README.md

Uses the Prophecy\Argument shortcut class to create an exact value token, providing a more readable alternative to the full token class.

```php
use Prophecy\Argument;

$user->setName(Argument::exact('everzet'));
```

--------------------------------

### Using ReturnTypeNode with UnionType

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/generator-argument-nodes.md

Example of creating a ReturnTypeNode with a union type containing null and int, then checking nullability and echoing the type string.

```php
$node = new \Prophecy\Doubler\Generator\Node\ReturnTypeNode(
    new \Prophecy\Doubler\Generator\Node\Type\UnionType([
        new \Prophecy\Doubler\Generator\Node\Type\BuiltinType('null'),
        new \Prophecy\Doubler\Generator\Node\Type\BuiltinType('int'),
    ])
);
$node->getType();        // UnionType
$node->isNullable();     // true
echo $node->getType();   // "null|int"
```

--------------------------------

### BuiltinType usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/generator-types.md

Shows creating a BuiltinType for 'int', calling getType() to return 'int', and equals() returning true when compared to another BuiltinType with the same name.

```php
$int = new \Prophecy\Doubler\Generator\Node\Type\BuiltinType('int');
$int->getType();            // "int"
$int->equals(new BuiltinType('int'));  // true
```

--------------------------------

### __construct(?Doubler $doubler = null, ?RevealerInterface $revealer = null, ?StringUtil $util = null)

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/prophet.md

Constructs a new Prophet instance. The constructor accepts optional dependencies for the doubler, revealer, and string utility, with sensible defaults provided.

```APIDOC
## __construct(?Doubler $doubler = null, ?RevealerInterface $revealer = null, ?StringUtil $util = null)

### Description
Constructs a new Prophet instance. The constructor accepts optional dependencies for the doubler, revealer, and string utility, with sensible defaults provided.

### Method
Constructor

### Parameters
- **$doubler** (?Doubler) - Optional - Double generator used for every prophecy created by this Prophet. Default: `CachedDoubler` + 8 patches.
- **$revealer** (?RevealerInterface) - Optional - Unwraps prophecies inside argument/return values. Default: `new Revealer()`.
- **$util** (?StringUtil) - Optional - Stringifier for error messages. Default: `new StringUtil()`.

### Returns
Constructed `Prophet` instance.

### Example
```php
$prophet = new \Prophecy\Prophet();                    // defaults

$custom = new \Prophecy\Prophet(
    new \Prophecy\Doubler\CachedDoubler(),             // custom doubler
    new \Prophecy\Prophecy\Revealer(),                 // custom revealer
    new \Prophecy\Util\StringUtil(false)               // non-verbose stringifier
);
```
```

--------------------------------

### Direct construction with MethodNotFoundException

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/method-prophecy.md

Directly constructs a MethodProphecy for an unknown method 'nope', catching the MethodNotFoundException and echoing the method name. Demonstrates the error case when the method does not exist on the double.

```php
// direct construction (error case: unknown method)
try {
    $mp = new \Prophecy\Prophecy\MethodProphecy($prophecy, 'nope', []);
} catch (\Prophecy\Exception\Doubler\MethodNotFoundException $e) {
    echo $e->getMethodName(); // "nope"
}
```

--------------------------------

### Using LazyDouble to create a double with parent, interface, and arguments

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/doubler.md

Shows how to configure a LazyDouble with a parent class, an interface, and constructor arguments, then call getInstance() to create the double once. Subsequent calls return the cached instance.

```php
$lazy = new \Prophecy\Doubler\LazyDouble($doubler);
$lazy->setParentClass('App\Entity\User');
$lazy->addInterface('JsonSerializable');
$lazy->setArguments(['John', 30]);
$double = $lazy->getInstance();
```

--------------------------------

### Defining complex behaviors with promises

Source: https://github.com/phpspec/prophecy/blob/master/README.md

Shows how to use promises to change behavior of other method calls. Includes PHP 5.4 closure syntax and two PHP 5.3 alternatives.

```php
$user->getName()->willReturn(null);

// For PHP 5.4
$user->setName('everzet')->will(function () {
    $this->getName()->willReturn('everzet');
});

// For PHP 5.3
$user->setName('everzet')->will(function ($args, $user) {
    $user->getName()->willReturn('everzet');
});

// Or
$user->setName('everzet')->will(function ($args) use ($user) {
    $user->getName()->willReturn('everzet');
});
```

--------------------------------

### NotInArrayToken usage example

Source: https://github.com/phpspec/prophecy/blob/master/_autodocs/api-reference/argument-tokens-value.md

Shows how to use Argument::notIn(['banned']) to create a token. scoreArgument returns 8 for an argument not in the list, and false for a value that is present.

```php
$token = \Prophecy\Argument::notIn(['banned']);
$token->scoreArgument('allowed'); // 8
$token->scoreArgument('banned');  // false
```
Tokens:
Raw