PHP PresenterInterface::presentValue方法代码示例

 /**
  * Evaluates negative match.
  *
  * @param string $name
  * @param mixed  $subject
  * @param array  $arguments
  *
  * @throws \PhpSpec\Exception\Example\FailureException
  * @return boolean
  */
 public function negativeMatch($name, $subject, array $arguments)
 {
     $checker = $this->getCheckerName($name);
     if (call_user_func($checker, $subject)) {
         throw new FailureException(sprintf('%s not expected to return %s, but it did.', $this->presenter->presentString(sprintf('%s(%s)', $checker, $this->presenter->presentValue($subject))), $this->presenter->presentValue(true)));
     }
 }

 /**
  * @param array $args
  *
  * @throws \PhpSpec\Exception\Wrapper\SubjectException
  */
 public function beConstructedWith($args)
 {
     if (null === $this->classname) {
         throw new SubjectException(sprintf('You can not set object arguments. Behavior subject is %s.', $this->presenter->presentValue(null)));
     }
     $this->beAnInstanceOf($this->classname, $args);
 }

 /**
  * @param $keyword
  * @param $subject
  * @param  array                                               $arguments
  * @return mixed
  * @throws \PhpSpec\Exception\Wrapper\MatcherNotFoundException
  */
 public function find($keyword, $subject, array $arguments)
 {
     foreach ($this->matchers as $matcher) {
         if (true === $matcher->supports($keyword, $subject, $arguments)) {
             return $matcher;
         }
     }
     throw new MatcherNotFoundException(sprintf('No %s(%s) matcher found for %s.', $this->presenter->presentString($keyword), $this->presenter->presentValue($arguments), $this->presenter->presentValue($subject)), $keyword, $subject, $arguments);
 }

 /**
  * @param array $args
  *
  * @throws \PhpSpec\Exception\Wrapper\SubjectException
  */
 public function beConstructedWith($args)
 {
     if (null === $this->classname) {
         throw new SubjectException(sprintf('You can not set object arguments. Behavior subject is %s.', $this->presenter->presentValue(null)));
     }
     if ($this->isInstantiated()) {
         throw new SubjectException('You can not change object construction method when it is already instantiated');
     }
     $this->beAnInstanceOf($this->classname, $args);
 }

 /**
  * @param mixed $subject
  * @param array $arguments
  *
  * @return boolean
  */
 protected function matches($subject, array $arguments)
 {
     if (!$this->isRestViewObject($subject)) {
         $this->exception = new FailureException(sprintf('Expected %s to be an instance of FOS\\RestBundle\\View\\View', $this->presenter->presentValue($subject)));
         return false;
     }
     /** @var View $subject */
     $argument = isset($arguments[0]) ? $arguments[0] : [];
     if (!$this->dataMatches($subject, $argument)) {
         $this->exception = new FailureException(sprintf('Expected %s to be a data of the View, but it is not. Instead got: %s', $this->presenter->presentValue($argument['data']), $this->presenter->presentValue($subject->getData())));
         return false;
     }
     if (!$this->statusCodeMatches($subject, $argument)) {
         $this->exception = new FailureException(sprintf('Expected %s to be a status code of the View, but it is not. Instead got: %s', $this->presenter->presentValue($argument['statusCode']), $this->presenter->presentValue($subject->getStatusCode())));
         return false;
     }
     if (!$this->headersMatches($subject, $argument)) {
         $this->exception = new FailureException(sprintf('Expected headers to be %s, but it is not. Instead got: %s. Details: %s', $this->presenter->presentValue($argument['headers']), $this->presenter->presentValue($subject->getHeaders()), $this->matcher->getError()));
         return false;
     }
     if (!$this->serializationGroupsMatches($subject, $argument)) {
         $this->exception = new FailureException(sprintf('Expected serialization group to be %s, but they are not', empty($argument['serializationGroups']) ? 'empty (it\'s impossible!)' : implode(', ', $argument['serializationGroups'])));
         return false;
     }
 }

 /**
  * @param callable $callable
  * @param array $arguments
  * @param string|null $exception
  *
  * @throws \PhpSpec\Exception\Example\FailureException
  */
 public function verifyNegative($callable, array $arguments, $exception = null)
 {
     try {
         call_user_func_array($callable, $arguments);
     } catch (\Exception $e) {
         if (null === $exception) {
             throw new FailureException(sprintf('Expected to not throw any exceptions, but got %s.', $this->presenter->presentValue($e)));
         }
         if ($e instanceof $exception) {
             $invalidProperties = array();
             if (is_object($exception)) {
                 $exceptionRefl = $this->factory->create($exception);
                 foreach ($exceptionRefl->getProperties() as $property) {
                     if (in_array($property->getName(), self::$ignoredProperties)) {
                         continue;
                     }
                     $property->setAccessible(true);
                     $expected = $property->getValue($exception);
                     $actual = $property->getValue($e);
                     if (null !== $expected && $actual === $expected) {
                         $invalidProperties[] = sprintf('  `%s`=%s', $property->getName(), $this->presenter->presentValue($expected));
                     }
                 }
             }
             $withProperties = '';
             if (count($invalidProperties) > 0) {
                 $withProperties = sprintf(' with' . PHP_EOL . '%s,' . PHP_EOL, implode(",\n", $invalidProperties));
             }
             throw new FailureException(sprintf('Expected to not throw %s exception%s but got it.', $this->presenter->presentValue($exception), $withProperties));
         }
     }
 }

 function let(PresenterInterface $presenter)
 {
     $presenter->presentValue(Argument::any())->willReturn('val');
     $presenter->presentString(Argument::any())->willReturnArgument();
     $this->beConstructedWith('custom', function () {
     }, $presenter);
 }

 /**
  * @param string $classname
  * @param array $arguments
  *
  * @throws \PhpSpec\Exception\Wrapper\SubjectException
  */
 public function beAnInstanceOf($classname, array $arguments = array())
 {
     if (!is_string($classname)) {
         throw new SubjectException(sprintf('Behavior subject classname should be a string, %s given.', $this->presenter->presentValue($classname)));
     }
     $this->classname = $classname;
     $unwrapper = new Unwrapper();
     $this->arguments = $unwrapper->unwrapAll($arguments);
     $this->isInstantiated = false;
     $this->factoryMethod = null;
 }

 /**
  * @param string $name
  * @param mixed $subject
  * @param array $arguments
  *
  * @throws \PhpSpec\Exception\Example\FailureException
  * @throws \PhpSpec\Exception\Fracture\MethodNotFoundException
  */
 public function negativeMatch($name, $subject, array $arguments)
 {
     preg_match(self::$regex, $name, $matches);
     $method = ('be' === $matches[1] ? 'is' : 'has') . ucfirst($matches[2]);
     $callable = array($subject, $method);
     if (!method_exists($subject, $method)) {
         throw new MethodNotFoundException(sprintf('Method %s not found.', $this->presenter->presentValue($callable)), $subject, $method, $arguments);
     }
     if (false !== ($result = call_user_func_array($callable, $arguments))) {
         throw $this->getFailureExceptionFor($callable, false, $result);
     }
 }

 /**
  *
  * @param array $arguments        	
  *
  * @return null|string
  * @throws \PhpSpec\Exception\Example\MatcherException
  */
 private function getException(array $arguments)
 {
     if (0 == count($arguments)) {
         return null;
     }
     if (is_string($arguments[0])) {
         return $arguments[0];
     }
     if (is_object($arguments[0]) && $arguments[0] instanceof \Exception) {
         return $arguments[0];
     }
     throw new MatcherException(sprintf("Wrong argument provided in throw matcher.\n" . "Fully qualified classname or exception instance expected,\n" . "Got %s.", $this->presenter->presentValue($arguments[0])));
 }

 function let(PresenterInterface $presenter)
 {
     $presenter->presentValue(Argument::any())->will(function ($subject) {
         if (is_array($subject[0])) {
             return 'array';
         }
         if (is_object($subject[0])) {
             return 'object';
         }
         return $subject[0];
     });
     $presenter->presentString(Argument::any())->willReturnArgument();
     $this->beConstructedWith($presenter);
 }

 /**
  * @param string $name
  * @param mixed  $subject
  * @param array  $arguments
  *
  * @return FailureException
  */
 protected function getNegativeFailureException($name, $subject, array $arguments)
 {
     return new FailureException(sprintf('Did not expect %s relationship on %s but got %s', $this->presenter->presentString($arguments[0]), $this->presenter->presentString($arguments[1]), $this->presenter->presentValue($subject)));
 }

 /**
  * @param string $name
  * @param mixed  $subject
  * @param array  $arguments
  *
  * @return FailureException
  */
 protected function getNegativeFailureException($name, $subject, array $arguments)
 {
     return new FailureException(sprintf('Did not expect %s, but got one.', $this->presenter->presentValue($subject)));
 }

 function let(PresenterInterface $presenter)
 {
     $presenter->presentValue(Argument::any())->willReturn('countable');
     $presenter->presentString(Argument::any())->willReturnArgument();
     $this->beConstructedWith($presenter);
 }

 /**
  * @param string $name
  * @param mixed  $subject
  * @param array  $arguments
  *
  * @return FailureException
  */
 protected function getNegativeFailureException($name, $subject, array $arguments)
 {
     return new FailureException(sprintf('Expected %s not to contain %s, but it does.', $this->presenter->presentValue($subject), $this->presenter->presentValue($arguments[0])));
 }