class PHPUnit_Framework_MockObject_Matcher_ConsecutiveParameters in Zircon Profile 8.0

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.

Hierarchy

• class \PHPUnit_Framework_MockObject_Matcher_StatelessInvocation implements PHPUnit_Framework_MockObject_Matcher_Invocation
  • class \PHPUnit_Framework_MockObject_Matcher_ConsecutiveParameters

File

vendor/phpunit/phpunit-mock-objects/src/Framework/MockObject/Matcher/ConsecutiveParameters.php, line 21

class PHPUnit_Framework_MockObject_Matcher_ConsecutiveParameters extends PHPUnit_Framework_MockObject_Matcher_StatelessInvocation {

  /**
   * @var array
   */
  private $_parameterGroups = array();

  /**
   * @var array
   */
  private $_invocations = array();

  /**
   * @param array $parameterGroups
   */
  public function __construct(array $parameterGroups) {
    foreach ($parameterGroups as $index => $parameters) {
      foreach ($parameters as $parameter) {
        if (!$parameter instanceof \PHPUnit_Framework_Constraint) {
          $parameter = new \PHPUnit_Framework_Constraint_IsEqual($parameter);
        }
        $this->_parameterGroups[$index][] = $parameter;
      }
    }
  }

  /**
   * @return string
   */
  public function toString() {
    $text = 'with consecutive parameters';
    return $text;
  }

  /**
   * @param  PHPUnit_Framework_MockObject_Invocation $invocation
   * @return bool
   */
  public function matches(PHPUnit_Framework_MockObject_Invocation $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  PHPUnit_Framework_MockObject_Invocation      $invocation
   * @param  int                                          $callIndex
   * @throws PHPUnit_Framework_ExpectationFailedException
   */
  private function verifyInvocation(PHPUnit_Framework_MockObject_Invocation $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 PHPUnit_Framework_ExpectationFailedException('Mocked method does not exist.');
    }
    if (count($invocation->parameters) < count($parameters)) {
      throw new PHPUnit_Framework_ExpectationFailedException(sprintf('Parameter count for invocation %s is too low.', $invocation
        ->toString()));
    }
    foreach ($parameters as $i => $parameter) {
      $parameter
        ->evaluate($invocation->parameters[$i], sprintf('Parameter %s for invocation #%d %s does not match expected ' . 'value.', $i, $callIndex, $invocation
        ->toString()));
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
PHPUnit_Framework_MockObject_Matcher_ConsecutiveParameters::$_invocations	private	property
PHPUnit_Framework_MockObject_Matcher_ConsecutiveParameters::$_parameterGroups	private	property
PHPUnit_Framework_MockObject_Matcher_ConsecutiveParameters::matches	public	function	Overrides PHPUnit_Framework_MockObject_Matcher_Invocation::matches
PHPUnit_Framework_MockObject_Matcher_ConsecutiveParameters::toString	public	function	Overrides PHPUnit_Framework_SelfDescribing::toString
PHPUnit_Framework_MockObject_Matcher_ConsecutiveParameters::verify	public	function	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. Overrides PHPUnit_Framework_MockObject_Matcher_StatelessInvocation::verify
PHPUnit_Framework_MockObject_Matcher_ConsecutiveParameters::verifyInvocation	private	function	Verify a single invocation
PHPUnit_Framework_MockObject_Matcher_ConsecutiveParameters::__construct	public	function
PHPUnit_Framework_MockObject_Matcher_StatelessInvocation::invoked	public	function	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. Overrides PHPUnit_Framework_MockObject_Matcher_Invocation::invoked