Add regular expression support in json_schema component

components/json_schema/json_schema_validator_unittest_base.cc

 // Copyright 2013 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 "components/json_schema/json_schema_validator_unittest_base.h"
 
 #include <cfloat>
 #include <cmath>
 #include <limits>
 
@@ skipping 49 matching lines @@
 }
 
 base::DictionaryValue* LoadDictionary(const std::string& filename) {
   return static_cast<base::DictionaryValue*>(
       LoadValue(filename, base::Value::TYPE_DICTIONARY));
 }
 
 }  // namespace
 
 
-JSONSchemaValidatorTestBase::JSONSchemaValidatorTestBase(
-    JSONSchemaValidatorTestBase::ValidatorType type)
-    : type_(type) {
+JSONSchemaValidatorTestBase::JSONSchemaValidatorTestBase() {
 }
 
 void JSONSchemaValidatorTestBase::RunTests() {
   TestComplex();
   TestStringPattern();
   TestEnum();
   TestChoices();
   TestExtends();
   TestObject();
   TestTypeReference();
@@ skipping 28 matching lines @@
   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<base::DictionaryValue> schema(new base::DictionaryValue());
   schema->SetString(schema::kType, schema::kString);
   schema->SetString(schema::kPattern, "foo+");
 
   ExpectValid(TEST_SOURCE,
               scoped_ptr<base::Value>(new base::StringValue("foo")).get(),
               schema.get(), NULL);
   ExpectValid(TEST_SOURCE,
               scoped_ptr<base::Value>(new base::StringValue("foooooo")).get(),
               schema.get(), NULL);
@@ skipping 82 matching lines @@
 
   scoped_ptr<base::DictionaryValue> instance(new base::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("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,
                      schema::kInteger,
                      schema::kString));
+  instance->SetInteger("bar", 42);
 
+  // Test "patternProperties".
+  instance->SetInteger("extra", 42);
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
+                 "extra", JSONSchemaValidator::kUnexpectedProperty);
+  schema->SetString("patternProperties.extra+.type",
+                    schema::kInteger);
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+  instance->Remove("extra", NULL);
+  instance->SetInteger("extraaa", 42);
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+  instance->Remove("extraaa", NULL);
+  instance->SetInteger("extr", 42);
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
+                 "extr", JSONSchemaValidator::kUnexpectedProperty);
+  instance->Remove("extr", NULL);
+  schema->Remove(schema::kPatternProperties, NULL);
+
+  // Test "patternProperties" and "properties" schemas are both checked if
+  // applicable.
+  schema->SetString("patternProperties.fo+.type", schema::kInteger);
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "foo",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kInteger,
+                     schema::kString));
+  instance->SetInteger("foo", 123);
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL, "foo",
+                 JSONSchemaValidator::FormatErrorMessage(
+                     JSONSchemaValidator::kInvalidType,
+                     schema::kString,
+                     schema::kInteger));
+  instance->SetString("foo", "foo");
+  schema->Remove(schema::kPatternProperties, NULL);
+
+  // Test additional properties.
   base::DictionaryValue* additional_properties = new base::DictionaryValue();
   additional_properties->SetString(schema::kType, schema::kAny);
   schema->Set(schema::kAdditionalProperties, 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(schema::kType, schema::kBoolean);
   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,
                      schema::kBoolean,
                      schema::kString));
+  instance->Remove("extra", NULL);
 
   base::DictionaryValue* properties = NULL;
   base::DictionaryValue* bar_property = NULL;
   ASSERT_TRUE(schema->GetDictionary(schema::kProperties, &properties));
   ASSERT_TRUE(properties->GetDictionary("bar", &bar_property));
 
   bar_property->SetBoolean(schema::kOptional, 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", base::Value::CreateNullValue());
   ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
                  "bar", JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType,
                      schema::kInteger,
                      schema::kNull));
   instance->SetString("bar", "42");
   ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
                  "bar", JSONSchemaValidator::FormatErrorMessage(
                      JSONSchemaValidator::kInvalidType,
                      schema::kInteger,
                      schema::kString));
+
+  // Verify that JSON parser handles dot in "patternProperties" well.
+  schema.reset(LoadDictionary("pattern_properties_dot.json"));
+  ASSERT_TRUE(schema->GetDictionary(schema::kPatternProperties, &properties));
+  ASSERT_TRUE(properties->HasKey("^.$"));
+
+  instance.reset(new base::DictionaryValue());
+  instance->SetString("a", "whatever");
+  ExpectValid(TEST_SOURCE, instance.get(), schema.get(), NULL);
+  instance->SetString("foo", "bar");
+  ExpectNotValid(TEST_SOURCE, instance.get(), schema.get(), NULL,
+                 "foo", JSONSchemaValidator::kUnexpectedProperty);
 }
 
 void JSONSchemaValidatorTestBase::TestTypeReference() {
   scoped_ptr<base::ListValue> types(LoadList("reference_types.json"));
   ASSERT_TRUE(types.get());
 
   scoped_ptr<base::DictionaryValue> schema(new base::DictionaryValue());
   schema->SetString(schema::kType, schema::kObject);
   schema->SetString("properties.foo.type", schema::kString);
   schema->SetString("properties.bar.$ref", "Max10Int");
@@ skipping 427 matching lines @@
   schema->SetString(schema::kType, schema::kNull);
   ExpectNotValid(
       TEST_SOURCE,
       scoped_ptr<base::Value>(new base::FundamentalValue(false)).get(),
       schema.get(),
       NULL,
       std::string(),
       JSONSchemaValidator::FormatErrorMessage(
           JSONSchemaValidator::kInvalidType, schema::kNull, schema::kBoolean));
 }