summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--chrome/chrome_common.gypi2
-rw-r--r--chrome/chrome_tests.gypi3
-rw-r--r--chrome/common/json_schema_validator.cc503
-rw-r--r--chrome/common/json_schema_validator.h211
-rw-r--r--chrome/common/json_schema_validator_unittest.cc51
-rw-r--r--chrome/common/json_schema_validator_unittest_base.cc628
-rw-r--r--chrome/common/json_schema_validator_unittest_base.h59
-rw-r--r--chrome/test/data/json_schema_validator/array_tuple_schema.json11
-rw-r--r--chrome/test/data/json_schema_validator/choices_schema.json7
-rw-r--r--chrome/test/data/json_schema_validator/complex_instance.json9
-rw-r--r--chrome/test/data/json_schema_validator/complex_schema.json33
-rw-r--r--chrome/test/data/json_schema_validator/enum_schema.json3
-rw-r--r--chrome/test/data/json_schema_validator/reference_types.json12
13 files changed, 1532 insertions, 0 deletions
diff --git a/chrome/chrome_common.gypi b/chrome/chrome_common.gypi
index 1437c1e..28924ca 100644
--- a/chrome/chrome_common.gypi
+++ b/chrome/chrome_common.gypi
@@ -257,6 +257,8 @@
'common/important_file_writer.h',
'common/json_pref_store.cc',
'common/json_pref_store.h',
+ 'common/json_schema_validator.cc',
+ 'common/json_schema_validator.h',
'common/jstemplate_builder.cc',
'common/jstemplate_builder.h',
'common/libxml_utils.cc',
diff --git a/chrome/chrome_tests.gypi b/chrome/chrome_tests.gypi
index fb2a787..3755925 100644
--- a/chrome/chrome_tests.gypi
+++ b/chrome/chrome_tests.gypi
@@ -1562,6 +1562,9 @@
'common/gpu_messages_unittest.cc',
'common/important_file_writer_unittest.cc',
'common/json_pref_store_unittest.cc',
+ 'common/json_schema_validator_unittest_base.cc',
+ 'common/json_schema_validator_unittest_base.h',
+ 'common/json_schema_validator_unittest.cc',
'common/json_value_serializer_unittest.cc',
'common/mru_cache_unittest.cc',
'common/net/gaia/gaia_auth_fetcher_unittest.cc',
diff --git a/chrome/common/json_schema_validator.cc b/chrome/common/json_schema_validator.cc
new file mode 100644
index 0000000..ee28a89
--- /dev/null
+++ b/chrome/common/json_schema_validator.cc
@@ -0,0 +1,503 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/common/json_schema_validator.h"
+
+#include <cfloat>
+#include <cmath>
+
+#include "app/l10n_util.h"
+#include "base/string_number_conversions.h"
+#include "base/string_util.h"
+#include "base/values.h"
+
+namespace {
+
+double GetNumberValue(Value* value) {
+ double result = 0;
+ if (value->GetAsReal(&result))
+ return result;
+
+ int int_result = 0;
+ if (value->GetAsInteger(&int_result)) {
+ return int_result;
+ }
+
+ CHECK(false) << "Unexpected value type: " << value->GetType();
+ return 0;
+}
+
+bool GetNumberFromDictionary(DictionaryValue* value, const std::string& key,
+ double* number) {
+ if (value->GetReal(key, number))
+ return true;
+
+ int int_value = 0;
+ if (value->GetInteger(key, &int_value)) {
+ *number = int_value;
+ return true;
+ }
+
+ return false;
+}
+
+} // namespace
+
+
+JSONSchemaValidator::Error::Error() {
+}
+
+JSONSchemaValidator::Error::Error(const std::string& message)
+ : path(message) {
+}
+
+JSONSchemaValidator::Error::Error(const std::string& path,
+ const std::string& message)
+ : path(path), message(message) {
+}
+
+
+const char JSONSchemaValidator::kUnknownTypeReference[] =
+ "Unknown schema reference: *.";
+const char JSONSchemaValidator::kInvalidChoice[] =
+ "Value does not match any valid type choices.";
+const char JSONSchemaValidator::kInvalidEnum[] =
+ "Value does not match any valid enum choices.";
+const char JSONSchemaValidator::kObjectPropertyIsRequired[] =
+ "Property is required.";
+const char JSONSchemaValidator::kUnexpectedProperty[] =
+ "Unexpected property.";
+const char JSONSchemaValidator::kArrayMinItems[] =
+ "Array must have at least * items.";
+const char JSONSchemaValidator::kArrayMaxItems[] =
+ "Array must not have more than * items.";
+const char JSONSchemaValidator::kArrayItemRequired[] =
+ "Item is required.";
+const char JSONSchemaValidator::kStringMinLength[] =
+ "String must be at least * characters long.";
+const char JSONSchemaValidator::kStringMaxLength[] =
+ "String must not be more than * characters long.";
+const char JSONSchemaValidator::kStringPattern[] =
+ "String must match the pattern: *.";
+const char JSONSchemaValidator::kNumberMinimum[] =
+ "Value must not be less than *.";
+const char JSONSchemaValidator::kNumberMaximum[] =
+ "Value must not be greater than *.";
+const char JSONSchemaValidator::kInvalidType[] =
+ "Expected '*' but got '*'.";
+
+
+// static
+std::string JSONSchemaValidator::GetJSONSchemaType(Value* value) {
+ switch (value->GetType()) {
+ case Value::TYPE_NULL:
+ return "null";
+ case Value::TYPE_BOOLEAN:
+ return "boolean";
+ case Value::TYPE_INTEGER:
+ return "integer";
+ case Value::TYPE_REAL: {
+ double double_value = 0;
+ value->GetAsReal(&double_value);
+ if (std::abs(double_value) <= std::pow(2.0, DBL_MANT_DIG) &&
+ double_value == floor(double_value)) {
+ return "integer";
+ } else {
+ return "number";
+ }
+ }
+ case Value::TYPE_STRING:
+ return "string";
+ case Value::TYPE_DICTIONARY:
+ return "object";
+ case Value::TYPE_LIST:
+ return "array";
+ default:
+ CHECK(false) << "Unexpected value type: " << value->GetType();
+ return "";
+ }
+}
+
+// static
+std::string JSONSchemaValidator::FormatErrorMessage(const std::string& format,
+ const std::string& s1) {
+ std::string ret_val = format;
+ ReplaceFirstSubstringAfterOffset(&ret_val, 0, "*", s1);
+ return ret_val;
+}
+
+// static
+std::string JSONSchemaValidator::FormatErrorMessage(const std::string& format,
+ const std::string& s1,
+ const std::string& s2) {
+ std::string ret_val = format;
+ ReplaceFirstSubstringAfterOffset(&ret_val, 0, "*", s1);
+ ReplaceFirstSubstringAfterOffset(&ret_val, 0, "*", s2);
+ return ret_val;
+}
+
+JSONSchemaValidator::JSONSchemaValidator(DictionaryValue* schema)
+ : schema_root_(schema), default_allow_additional_properties_(false) {
+}
+
+JSONSchemaValidator::JSONSchemaValidator(DictionaryValue* schema,
+ ListValue* types)
+ : schema_root_(schema), default_allow_additional_properties_(false) {
+ if (!types)
+ return;
+
+ for (size_t i = 0; i < types->GetSize(); ++i) {
+ DictionaryValue* type = NULL;
+ CHECK(types->GetDictionary(i, &type));
+
+ std::string id;
+ CHECK(type->GetString("id", &id));
+
+ CHECK(types_.find(id) == types_.end());
+ types_[id] = type;
+ }
+}
+
+
+bool JSONSchemaValidator::Validate(Value* instance) {
+ errors_.clear();
+ Validate(instance, schema_root_, "");
+ return errors_.empty();
+}
+
+void JSONSchemaValidator::Validate(Value* instance,
+ DictionaryValue* schema,
+ const std::string& path) {
+ // If this schema defines itself as reference type, save it in this.types.
+ std::string id;
+ if (schema->GetString("id", &id)) {
+ TypeMap::iterator iter = types_.find(id);
+ if (iter == types_.end())
+ types_[id] = schema;
+ else
+ CHECK(iter->second == schema);
+ }
+
+ // If the schema has a $ref property, the instance must validate against
+ // that schema. It must be present in types_ to be referenced.
+ std::string ref;
+ if (schema->GetString("$ref", &ref)) {
+ TypeMap::iterator type = types_.find(ref);
+ if (type == types_.end()) {
+ errors_.push_back(
+ Error(path, FormatErrorMessage(kUnknownTypeReference, ref)));
+ } else {
+ Validate(instance, type->second, path);
+ }
+ return;
+ }
+
+ // If the schema has a choices property, the instance must validate against at
+ // least one of the items in that array.
+ ListValue* choices = NULL;
+ if (schema->GetList("choices", &choices)) {
+ ValidateChoices(instance, choices, path);
+ return;
+ }
+
+ // If the schema has an enum property, the instance must be one of those
+ // values.
+ ListValue* enumeration = NULL;
+ if (schema->GetList("enum", &enumeration)) {
+ ValidateEnum(instance, enumeration, path);
+ return;
+ }
+
+ std::string type;
+ schema->GetString("type", &type);
+ CHECK(!type.empty());
+ if (type != "any") {
+ if (!ValidateType(instance, type, path))
+ return;
+
+ // These casts are safe because of checks in ValidateType().
+ if (type == "object")
+ ValidateObject(static_cast<DictionaryValue*>(instance), schema, path);
+ else if (type == "array")
+ ValidateArray(static_cast<ListValue*>(instance), schema, path);
+ else if (type == "string")
+ ValidateString(static_cast<StringValue*>(instance), schema, path);
+ else if (type == "number" || type == "integer")
+ ValidateNumber(instance, schema, path);
+ else if (type != "boolean" && type != "null")
+ CHECK(false) << "Unexpected type: " << type;
+ }
+}
+
+void JSONSchemaValidator::ValidateChoices(Value* instance,
+ ListValue* choices,
+ const std::string& path) {
+ size_t original_num_errors = errors_.size();
+
+ for (size_t i = 0; i < choices->GetSize(); ++i) {
+ DictionaryValue* choice = NULL;
+ CHECK(choices->GetDictionary(i, &choice));
+
+ Validate(instance, choice, path);
+ if (errors_.size() == original_num_errors)
+ return;
+
+ // We discard the error from each choice. We only want to know if any of the
+ // validations succeeded.
+ errors_.resize(original_num_errors);
+ }
+
+ // Now add a generic error that no choices matched.
+ errors_.push_back(Error(path, kInvalidChoice));
+ return;
+}
+
+void JSONSchemaValidator::ValidateEnum(Value* instance,
+ ListValue* choices,
+ const std::string& path) {
+ for (size_t i = 0; i < choices->GetSize(); ++i) {
+ Value* choice = NULL;
+ CHECK(choices->Get(i, &choice));
+ switch (choice->GetType()) {
+ case Value::TYPE_NULL:
+ case Value::TYPE_BOOLEAN:
+ case Value::TYPE_STRING:
+ if (instance->Equals(choice))
+ return;
+ break;
+
+ case Value::TYPE_INTEGER:
+ case Value::TYPE_REAL:
+ if (instance->IsType(Value::TYPE_INTEGER) ||
+ instance->IsType(Value::TYPE_REAL)) {
+ if (GetNumberValue(choice) == GetNumberValue(instance))
+ return;
+ }
+ break;
+
+ default:
+ CHECK(false) << "Unexpected type in enum: " << choice->GetType();
+ }
+ }
+
+ errors_.push_back(Error(path, kInvalidEnum));
+}
+
+void JSONSchemaValidator::ValidateObject(DictionaryValue* instance,
+ DictionaryValue* schema,
+ const std::string& path) {
+ DictionaryValue* properties = NULL;
+ schema->GetDictionary("properties", &properties);
+ if (properties) {
+ for (DictionaryValue::key_iterator key = properties->begin_keys();
+ key != properties->end_keys(); ++key) {
+ std::string prop_path = path.empty() ? *key : (path + "." + *key);
+ DictionaryValue* prop_schema = NULL;
+ CHECK(properties->GetDictionary(*key, &prop_schema));
+
+ Value* prop_value = NULL;
+ if (instance->Get(*key, &prop_value)) {
+ Validate(prop_value, prop_schema, prop_path);
+ } else {
+ // Properties are required unless there is an optional field set to
+ // 'true'.
+ bool is_optional = false;
+ prop_schema->GetBoolean("optional", &is_optional);
+ if (!is_optional) {
+ errors_.push_back(Error(prop_path, kObjectPropertyIsRequired));
+ }
+ }
+ }
+ }
+
+ DictionaryValue* additional_properties_schema = NULL;
+ if (SchemaAllowsAnyAdditionalItems(schema, &additional_properties_schema))
+ return;
+
+ // Validate additional properties.
+ for (DictionaryValue::key_iterator key = instance->begin_keys();
+ key != instance->end_keys(); ++key) {
+ if (properties && properties->HasKey(*key))
+ continue;
+
+ std::string prop_path = path.empty() ? *key : path + "." + *key;
+ if (!additional_properties_schema) {
+ errors_.push_back(Error(prop_path, kUnexpectedProperty));
+ } else {
+ Value* prop_value = NULL;
+ CHECK(instance->Get(*key, &prop_value));
+ Validate(prop_value, additional_properties_schema, prop_path);
+ }
+ }
+}
+
+void JSONSchemaValidator::ValidateArray(ListValue* instance,
+ DictionaryValue* schema,
+ const std::string& path) {
+ DictionaryValue* single_type = NULL;
+ size_t instance_size = instance->GetSize();
+ if (schema->GetDictionary("items", &single_type)) {
+ int min_items = 0;
+ if (schema->GetInteger("minItems", &min_items)) {
+ CHECK(min_items >= 0);
+ if (instance_size < static_cast<size_t>(min_items)) {
+ errors_.push_back(Error(path, FormatErrorMessage(
+ kArrayMinItems, base::IntToString(min_items))));
+ }
+ }
+
+ int max_items = 0;
+ if (schema->GetInteger("maxItems", &max_items)) {
+ CHECK(max_items >= 0);
+ if (instance_size > static_cast<size_t>(max_items)) {
+ errors_.push_back(Error(path, FormatErrorMessage(
+ kArrayMaxItems, base::IntToString(max_items))));
+ }
+ }
+
+ // If the items property is a single schema, each item in the array must
+ // validate against that schema.
+ for (size_t i = 0; i < instance_size; ++i) {
+ Value* item = NULL;
+ CHECK(instance->Get(i, &item));
+ std::string i_str = base::UintToString(i);
+ std::string item_path = path.empty() ? i_str : (path + "." + i_str);
+ Validate(item, single_type, item_path);
+ }
+
+ return;
+ }
+
+ // Otherwise, the list must be a tuple type, where each item in the list has a
+ // particular schema.
+ ValidateTuple(instance, schema, path);
+}
+
+void JSONSchemaValidator::ValidateTuple(ListValue* instance,
+ DictionaryValue* schema,
+ const std::string& path) {
+ ListValue* tuple_type = NULL;
+ schema->GetList("items", &tuple_type);
+ size_t tuple_size = tuple_type ? tuple_type->GetSize() : 0;
+ if (tuple_type) {
+ for (size_t i = 0; i < tuple_size; ++i) {
+ std::string i_str = base::UintToString(i);
+ std::string item_path = path.empty() ? i_str : (path + "." + i_str);
+ DictionaryValue* item_schema = NULL;
+ CHECK(tuple_type->GetDictionary(i, &item_schema));
+ Value* item_value = NULL;
+ instance->Get(i, &item_value);
+ if (item_value && item_value->GetType() != Value::TYPE_NULL) {
+ Validate(item_value, item_schema, item_path);
+ } else {
+ bool is_optional = false;
+ item_schema->GetBoolean("optional", &is_optional);
+ if (!is_optional) {
+ errors_.push_back(Error(item_path, kArrayItemRequired));
+ return;
+ }
+ }
+ }
+ }
+
+ DictionaryValue* additional_properties_schema = NULL;
+ if (SchemaAllowsAnyAdditionalItems(schema, &additional_properties_schema))
+ return;
+
+ size_t instance_size = instance->GetSize();
+ if (additional_properties_schema) {
+ // Any additional properties must validate against the additionalProperties
+ // schema.
+ for (size_t i = tuple_size; i < instance_size; ++i) {
+ std::string i_str = base::UintToString(i);
+ std::string item_path = path.empty() ? i_str : (path + "." + i_str);
+ Value* item_value = NULL;
+ CHECK(instance->Get(i, &item_value));
+ Validate(item_value, additional_properties_schema, item_path);
+ }
+ } else if (instance_size > tuple_size) {
+ errors_.push_back(Error(path, FormatErrorMessage(
+ kArrayMaxItems, base::UintToString(tuple_size))));
+ }
+}
+
+void JSONSchemaValidator::ValidateString(StringValue* instance,
+ DictionaryValue* schema,
+ const std::string& path) {
+ std::string value;
+ CHECK(instance->GetAsString(&value));
+
+ int min_length = 0;
+ if (schema->GetInteger("minLength", &min_length)) {
+ CHECK(min_length >= 0);
+ if (value.size() < static_cast<size_t>(min_length)) {
+ errors_.push_back(Error(path, FormatErrorMessage(
+ kStringMinLength, base::IntToString(min_length))));
+ }
+ }
+
+ int max_length = 0;
+ if (schema->GetInteger("maxLength", &max_length)) {
+ CHECK(max_length >= 0);
+ if (value.size() > static_cast<size_t>(max_length)) {
+ errors_.push_back(Error(path, FormatErrorMessage(
+ kStringMaxLength, base::IntToString(max_length))));
+ }
+ }
+
+ CHECK(!schema->HasKey("pattern")) << "Pattern is not supported.";
+}
+
+void JSONSchemaValidator::ValidateNumber(Value* instance,
+ DictionaryValue* schema,
+ const std::string& path) {
+ double value = GetNumberValue(instance);
+
+ // TODO(aa): It would be good to test that the double is not infinity or nan,
+ // but isnan and isinf aren't defined on Windows.
+
+ double minimum = 0;
+ if (GetNumberFromDictionary(schema, "minimum", &minimum)) {
+ if (value < minimum)
+ errors_.push_back(Error(path, FormatErrorMessage(
+ kNumberMinimum, base::DoubleToString(minimum))));
+ }
+
+ double maximum = 0;
+ if (GetNumberFromDictionary(schema, "maximum", &maximum)) {
+ if (value > maximum)
+ errors_.push_back(Error(path, FormatErrorMessage(
+ kNumberMaximum, base::DoubleToString(maximum))));
+ }
+}
+
+bool JSONSchemaValidator::ValidateType(Value* instance,
+ const std::string& expected_type,
+ const std::string& path) {
+ std::string actual_type = GetJSONSchemaType(instance);
+ if (expected_type == actual_type ||
+ (expected_type == "number" && actual_type == "integer")) {
+ return true;
+ } else {
+ errors_.push_back(Error(path, FormatErrorMessage(
+ kInvalidType, expected_type, actual_type)));
+ return false;
+ }
+}
+
+bool JSONSchemaValidator::SchemaAllowsAnyAdditionalItems(
+ DictionaryValue* schema, DictionaryValue** additional_properties_schema) {
+ // If the validator allows additional properties globally, and this schema
+ // doesn't override, then we can exit early.
+ schema->GetDictionary("additionalProperties", additional_properties_schema);
+
+ if (*additional_properties_schema) {
+ std::string additional_properties_type("any");
+ CHECK((*additional_properties_schema)->GetString(
+ "type", &additional_properties_type));
+ return additional_properties_type == "any";
+ } else {
+ return default_allow_additional_properties_;
+ }
+}
diff --git a/chrome/common/json_schema_validator.h b/chrome/common/json_schema_validator.h
new file mode 100644
index 0000000..9af31fb
--- /dev/null
+++ b/chrome/common/json_schema_validator.h
@@ -0,0 +1,211 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_COMMON_JSON_SCHEMA_VALIDATOR_H_
+#define CHROME_COMMON_JSON_SCHEMA_VALIDATOR_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+
+class DictionaryValue;
+class FundamentalValue;
+class ListValue;
+class StringValue;
+class Value;
+
+//==============================================================================
+// This class implements a subset of JSON Schema.
+// See: http://www.json.com/json-schema-proposal/ for more details.
+//
+// There is also an older JavaScript implementation of the same functionality in
+// chrome/renderer/resources/json_schema.js.
+//
+// The following features of JSON Schema are not implemented:
+// - requires
+// - unique
+// - disallow
+// - union types (but replaced with 'choices')
+// - number.maxDecimal
+// - string.pattern
+//
+// The following properties are not applicable to the interface exposed by
+// this class:
+// - options
+// - readonly
+// - title
+// - description
+// - format
+// - default
+// - transient
+// - hidden
+//
+// There are also these departures from the JSON Schema proposal:
+// - null counts as 'unspecified' for optional values
+// - added the 'choices' property, to allow specifying a list of possible types
+// for a value
+// - by default an "object" typed schema does not allow additional properties.
+// if present, "additionalProperties" is to be a schema against which all
+// additional properties will be validated.
+//==============================================================================
+class JSONSchemaValidator {
+ public:
+ // Details about a validation error.
+ struct Error {
+ Error();
+
+ explicit Error(const std::string& message);
+
+ Error(const std::string& path, const std::string& message);
+
+ // The path to the location of the error in the JSON structure.
+ std::string path;
+
+ // An english message describing the error.
+ std::string message;
+ };
+
+ // Error messages.
+ static const char kUnknownTypeReference[];
+ static const char kInvalidChoice[];
+ static const char kInvalidEnum[];
+ static const char kObjectPropertyIsRequired[];
+ static const char kUnexpectedProperty[];
+ static const char kArrayMinItems[];
+ static const char kArrayMaxItems[];
+ static const char kArrayItemRequired[];
+ static const char kStringMinLength[];
+ static const char kStringMaxLength[];
+ static const char kStringPattern[];
+ static const char kNumberMinimum[];
+ static const char kNumberMaximum[];
+ static const char kInvalidType[];
+
+ // Classifies a Value as one of the JSON schema primitive types.
+ static std::string GetJSONSchemaType(Value* value);
+
+ // Utility methods to format error messages. The first method can have one
+ // wildcard represented by '*', which is replaced with s1. The second method
+ // can have two, which are replaced by s1 and s2.
+ static std::string FormatErrorMessage(const std::string& format,
+ const std::string& s1);
+ static std::string FormatErrorMessage(const std::string& format,
+ const std::string& s1,
+ const std::string& s2);
+
+ // Creates a validator for the specified schema.
+ //
+ // NOTE: This constructor assumes that |schema| is well formed and valid.
+ // Errors will result in CHECK at runtime; this constructor should not be used
+ // with untrusted schemas.
+ explicit JSONSchemaValidator(DictionaryValue* schema);
+
+ // Creates a validator for the specified schema and user-defined types. Each
+ // type must be a valid JSONSchema type description with an additional "id"
+ // field. Schema objects in |schema| can refer to these types with the "$ref"
+ // property.
+ //
+ // NOTE: This constructor assumes that |schema| and |types| are well-formed
+ // and valid. Errors will result in CHECK at runtime; this constructor should
+ // not be used with untrusted schemas.
+ JSONSchemaValidator(DictionaryValue* schema, ListValue* types);
+
+ // Whether the validator allows additional items for objects and lists, beyond
+ // those defined by their schema, by default.
+ //
+ // This setting defaults to false: all items in an instance list or object
+ // must be defined by the corresponding schema.
+ //
+ // This setting can be overridden on individual object and list schemas by
+ // setting the "additionalProperties" field.
+ bool default_allow_additional_properties() const {
+ return default_allow_additional_properties_;
+ }
+
+ void set_default_allow_additional_properties(bool val) {
+ default_allow_additional_properties_ = val;
+ }
+
+ // Returns any errors from the last call to to Validate().
+ const std::vector<Error>& errors() const {
+ return errors_;
+ }
+
+ // Validates a JSON value. Returns true if the instance is valid, false
+ // otherwise. If false is returned any errors are available from the errors()
+ // getter.
+ bool Validate(Value* instance);
+
+ private:
+ typedef std::map<std::string, DictionaryValue*> TypeMap;
+
+ // Each of the below methods handle a subset of the validation process. The
+ // path paramater is the path to |instance| from the root of the instance tree
+ // and is used in error messages.
+
+ // Validates any instance node against any schema node. This is called for
+ // every node in the instance tree, and it just decides which of the more
+ // detailed methods to call.
+ void Validate(Value* instance, DictionaryValue* schema,
+ const std::string& path);
+
+ // Validates a node against a list of possible schemas. If any one of the
+ // schemas match, the node is valid.
+ void ValidateChoices(Value* instance, ListValue* choices,
+ const std::string& path);
+
+ // Validates a node against a list of exact primitive values, eg 42, "foobar".
+ void ValidateEnum(Value* instance, ListValue* choices,
+ const std::string& path);
+
+ // Validates a JSON object against an object schema node.
+ void ValidateObject(DictionaryValue* instance, DictionaryValue* schema,
+ const std::string& path);
+
+ // Validates a JSON array against an array schema node.
+ void ValidateArray(ListValue* instance, DictionaryValue* schema,
+ const std::string& path);
+
+ // Validates a JSON array against an array schema node configured to be a
+ // tuple. In a tuple, there is one schema node for each item expected in the
+ // array.
+ void ValidateTuple(ListValue* instance, DictionaryValue* schema,
+ const std::string& path);
+
+ // Validate a JSON string against a string schema node.
+ void ValidateString(StringValue* instance, DictionaryValue* schema,
+ const std::string& path);
+
+ // Validate a JSON number against a number schema node.
+ void ValidateNumber(Value* instance, DictionaryValue* schema,
+ const std::string& path);
+
+ // Validates that the JSON node |instance| has |expected_type|.
+ bool ValidateType(Value* instance, const std::string& expected_type,
+ const std::string& path);
+
+ // Returns true if |schema| will allow additional items of any type.
+ bool SchemaAllowsAnyAdditionalItems(
+ DictionaryValue* schema, DictionaryValue** addition_items_schema);
+
+ // The root schema node.
+ DictionaryValue* schema_root_;
+
+ // Map of user-defined name to type.
+ TypeMap types_;
+
+ // Whether we allow additional properties on objects by default. This can be
+ // overridden by the allow_additional_properties flag on an Object schema.
+ bool default_allow_additional_properties_;
+
+ // Errors accumulated since the last call to Validate().
+ std::vector<Error> errors_;
+
+
+ DISALLOW_COPY_AND_ASSIGN(JSONSchemaValidator);
+};
+
+#endif // CHROME_COMMON_JSON_SCHEMA_VALIDATOR_H_
diff --git a/chrome/common/json_schema_validator_unittest.cc b/chrome/common/json_schema_validator_unittest.cc
new file mode 100644
index 0000000..ca4b388
--- /dev/null
+++ b/chrome/common/json_schema_validator_unittest.cc
@@ -0,0 +1,51 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/values.h"
+#include "chrome/common/json_schema_validator.h"
+#include "chrome/common/json_schema_validator_unittest_base.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+class JSONSchemaValidatorCPPTest : public JSONSchemaValidatorTestBase {
+ public:
+ JSONSchemaValidatorCPPTest()
+ : JSONSchemaValidatorTestBase(JSONSchemaValidatorTestBase::CPP) {
+ }
+
+ protected:
+ virtual void ExpectValid(const std::string& test_source,
+ Value* instance, DictionaryValue* schema,
+ ListValue* types) {
+ JSONSchemaValidator validator(schema, types);
+ if (validator.Validate(instance))
+ return;
+
+ for (size_t i = 0; i < validator.errors().size(); ++i) {
+ ADD_FAILURE() << test_source << ": "
+ << validator.errors()[i].path << ": "
+ << validator.errors()[i].message;
+ }
+ }
+
+ virtual void ExpectNotValid(const std::string& test_source,
+ Value* instance, DictionaryValue* schema,
+ ListValue* types,
+ const std::string& expected_error_path,
+ const std::string& expected_error_message) {
+ JSONSchemaValidator validator(schema, types);
+ if (validator.Validate(instance)) {
+ ADD_FAILURE() << test_source;
+ return;
+ }
+
+ ASSERT_EQ(1u, validator.errors().size()) << test_source;
+ EXPECT_EQ(expected_error_path, validator.errors()[0].path) << test_source;
+ EXPECT_EQ(expected_error_message, validator.errors()[0].message)
+ << test_source;
+ }
+};
+
+TEST_F(JSONSchemaValidatorCPPTest, Test) {
+ RunTests();
+}
diff --git a/chrome/common/json_schema_validator_unittest_base.cc b/chrome/common/json_schema_validator_unittest_base.cc
new file mode 100644
index 0000000..782d6bc
--- /dev/null
+++ b/chrome/common/json_schema_validator_unittest_base.cc
@@ -0,0 +1,628 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/common/json_schema_validator_unittest_base.h"
+
+#include <cfloat>
+#include <cmath>
+#include <limits>
+
+#include "base/file_util.h"
+#include "base/logging.h"
+#include "base/path_service.h"
+#include "base/scoped_ptr.h"
+#include "base/stringprintf.h"
+#include "base/values.h"
+#include "chrome/common/chrome_paths.h"
+#include "chrome/common/json_schema_validator.h"
+#include "chrome/common/json_value_serializer.h"
+
+namespace {
+
+#define TEST_SOURCE base::StringPrintf("%s:%i", __FILE__, __LINE__)
+
+Value* LoadValue(const std::string& filename) {
+ FilePath path;
+ PathService::Get(chrome::DIR_TEST_DATA, &path);
+ path = path.AppendASCII("json_schema_validator").AppendASCII(filename);
+ EXPECT_TRUE(file_util::PathExists(path));
+
+ std::string error_message;
+ JSONFileValueSerializer serializer(path);
+ Value* result = serializer.Deserialize(NULL, &error_message);
+ if (!result)
+ ADD_FAILURE() << "Could not parse JSON: " << error_message;
+ return result;
+}
+
+Value* LoadValue(const std::string& filename, Value::ValueType type) {
+ scoped_ptr<Value> result(LoadValue(filename));
+ if (!result.get())
+ return NULL;
+ if (!result->IsType(type)) {
+ ADD_FAILURE() << "Expected type " << type << ", got: " << result->GetType();
+ return NULL;
+ }
+ return result.release();
+}
+
+ListValue* LoadList(const std::string& filename) {
+ return static_cast<ListValue*>(
+ LoadValue(filename, Value::TYPE_LIST));
+}
+
+DictionaryValue* LoadDictionary(const std::string& filename) {
+ return static_cast<DictionaryValue*>(
+ LoadValue(filename, Value::TYPE_DICTIONARY));
+}
+
+} // namespace
+
+
+JSONSchemaValidatorTestBase::JSONSchemaValidatorTestBase(
+ JSONSchemaValidatorTestBase::ValidatorType type)
+ : type_(type) {
+}
+
+void JSONSchemaValidatorTestBase::RunTests() {
+ TestComplex();
+ TestStringPattern();
+ TestEnum();
+ TestChoices();
+ TestExtends();
+ TestObject();
+ TestTypeReference();
+ TestArrayTuple();
+ TestArrayNonTuple();
+ TestString();
+ TestNumber();
+ TestTypeClassifier();
+ TestTypes();
+}
+
+void JSONSchemaValidatorTestBase::TestComplex() {
+ scoped_ptr<DictionaryValue> schema(LoadDictionary("complex_schema.json"));
+ scoped_ptr<ListValue> instance(LoadList("complex_instance.json"));
+
+ ASSERT_TRUE(schema.get());
+ ASSERT_TRUE(instance.get());
+
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+ instance->Remove(instance->GetSize() - 1, NULL);
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+ instance->Append(new DictionaryValue());
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "1",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "number", "object"));
+ instance->Remove(instance->GetSize() - 1, NULL);
+
+ DictionaryValue* item = NULL;
+ ASSERT_TRUE(instance->GetDictionary(0, &item));
+ item->SetString("url", "xxxxxxxxxxx");
+
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
+ "0.url",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kStringMaxLength, "10"));
+}
+
+void JSONSchemaValidatorTestBase::TestStringPattern() {
+ // Regex patterns not supported in CPP validator.
+ if (type_ == CPP)
+ return;
+
+ scoped_ptr<DictionaryValue> schema(new DictionaryValue());
+ schema->SetString("type", "string");
+ schema->SetString("pattern", "foo+");
+
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateStringValue("foo")).get(),
+ schema.get(), NULL);
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateStringValue("foooooo")).get(),
+ schema.get(), NULL);
+ ExpectNotValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateStringValue("bar")).get(),
+ schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kStringPattern, "foo+"));
+}
+
+void JSONSchemaValidatorTestBase::TestEnum() {
+ scoped_ptr<DictionaryValue> schema(LoadDictionary("enum_schema.json"));
+
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateStringValue("foo")).get(),
+ schema.get(), NULL);
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateIntegerValue(42)).get(),
+ schema.get(), NULL);
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateBooleanValue(false)).get(),
+ schema.get(), NULL);
+
+ ExpectNotValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateStringValue("42")).get(),
+ schema.get(), NULL, "", JSONSchemaValidator::kInvalidEnum);
+ ExpectNotValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateNullValue()).get(),
+ schema.get(), NULL, "", JSONSchemaValidator::kInvalidEnum);
+}
+
+void JSONSchemaValidatorTestBase::TestChoices() {
+ scoped_ptr<DictionaryValue> schema(LoadDictionary("choices_schema.json"));
+
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateNullValue()).get(),
+ schema.get(), NULL);
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateIntegerValue(42)).get(),
+ schema.get(), NULL);
+
+ scoped_ptr<DictionaryValue> instance(new DictionaryValue());
+ instance->SetString("foo", "bar");
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+ ExpectNotValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateStringValue("foo")).get(),
+ schema.get(), NULL, "", JSONSchemaValidator::kInvalidChoice);
+ ExpectNotValid(TEST_SOURCE,
+ scoped_ptr<Value>(new ListValue()).get(),
+ schema.get(), NULL, "", JSONSchemaValidator::kInvalidChoice);
+
+ instance->SetInteger("foo", 42);
+ ExpectNotValid(TEST_SOURCE, instance.get(),
+ schema.get(), NULL, "", JSONSchemaValidator::kInvalidChoice);
+}
+
+void JSONSchemaValidatorTestBase::TestExtends() {
+ // TODO(aa): JS only
+}
+
+void JSONSchemaValidatorTestBase::TestObject() {
+ scoped_ptr<DictionaryValue> schema(new DictionaryValue());
+ schema->SetString("type", "object");
+ schema->SetString("properties.foo.type", "string");
+ schema->SetString("properties.bar.type", "integer");
+
+ scoped_ptr<DictionaryValue> instance(new DictionaryValue());
+ instance->SetString("foo", "foo");
+ instance->SetInteger("bar", 42);
+
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+ instance->SetBoolean("extra", true);
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
+ "extra", JSONSchemaValidator::kUnexpectedProperty);
+
+ instance->Remove("extra", NULL);
+ instance->Remove("bar", NULL);
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "bar",
+ JSONSchemaValidator::kObjectPropertyIsRequired);
+
+ instance->SetString("bar", "42");
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "bar",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "integer", "string"));
+
+ DictionaryValue* additional_properties = new DictionaryValue();
+ additional_properties->SetString("type", "any");
+ schema->Set("additionalProperties", additional_properties);
+
+ instance->SetInteger("bar", 42);
+ instance->SetBoolean("extra", true);
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+ instance->SetString("extra", "foo");
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+ additional_properties->SetString("type", "boolean");
+ instance->SetBoolean("extra", true);
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+ instance->SetString("extra", "foo");
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
+ "extra", JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "boolean", "string"));
+
+ DictionaryValue* properties = NULL;
+ DictionaryValue* bar_property = NULL;
+ ASSERT_TRUE(schema->GetDictionary("properties", &properties));
+ ASSERT_TRUE(properties->GetDictionary("bar", &bar_property));
+
+ bar_property->SetBoolean("optional", true);
+ instance->Remove("extra", NULL);
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+ instance->Remove("bar", NULL);
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+ instance->Set("bar", Value::CreateNullValue());
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
+ "bar", JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "integer", "null"));
+ instance->SetString("bar", "42");
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
+ "bar", JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "integer", "string"));
+}
+
+void JSONSchemaValidatorTestBase::TestTypeReference() {
+ scoped_ptr<ListValue> types(LoadList("reference_types.json"));
+ ASSERT_TRUE(types.get());
+
+ scoped_ptr<DictionaryValue> schema(new DictionaryValue());
+ schema->SetString("type", "object");
+ schema->SetString("properties.foo.type", "string");
+ schema->SetString("properties.bar.$ref", "Max10Int");
+ schema->SetString("properties.baz.$ref", "MinLengthString");
+
+ scoped_ptr<DictionaryValue> schema_inline(new DictionaryValue());
+ schema_inline->SetString("type", "object");
+ schema_inline->SetString("properties.foo.type", "string");
+ schema_inline->SetString("properties.bar.id", "NegativeInt");
+ schema_inline->SetString("properties.bar.type", "integer");
+ schema_inline->SetInteger("properties.bar.maximum", 0);
+ schema_inline->SetString("properties.baz.$ref", "NegativeInt");
+
+ scoped_ptr<DictionaryValue> instance(new DictionaryValue());
+ instance->SetString("foo", "foo");
+ instance->SetInteger("bar", 4);
+ instance->SetString("baz", "ab");
+
+ scoped_ptr<DictionaryValue> instance_inline(new DictionaryValue());
+ instance_inline->SetString("foo", "foo");
+ instance_inline->SetInteger("bar", -4);
+ instance_inline->SetInteger("baz", -2);
+
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), types.get());
+ ExpectValid(TEST_SOURCE, instance_inline.get(), schema_inline.get(), NULL);
+
+ // Validation failure, but successful schema reference.
+ instance->SetString("baz", "a");
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), types.get(),
+ "baz", JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kStringMinLength, "2"));
+
+ instance_inline->SetInteger("bar", 20);
+ ExpectNotValid(TEST_SOURCE, instance_inline.get(), schema_inline.get(), NULL,
+ "bar", JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kNumberMaximum, "0"));
+
+ // Remove MinLengthString type.
+ types->Remove(types->GetSize() - 1, NULL);
+ instance->SetString("baz", "ab");
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), types.get(),
+ "bar", JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kUnknownTypeReference,
+ "Max10Int"));
+
+ // Remove internal type "NegativeInt".
+ schema_inline->Remove("properties.bar", NULL);
+ instance_inline->Remove("bar", NULL);
+ ExpectNotValid(TEST_SOURCE, instance_inline.get(), schema_inline.get(), NULL,
+ "baz", JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kUnknownTypeReference,
+ "NegativeInt"));
+}
+
+void JSONSchemaValidatorTestBase::TestArrayTuple() {
+ scoped_ptr<DictionaryValue> schema(LoadDictionary("array_tuple_schema.json"));
+ ASSERT_TRUE(schema.get());
+
+ scoped_ptr<ListValue> instance(new ListValue());
+ instance->Append(Value::CreateStringValue("42"));
+ instance->Append(Value::CreateIntegerValue(42));
+
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+ instance->Append(Value::CreateStringValue("anything"));
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kArrayMaxItems, "2"));
+
+ instance->Remove(1, NULL);
+ instance->Remove(1, NULL);
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "1",
+ JSONSchemaValidator::kArrayItemRequired);
+
+ instance->Set(0, Value::CreateIntegerValue(42));
+ instance->Append(Value::CreateIntegerValue(42));
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "0",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "string", "integer"));
+
+ DictionaryValue* additional_properties = new DictionaryValue();
+ additional_properties->SetString("type", "any");
+ schema->Set("additionalProperties", additional_properties);
+ instance->Set(0, Value::CreateStringValue("42"));
+ instance->Append(Value::CreateStringValue("anything"));
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+ instance->Set(2, new ListValue());
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+ additional_properties->SetString("type", "boolean");
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "2",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "boolean", "array"));
+ instance->Set(2, Value::CreateBooleanValue(false));
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+ ListValue* items_schema = NULL;
+ DictionaryValue* item0_schema = NULL;
+ ASSERT_TRUE(schema->GetList("items", &items_schema));
+ ASSERT_TRUE(items_schema->GetDictionary(0, &item0_schema));
+ item0_schema->SetBoolean("optional", true);
+ instance->Remove(2, NULL);
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+ // TODO(aa): I think this is inconsistent with the handling of NULL+optional
+ // for objects.
+ instance->Set(0, Value::CreateNullValue());
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+ instance->Set(0, Value::CreateIntegerValue(42));
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "0",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "string", "integer"));
+}
+
+void JSONSchemaValidatorTestBase::TestArrayNonTuple() {
+ scoped_ptr<DictionaryValue> schema(new DictionaryValue());
+ schema->SetString("type", "array");
+ schema->SetString("items.type", "string");
+ schema->SetInteger("minItems", 2);
+ schema->SetInteger("maxItems", 3);
+
+ scoped_ptr<ListValue> instance(new ListValue());
+ instance->Append(Value::CreateStringValue("x"));
+ instance->Append(Value::CreateStringValue("x"));
+
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+ instance->Append(Value::CreateStringValue("x"));
+ ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+
+ instance->Append(Value::CreateStringValue("x"));
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kArrayMaxItems, "3"));
+ instance->Remove(1, NULL);
+ instance->Remove(1, NULL);
+ instance->Remove(1, NULL);
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kArrayMinItems, "2"));
+
+ instance->Remove(1, NULL);
+ instance->Append(Value::CreateIntegerValue(42));
+ ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "1",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "string", "integer"));
+}
+
+void JSONSchemaValidatorTestBase::TestString() {
+ scoped_ptr<DictionaryValue> schema(new DictionaryValue());
+ schema->SetString("type", "string");
+ schema->SetInteger("minLength", 1);
+ schema->SetInteger("maxLength", 10);
+
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateStringValue("x")).get(),
+ schema.get(), NULL);
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateStringValue("xxxxxxxxxx")).get(),
+ schema.get(), NULL);
+
+ ExpectNotValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateStringValue("")).get(),
+ schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kStringMinLength, "1"));
+ ExpectNotValid(
+ TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateStringValue("xxxxxxxxxxx")).get(),
+ schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kStringMaxLength, "10"));
+
+}
+
+void JSONSchemaValidatorTestBase::TestNumber() {
+ scoped_ptr<DictionaryValue> schema(new DictionaryValue());
+ schema->SetString("type", "number");
+ schema->SetInteger("minimum", 1);
+ schema->SetInteger("maximum", 100);
+ schema->SetInteger("maxDecimal", 2);
+
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateIntegerValue(1)).get(),
+ schema.get(), NULL);
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateIntegerValue(50)).get(),
+ schema.get(), NULL);
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateIntegerValue(100)).get(),
+ schema.get(), NULL);
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateRealValue(88.88)).get(),
+ schema.get(), NULL);
+
+ ExpectNotValid(
+ TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateRealValue(0.5)).get(),
+ schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kNumberMinimum, "1"));
+ ExpectNotValid(
+ TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateRealValue(100.1)).get(),
+ schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kNumberMaximum, "100"));
+}
+
+void JSONSchemaValidatorTestBase::TestTypeClassifier() {
+ EXPECT_EQ("boolean", JSONSchemaValidator::GetJSONSchemaType(
+ scoped_ptr<Value>(Value::CreateBooleanValue(true)).get()));
+ EXPECT_EQ("boolean", JSONSchemaValidator::GetJSONSchemaType(
+ scoped_ptr<Value>(Value::CreateBooleanValue(false)).get()));
+
+ // It doesn't matter whether the C++ type is 'integer' or 'real'. If the
+ // number is integral and within the representable range of integers in
+ // double, it's classified as 'integer'.
+ EXPECT_EQ("integer", JSONSchemaValidator::GetJSONSchemaType(
+ scoped_ptr<Value>(Value::CreateIntegerValue(42)).get()));
+ EXPECT_EQ("integer", JSONSchemaValidator::GetJSONSchemaType(
+ scoped_ptr<Value>(Value::CreateIntegerValue(0)).get()));
+ EXPECT_EQ("integer", JSONSchemaValidator::GetJSONSchemaType(
+ scoped_ptr<Value>(Value::CreateRealValue(42)).get()));
+ EXPECT_EQ("integer", JSONSchemaValidator::GetJSONSchemaType(
+ scoped_ptr<Value>(
+ Value::CreateRealValue(pow(2.0, DBL_MANT_DIG))).get()));
+ EXPECT_EQ("integer", JSONSchemaValidator::GetJSONSchemaType(
+ scoped_ptr<Value>(
+ Value::CreateRealValue(pow(-2.0, DBL_MANT_DIG))).get()));
+
+ // "number" is only used for non-integral numbers, or numbers beyond what
+ // double can accurately represent.
+ EXPECT_EQ("number", JSONSchemaValidator::GetJSONSchemaType(
+ scoped_ptr<Value>(Value::CreateRealValue(88.8)).get()));
+ EXPECT_EQ("number", JSONSchemaValidator::GetJSONSchemaType(
+ scoped_ptr<Value>(Value::CreateRealValue(
+ pow(2.0, DBL_MANT_DIG) * 2)).get()));
+ EXPECT_EQ("number", JSONSchemaValidator::GetJSONSchemaType(
+ scoped_ptr<Value>(Value::CreateRealValue(
+ pow(-2.0, DBL_MANT_DIG) * 2)).get()));
+
+ EXPECT_EQ("string", JSONSchemaValidator::GetJSONSchemaType(
+ scoped_ptr<Value>(Value::CreateStringValue("foo")).get()));
+ EXPECT_EQ("array", JSONSchemaValidator::GetJSONSchemaType(
+ scoped_ptr<Value>(new ListValue()).get()));
+ EXPECT_EQ("object", JSONSchemaValidator::GetJSONSchemaType(
+ scoped_ptr<Value>(new DictionaryValue()).get()));
+ EXPECT_EQ("null", JSONSchemaValidator::GetJSONSchemaType(
+ scoped_ptr<Value>(Value::CreateNullValue()).get()));
+}
+
+void JSONSchemaValidatorTestBase::TestTypes() {
+ scoped_ptr<DictionaryValue> schema(new DictionaryValue());
+
+ // valid
+ schema->SetString("type", "object");
+ ExpectValid(TEST_SOURCE, scoped_ptr<Value>(new DictionaryValue()).get(),
+ schema.get(), NULL);
+
+ schema->SetString("type", "array");
+ ExpectValid(TEST_SOURCE, scoped_ptr<Value>(new ListValue()).get(),
+ schema.get(), NULL);
+
+ schema->SetString("type", "string");
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateStringValue("foobar")).get(),
+ schema.get(), NULL);
+
+ schema->SetString("type", "number");
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateRealValue(88.8)).get(),
+ schema.get(), NULL);
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateRealValue(42)).get(),
+ schema.get(), NULL);
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateIntegerValue(42)).get(),
+ schema.get(), NULL);
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateIntegerValue(0)).get(),
+ schema.get(), NULL);
+
+ schema->SetString("type", "integer");
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateIntegerValue(42)).get(),
+ schema.get(), NULL);
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateRealValue(42)).get(),
+ schema.get(), NULL);
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateIntegerValue(0)).get(),
+ schema.get(), NULL);
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(
+ Value::CreateRealValue(pow(2.0, DBL_MANT_DIG))).get(),
+ schema.get(), NULL);
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(
+ Value::CreateRealValue(pow(-2.0, DBL_MANT_DIG))).get(),
+ schema.get(), NULL);
+
+ schema->SetString("type", "boolean");
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateBooleanValue(false)).get(),
+ schema.get(), NULL);
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateBooleanValue(true)).get(),
+ schema.get(), NULL);
+
+ schema->SetString("type", "null");
+ ExpectValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateNullValue()).get(),
+ schema.get(), NULL);
+
+ // not valid
+ schema->SetString("type", "object");
+ ExpectNotValid(TEST_SOURCE, scoped_ptr<Value>(new ListValue()).get(),
+ schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "object", "array"));
+
+ schema->SetString("type", "object");
+ ExpectNotValid(TEST_SOURCE, scoped_ptr<Value>(Value::CreateNullValue()).get(),
+ schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "object", "null"));
+
+ schema->SetString("type", "array");
+ ExpectNotValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateIntegerValue(42)).get(),
+ schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "array", "integer"));
+
+ schema->SetString("type", "string");
+ ExpectNotValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateIntegerValue(42)).get(),
+ schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "string", "integer"));
+
+ schema->SetString("type", "number");
+ ExpectNotValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateStringValue("42")).get(),
+ schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "number", "string"));
+
+ schema->SetString("type", "integer");
+ ExpectNotValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateRealValue(88.8)).get(),
+ schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "integer", "number"));
+
+ schema->SetString("type", "integer");
+ ExpectNotValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateRealValue(88.8)).get(),
+ schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "integer", "number"));
+
+ schema->SetString("type", "boolean");
+ ExpectNotValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateIntegerValue(1)).get(),
+ schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "boolean", "integer"));
+
+ schema->SetString("type", "null");
+ ExpectNotValid(TEST_SOURCE,
+ scoped_ptr<Value>(Value::CreateBooleanValue(false)).get(),
+ schema.get(), NULL, "",
+ JSONSchemaValidator::FormatErrorMessage(
+ JSONSchemaValidator::kInvalidType, "null", "boolean"));
+}
diff --git a/chrome/common/json_schema_validator_unittest_base.h b/chrome/common/json_schema_validator_unittest_base.h
new file mode 100644
index 0000000..8530a13
--- /dev/null
+++ b/chrome/common/json_schema_validator_unittest_base.h
@@ -0,0 +1,59 @@
+// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_COMMON_JSON_SCHEMA_VALIDATOR_UNITTEST_BASE_H_
+#define CHROME_COMMON_JSON_SCHEMA_VALIDATOR_UNITTEST_BASE_H_
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+class DictionaryValue;
+class ListValue;
+class Value;
+
+// Base class for unit tests for JSONSchemaValidator. There is currently only
+// one implementation, JSONSchemaValidatorCPPTest.
+//
+// TODO(aa): Refactor chrome/test/data/json_schema_test.js into
+// JSONSchemaValidatorJSTest that inherits from this.
+class JSONSchemaValidatorTestBase : public testing::Test {
+ public:
+ enum ValidatorType {
+ CPP = 1,
+ JS = 2
+ };
+
+ explicit JSONSchemaValidatorTestBase(ValidatorType type);
+
+ void RunTests();
+
+ protected:
+ virtual void ExpectValid(const std::string& test_source,
+ Value* instance, DictionaryValue* schema,
+ ListValue* types) = 0;
+
+ virtual void ExpectNotValid(const std::string& test_source,
+ Value* instance, DictionaryValue* schema,
+ ListValue* types,
+ const std::string& expected_error_path,
+ const std::string& expected_error_message) = 0;
+
+ private:
+ void TestComplex();
+ void TestStringPattern();
+ void TestEnum();
+ void TestChoices();
+ void TestExtends();
+ void TestObject();
+ void TestTypeReference();
+ void TestArrayTuple();
+ void TestArrayNonTuple();
+ void TestString();
+ void TestNumber();
+ void TestTypeClassifier();
+ void TestTypes();
+
+ ValidatorType type_;
+};
+
+#endif // CHROME_COMMON_JSON_SCHEMA_VALIDATOR_UNITTEST_BASE_H_
diff --git a/chrome/test/data/json_schema_validator/array_tuple_schema.json b/chrome/test/data/json_schema_validator/array_tuple_schema.json
new file mode 100644
index 0000000..a9bea68
--- /dev/null
+++ b/chrome/test/data/json_schema_validator/array_tuple_schema.json
@@ -0,0 +1,11 @@
+{
+ "type": "array",
+ "items": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "integer"
+ }
+ ]
+}
diff --git a/chrome/test/data/json_schema_validator/choices_schema.json b/chrome/test/data/json_schema_validator/choices_schema.json
new file mode 100644
index 0000000..bd0f1a5
--- /dev/null
+++ b/chrome/test/data/json_schema_validator/choices_schema.json
@@ -0,0 +1,7 @@
+{
+ "choices": [
+ { "type": "null" },
+ { "type": "integer", "minimum": 42, "maximum": 43 },
+ { "type": "object", "properties": { "foo": { "type": "string" } } }
+ ]
+}
diff --git a/chrome/test/data/json_schema_validator/complex_instance.json b/chrome/test/data/json_schema_validator/complex_instance.json
new file mode 100644
index 0000000..1fb193b
--- /dev/null
+++ b/chrome/test/data/json_schema_validator/complex_instance.json
@@ -0,0 +1,9 @@
+[
+ {
+ "id": 42,
+ "url": "google.com",
+ "index": 2,
+ "selected": true
+ },
+ 88.8
+]
diff --git a/chrome/test/data/json_schema_validator/complex_schema.json b/chrome/test/data/json_schema_validator/complex_schema.json
new file mode 100644
index 0000000..bf0d6b8
--- /dev/null
+++ b/chrome/test/data/json_schema_validator/complex_schema.json
@@ -0,0 +1,33 @@
+{
+ "type": "array",
+ "items": [
+ {
+ "type": "object",
+ "properties": {
+ "id": {
+ "type": "integer",
+ "minimum": 1
+ },
+ "url": {
+ "type": "string",
+ "maxLength": 10,
+ "optional": true
+ },
+ "index": {
+ "type": "integer",
+ "minimum": 0,
+ "optional": true
+ },
+ "selected": {
+ "type": "boolean",
+ "optional": true
+ }
+ }
+ },
+ {
+ "type": "number",
+ "optional": true
+ }
+ ]
+}
+
diff --git a/chrome/test/data/json_schema_validator/enum_schema.json b/chrome/test/data/json_schema_validator/enum_schema.json
new file mode 100644
index 0000000..ae0c12a
--- /dev/null
+++ b/chrome/test/data/json_schema_validator/enum_schema.json
@@ -0,0 +1,3 @@
+{
+ "enum": ["foo", 42, false]
+}
diff --git a/chrome/test/data/json_schema_validator/reference_types.json b/chrome/test/data/json_schema_validator/reference_types.json
new file mode 100644
index 0000000..8f77334
--- /dev/null
+++ b/chrome/test/data/json_schema_validator/reference_types.json
@@ -0,0 +1,12 @@
+[
+ {
+ "id": "MinLengthString",
+ "type": "string",
+ "minLength": 2
+ },
+ {
+ "id": "Max10Int",
+ "type": "integer",
+ "maximum": 10
+ }
+]
generated by cgit v1.1 at 2025-02-13 17:24:54 +0000