/**
  * @param \stdClass $responseBody
  *
  * @return Validator
  */
 protected function getValidator($responseBody)
 {
     $responseSchema = $this->schemaManager->getResponseSchema($this->path, $this->httpMethod, $this->httpCode);
     $validator = new Validator();
     $validator->check($responseBody, $responseSchema);
     return $validator;
 }

 protected function doValidation(Response $response)
 {
     $data = json_decode($response->getBody());
     if ($data === null) {
         throw new ValidationFailedException("The given JSON data can not be validated (last error: '" . $this->json_errors[json_last_error()] . "').");
     } else {
         $error = false;
         $messageParts = array();
         foreach ($this->jsonSchemaFiles as $jsonSchemaFile) {
             $factory = new Factory(null, null, Constraint::CHECK_MODE_TYPE_CAST | Constraint::CHECK_MODE_COERCE);
             $validator = new Validator($factory);
             $jsonSchemaObject = (object) json_decode(file_get_contents($jsonSchemaFile['jsonschemafileurl']));
             $validator->check($data, $jsonSchemaObject);
             if (!$validator->isValid()) {
                 $error = true;
                 $errorMessage = '';
                 foreach ($validator->getErrors() as $error) {
                     $errorMessage = $errorMessage . sprintf("[%s] %s\n", $error['property'], $error['message']);
                 }
                 $messageParts[] = $jsonSchemaFile['jsonschemafilename'] . ' - ' . $jsonSchemaFile['jsonschemafileurl'] . '(last error: ' . $errorMessage . ').';
             }
         }
         if ($error == true) {
             $message = 'JSON file (' . (string) $response->getUri() . ')  does not validate against the following JSON Schema files: ' . implode(", ", $messageParts);
             throw new ValidationFailedException($message);
         }
     }
 }

 /**
  * Check data against a given entity type from the schema
  *
  * @param array|object $data Data from the API. Associative arrays will be reparsed into objects
  * @param string $entity Entity type, from the schema
  */
 protected function checkEntityAgainstSchema($data, $entity)
 {
     $absolute_ref = self::SCHEMA_BASE . 'definitions/' . $entity;
     $schema = $this->retriever->retrieve($absolute_ref);
     if (is_array($data)) {
         // Data was decoded as an array instead of an object, reencode for
         // schema checking
         $data = json_decode(json_encode($data));
     }
     $validator = new Validator(Validator::CHECK_MODE_NORMAL, $this->retriever);
     $validator->check($data, $schema);
     if (!$validator->isValid()) {
         $message = "JSON does not validate against schema:\n";
         $i = 0;
         foreach ($validator->getErrors() as $error) {
             $i++;
             $message .= $i . ') ';
             if (!empty($error['property'])) {
                 $message .= sprintf("[%s] %s\n", $error['property'], $error['message']);
             } else {
                 $message .= $error['message'] . "\n";
             }
         }
         $this->fail($message);
     }
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $path = $input->getArgument('path');
     if (!$path) {
         $path = getcwd() . DIRECTORY_SEPARATOR . 'resolver.json';
     }
     if (!is_file($path)) {
         $output->writeln(sprintf('<error>The file "%s" does not exists.</error>', $path));
         return 1;
     }
     // Get the schema and data as objects:
     $schema = json_decode(file_get_contents(__DIR__ . '/../../resources/schema.json'));
     $data = json_decode(file_get_contents($path));
     // Validate:
     $validator = new Validator();
     $validator->check($data, $schema);
     if ($validator->isValid()) {
         $output->writeln($path . ' is valid');
         return 0;
     }
     $output->writeln(sprintf('<error>The file "%s" contains errors.</error>', $path));
     foreach ($validator->getErrors() as $error) {
         if ($error['property']) {
             $output->writeln(sprintf('- %s: %s', $error['property'], $error['message']));
         } else {
             $output->writeln(sprintf('- %s', $error['message']));
         }
     }
     return 1;
 }

 /**
  * @param string $schemaName
  */
 protected function assertJsonResponse($response, $statusCode = Response::HTTP_OK, $schemaName = null)
 {
     // Assert HTTP response status code
     $this->assertEquals($statusCode, $response->getStatusCode(), $response->getContent());
     $content = $response->getContent();
     $data = null;
     if ($content) {
         // Assert response is JSON content-type (unless response content is empty)
         $this->assertTrue($response->headers->contains('Content-Type', 'application/json'), $response->headers);
         // Parse the response body
         $data = json_decode($response->getContent());
     }
     // Validate JSON data with given schema
     if (null !== $schemaName) {
         $schemaUri = 'file://' . realpath(__DIR__ . '/../Resources/json_schemas/' . $schemaName . '.json');
         $retriever = new JsonSchema\Uri\UriRetriever();
         $schema = $retriever->retrieve($schemaUri);
         $validator = new JsonSchema\Validator();
         $validator->check($data, $schema);
         if (!$validator->isValid()) {
             $errorMessage = 'JSON response does not validate the schema';
             foreach ($validator->getErrors() as $error) {
                 $errorMessage .= sprintf("\n[%s] %s", $error['property'], $error['message']);
             }
             $this->fail($errorMessage);
         }
     }
     return $data;
 }

 public function parseSingleSchema($schemeSpec)
 {
     if ($schemeSpec === null) {
         throw new ParseException('scheme must not be empty');
     }
     if (!is_string($schemeSpec)) {
         throw new ParseException('scheme must be a string');
     }
     $schemaJson = json_decode($schemeSpec);
     if (json_last_error() == JSON_ERROR_NONE) {
         $schemeUri = $schemaJson->{'$schema'};
         $retriever = new \JsonSchema\Uri\UriRetriever();
         $scheme = $retriever->retrieve($schemeUri);
         $validator = new Validator();
         $validator->check($schemaJson, $scheme);
         if ($validator->isValid()) {
             $arrayScheme = json_decode($schemeSpec, true);
             unset($arrayScheme['$schema']);
             return $arrayScheme;
         } else {
             foreach ($validator->getErrors() as $error) {
                 echo sprintf("[%s] %s\n", $error['property'], $error['message']);
             }
         }
     }
 }

 /**
  * @inheritdoc
  */
 protected function additionalFailureDescription($other)
 {
     $other = $this->forceToObject($other);
     $validator = new Validator();
     $validator->check($other, $this->schema);
     return implode("\n", array_map(function ($error) {
         return $error['message'];
     }, $validator->getErrors()));
 }

 /**
  * @param $jsonStr
  * @return Validator
  */
 private static function initValidator($jsonStr)
 {
     /** @var $this JsonValidatableTrait */
     $validator = new Validator();
     $data = json_decode($jsonStr);
     $schema = static::jsonViceVersa(static::getJsonSchema());
     $validator->check($data, $schema);
     return $validator;
 }

 /**
  * @dataProvider getValidTests
  */
 public function testValidCases($input, $schema, $checkMode = Validator::CHECK_MODE_NORMAL)
 {
     $schema = json_decode($schema);
     $refResolver = new RefResolver(new UriRetriever());
     $refResolver->resolve($schema);
     $validator = new Validator($checkMode);
     $validator->check(json_decode($input), $schema);
     $this->assertTrue($validator->isValid(), print_r($validator->getErrors(), true));
 }

 public static function GetTestFiles()
 {
     $dir = dirname(dirname(__DIR__));
     $retriever = new UriRetriever();
     $schema = $retriever->retrieve('file://' . realpath($dir . '/schema/tests.json'));
     return new CallbackFilterIterator(new DirectoryIterator($dir . '/tests'), function (SplFileInfo $file) use($schema) {
         $validator = new Validator();
         return $file->isFile() && $file->isReadable() && preg_match('/\\.json$/', $file->getBasename()) && $validator->check($schema, json_decode(file_get_contents($file->getRealPath()))) == null && $validator->isValid();
     });
 }

 /**
  * Validates a json object
  *
  * @param string $json
  *
  * @throws \Exception
  *
  * @return boolean
  */
 public function validateJsonObject($json)
 {
     $validator = new Validator();
     $jsonSchema = $this->json;
     $validator->check($json, $jsonSchema);
     if (!$validator->isValid()) {
         throw new InvalidSchemaException($validator->getErrors());
     }
     return true;
 }

 private function check($json)
 {
     $schema = json_decode(file_get_contents(__DIR__ . '/../../../../res/composer-schema.json'));
     $validator = new Validator();
     $validator->check(json_decode($json), $schema);
     if (!$validator->isValid()) {
         return $validator->getErrors();
     }
     return true;
 }

 public function validateSchema($json, $schema)
 {
     $validator = new Validator();
     $validator->check(json_decode($json), json_decode($schema));
     if ($validator->isValid()) {
         return true;
     } else {
         return $validator->getErrors();
     }
 }

 /**
  * Zkontroluje data proti zadanému schématu
  *
  * @param array|\StdClass
  * @param string
  * @return bool
  */
 public function check($data, $schemaFile)
 {
     $validator = new Validator();
     $schema = $this->getSchema($schemaFile);
     $validator->check($data, Json::decode($schema));
     if ($validator->isValid()) {
         return TRUE;
     }
     $this->errors = $validator->getErrors();
     return FALSE;
 }

 /**
  * @param \stdClass $headers
  *
  * @return Validator
  */
 protected function getValidator($headers)
 {
     $schema = new \stdClass();
     $headers = (object) array_change_key_case((array) $headers, CASE_LOWER);
     $properties = $this->schemaManager->getResponseHeaders($this->path, $this->httpMethod, $this->httpCode);
     $schema->properties = (object) array_change_key_case((array) $properties, CASE_LOWER);
     $schema->required = array_keys((array) $schema->properties);
     $validator = new Validator();
     $validator->check($headers, $schema);
     return $validator;
 }

 /**
  * Tests right errors output.
  *
  * @covers ::displayErrors
  *
  * @return void
  */
 public function testDisplayErrors()
 {
     $validator = new Validator();
     $validator->addError(null, 'Foo');
     $validator->addError('subpath', 'Bar');
     $output = new StreamOutput(fopen('php://memory', 'r+'), StreamOutput::VERBOSITY_NORMAL, false);
     Utils::displayErrors($validator, $output);
     rewind($output->getStream());
     $this->assertStringEqualsFile(__DIR__ . '/fixtures/Utils/testDisplayErrors', stream_get_contents($output->getStream()));
     fclose($output->getStream());
 }

 /**
  * @param string $message
  * @return array
  */
 protected function validateMessage($message)
 {
     if (empty($message) === true) {
         return [];
     }
     $refResolver = new RefResolver(new UriRetriever(), new UriResolver());
     $schema = $refResolver->resolve('file://' . realpath(__DIR__ . "/json-api-schema.json"));
     $validator = new Validator();
     $validator->check(json_decode($message), $schema);
     return $validator->getErrors();
 }

 public function __construct(array $config)
 {
     $config += $this->default;
     $schema = file_get_contents(__DIR__ . '/../res/config-schema.json');
     $validator = new JsonSchema\Validator();
     $validator->check((object) $config, json_decode($schema));
     if (!$validator->isValid()) {
         throw new \InvalidArgumentException(var_export($validator->getErrors(), true));
     }
     $this->config = $config;
 }

 /**
  * @param Request $request
  *
  * @throws InvalidParametersException
  * @throws UnsupportedException
  */
 public function validateRequest(Request $request)
 {
     $validator = new Validator();
     $validator->check($this->assembleParameterDataForValidation($request), $this->assembleRequestSchema());
     if (!$validator->isValid()) {
         /**
          * TODO Better utilize $validator->getErrors() so we can assemble a more helpful vnd.error response
          * @see https://github.com/kleijnweb/swagger-bundle/issues/27
          */
         throw new InvalidParametersException("Parameters incompatible with operation schema: " . implode(', ', $validator->getErrors()[0]), 400);
     }
 }

 public function validate(Json $json, Validator $validator)
 {
     $validator->check($json->getContent(), $this->getContent());
     if (!$validator->isValid()) {
         $msg = "JSON does not validate. Violations:" . PHP_EOL;
         foreach ($validator->getErrors() as $error) {
             $msg .= sprintf("  - [%s] %s" . PHP_EOL, $error['property'], $error['message']);
         }
         throw new \Exception($msg);
     }
     return true;
 }