PHP InvalidArgumentException类代码示例

 public function validation($ruleName, $value)
 {
     Cascade::getLogger('bigc\\profile')->debug("ProfileData validation {$ruleName}, {$value}");
     try {
         $this->validRule[$ruleName]->assert($value);
     } catch (\Respect\Validation\Exceptions\NestedValidationException $ex) {
         $e = new \InvalidArgumentException($this->validMessage[$ruleName], 0, $ex);
         Cascade::getLogger('bigc\\profile')->warning($e->getMessage());
         throw $e;
     }
     return true;
 }

 /**
  * @covers Gloubster\Server\GloubsterServer::throwError
  */
 public function testThrowError()
 {
     $server = $this->getServer();
     $exception = new \InvalidArgumentException('SHIT');
     $server['monolog']->expects($this->once())->method('addError')->with($this->equalTo($exception->getMessage()));
     try {
         $server->throwError($exception);
         $this->fail('Should have raised an exception');
     } catch (\Exception $e) {
         $this->assertEquals($exception, $e);
     }
 }

 private function init($fileName)
 {
     if (!file_exists($fileName)) {
         throw InvalidArgumentException::fileNotExists($fileName);
     }
     $this->fileName = $fileName;
 }

 public function __construct($fileName)
 {
     if (!file_exists($fileName)) {
         throw InvalidArgumentException::fileNotExists($fileName);
     }
     $this->fileName = $fileName;
 }

 public function __construct($name, $value, $expected)
 {
     if (!is_string($name)) {
         throw new InvalidArgumentException("Not a string: name");
     }
     if (!is_string($expected)) {
         throw new InvalidArgumentException("Not a string: expected");
     }
     $lead = "Invalid";
     if (NULL === $value) {
         $lead = "Not set";
     }
     $type = gettype($value);
     $got_msg = $type;
     if (is_object($value)) {
         $class = get_class($value);
         $got_msg = "{$type} ({$class})";
     }
     $this->name = $name;
     $this->type = $type;
     $this->expected = $expected;
     $this->message = $msg;
     $msg = "{$lead}: {$name} - Got: {$got_msg} - Expected: {$expected}";
     parent::__construct($msg, 0);
 }

 public function __construct($message, array $errors, Exception $previous = null)
 {
     $flatErrors = iterator_to_array(new RecursiveIteratorIterator(new RecursiveArrayIterator($errors)), false);
     $message = $message . ":\n" . implode("\n", $flatErrors);
     parent::__construct($message, 0, $previous);
     $this->setErrors($errors);
 }

 /**
  * @param string|WeaponlikeCode $message
  * @param int $code
  * @param \Exception $previous
  */
 public function __construct($message = '', $code = 0, \Exception $previous = null)
 {
     if ($message instanceof WeaponlikeCode) {
         $message = "Given weapon-like '{$message}' is of unknown type";
     }
     parent::__construct($message, $code, $previous);
 }

 /**
  * Constructor.
  *
  * @param mixed        $value
  * @param string|array $expectedType
  */
 public function __construct($value, $expectedType)
 {
     if (is_array($expectedType)) {
         $expectedType = implode('", "', $expectedType);
     }
     parent::__construct(sprintf('Expected argument of type "%s", "%s" given', $expectedType, is_object($value) ? get_class($value) : gettype($value)));
 }

 public function __construct(\ReflectionParameter $parameter, $message = null, $code = null, \Exception $previous = null)
 {
     if (null === $message) {
         $message = sprintf('Unable to resolve argument $%s (#%d) of %s.', $parameter->name, $parameter->getPosition(), static::getFunctionName($parameter->getDeclaringFunction()));
     }
     parent::__construct($message, $code, $previous);
 }

 /**
  * @inheritdoc
  */
 public function __construct($message = '', $code = 0, \Exception $previous = null)
 {
     if (empty($message)) {
         $message = 'Invalid argument value.';
     }
     parent::__construct($message, $code, $previous);
 }

 /**
  * @param string $message
  * @param \Exception $previous
  */
 public function __construct($message = null, \Exception $previous = null)
 {
     if (empty($message)) {
         $message = 'Listeners must implements EventListenerInterface';
     }
     parent::__construct($message, $previous);
 }

 /**
  * {@inheritdoc}
  */
 public function __construct($inputCurrency, $allowedCurrencies = null)
 {
     if (null === $allowedCurrencies) {
         $allowedCurrencies = Environment::$ALLOWED_CURRENCIES;
     }
     parent::__construct(sprintf('Invalid currency given (%s), allowed: %s', $inputCurrency, implode(', ', $allowedCurrencies)));
 }

 public function __construct($message = "", $code = 0, Exception $previous = null)
 {
     if (empty($message)) {
         $message = 'The specified file pointer is not a valid stream resource';
     }
     parent::__construct($message, $code, $previous);
 }

 public function __construct($file, $line, $message)
 {
     parent::__construct();
     $this->file = $file;
     $this->line = $line;
     $this->message = $message;
 }

 public function __construct($message = null)
 {
     if ($message === null) {
         $message = 'The parameter must be a non empty string';
     }
     parent::__construct($message);
 }