Added a SchemaMap.

components/policy/core/common/schema_unittest.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/policy/core/common/schema.h"
 
 #include "components/policy/core/common/schema_internal.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace policy {
 
 namespace {
 
 #define OBJECT_TYPE "\"type\":\"object\""
 
+const char kTestSchema[] =
+    "{"
+      OBJECT_TYPE ","

[dconnelly, 2013/10/31 10:04:16]

I know this is just moved, but why is this necessary?  The other types haven't
been lifted into constants...

[Joao da Silva, 2013/10/31 13:34:56]

Done.

+      "\"properties\": {"
+      "  \"Boolean\": { \"type\": \"boolean\" },"
+      "  \"Integer\": { \"type\": \"integer\" },"
+      "  \"Null\": { \"type\": \"null\" },"
+      "  \"Number\": { \"type\": \"number\" },"
+      "  \"String\": { \"type\": \"string\" },"
+      "  \"Array\": {"
+      "    \"type\": \"array\","
+      "    \"items\": { \"type\": \"string\" }"
+      "  },"
+      "  \"ArrayOfObjects\": {"
+      "    \"type\": \"array\","
+      "    \"items\": {"
+      "      \"type\": \"object\","
+      "      \"properties\": {"
+      "        \"one\": { \"type\": \"string\" },"
+      "        \"two\": { \"type\": \"integer\" }"
+      "      }"
+      "    }"
+      "  },"
+      "  \"ArrayOfArray\": {"
+      "    \"type\": \"array\","
+      "    \"items\": {"
+      "      \"type\": \"array\","
+      "      \"items\": { \"type\": \"string\" }"
+      "    }"
+      "  },"
+      "  \"Object\": {"
+      "    \"type\": \"object\","
+      "    \"properties\": {"
+      "      \"one\": { \"type\": \"boolean\" },"
+      "      \"two\": { \"type\": \"integer\" }"
+      "    },"
+      "    \"additionalProperties\": { \"type\": \"string\" }"
+      "  }"
+      "}"
+    "}";
+
 bool ParseFails(const std::string& content) {
   std::string error;
   Schema schema = Schema::Parse(content, &error);
   if (schema.valid())
     return false;
   EXPECT_FALSE(error.empty());
   return true;
 }
 
 }  // namespace
@@ skipping 77 matching lines @@
   }
 
   ASSERT_TRUE(schema.valid());
   EXPECT_EQ(base::Value::TYPE_STRING, schema.type());
 
   // This test shouldn't leak nor use invalid memory.
 }
 
 TEST(SchemaTest, ValidSchema) {
   std::string error;
-  Schema schema = Schema::Parse(
-      "{"
-        OBJECT_TYPE ","
-        "\"properties\": {"
-        "  \"Boolean\": { \"type\": \"boolean\" },"
-        "  \"Integer\": { \"type\": \"integer\" },"
-        "  \"Null\": { \"type\": \"null\" },"
-        "  \"Number\": { \"type\": \"number\" },"
-        "  \"String\": { \"type\": \"string\" },"
-        "  \"Array\": {"
-        "    \"type\": \"array\","
-        "    \"items\": { \"type\": \"string\" }"
-        "  },"
-        "  \"ArrayOfObjects\": {"
-        "    \"type\": \"array\","
-        "    \"items\": {"
-        "      \"type\": \"object\","
-        "      \"properties\": {"
-        "        \"one\": { \"type\": \"string\" },"
-        "        \"two\": { \"type\": \"integer\" }"
-        "      }"
-        "    }"
-        "  },"
-        "  \"ArrayOfArray\": {"
-        "    \"type\": \"array\","
-        "    \"items\": {"
-        "      \"type\": \"array\","
-        "      \"items\": { \"type\": \"string\" }"
-        "    }"
-        "  },"
-        "  \"Object\": {"
-        "    \"type\": \"object\","
-        "    \"properties\": {"
-        "      \"one\": { \"type\": \"boolean\" },"
-        "      \"two\": { \"type\": \"integer\" }"
-        "    },"
-        "    \"additionalProperties\": { \"type\": \"string\" }"
-        "  }"
-        "}"
-      "}", &error);
+  Schema schema = Schema::Parse(kTestSchema, &error);
   ASSERT_TRUE(schema.valid()) << error;
 
   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
   EXPECT_FALSE(schema.GetProperty("invalid").valid());
 
   Schema sub = schema.GetProperty("Boolean");
   ASSERT_TRUE(sub.valid());
   EXPECT_EQ(base::Value::TYPE_BOOLEAN, sub.type());
 
   sub = schema.GetProperty("Integer");
@@ skipping 214 matching lines @@
   ASSERT_TRUE(sub.valid());
   ASSERT_EQ(base::Value::TYPE_LIST, sub.type());
   Schema subsub = sub.GetItems();
   ASSERT_TRUE(subsub.valid());
   ASSERT_EQ(base::Value::TYPE_LIST, subsub.type());
   Schema subsubsub = subsub.GetItems();
   ASSERT_TRUE(subsubsub.valid());
   ASSERT_EQ(base::Value::TYPE_STRING, subsubsub.type());
 }
 
+TEST(SchemaTest, Matches) {
+  std::string error;
+  Schema schema = Schema::Parse(kTestSchema, &error);
+  ASSERT_TRUE(schema.valid()) << error;
+
+  base::DictionaryValue bundle;
+  EXPECT_TRUE(schema.Matches(bundle));
+
+  // Wrong type, expected integer.
+  bundle.SetBoolean("Integer", true);
+  EXPECT_FALSE(schema.Matches(bundle));
+
+  // Wrong type, expected list of strings.
+  {
+    bundle.Clear();
+    base::ListValue list;
+    list.AppendInteger(1);
+    bundle.Set("Array", list.DeepCopy());
+    EXPECT_FALSE(schema.Matches(bundle));
+  }
+
+  // Wrong type in a sub-object.
+  {
+    bundle.Clear();
+    base::DictionaryValue dict;
+    dict.SetString("one", "one");
+    bundle.Set("Object", dict.DeepCopy());
+    EXPECT_FALSE(schema.Matches(bundle));
+  }
+
+  // Unknown name.
+  bundle.Clear();
+  bundle.SetBoolean("Unknown", true);
+  EXPECT_FALSE(schema.Matches(bundle));
+
+  // All of these will be valid.
+  bundle.Clear();
+  bundle.SetBoolean("Boolean", true);
+  bundle.SetInteger("Integer", 123);
+  bundle.Set("Null", base::Value::CreateNullValue());
+  bundle.Set("Number", base::Value::CreateDoubleValue(3.14));
+  bundle.SetString("String", "omg");
+
+  {
+    base::ListValue list;
+    list.AppendString("a string");
+    list.AppendString("another string");
+    bundle.Set("Array", list.DeepCopy());
+  }
+
+  {
+    base::DictionaryValue dict;
+    dict.SetString("one", "string");
+    dict.SetInteger("two", 2);
+    base::ListValue list;
+    list.Append(dict.DeepCopy());
+    list.Append(dict.DeepCopy());
+    bundle.Set("ArrayOfObjects", list.DeepCopy());
+  }
+
+  {
+    base::ListValue list;
+    list.AppendString("a string");
+    list.AppendString("another string");
+    base::ListValue listlist;
+    listlist.Append(list.DeepCopy());
+    listlist.Append(list.DeepCopy());
+    bundle.Set("ArrayOfArray", listlist.DeepCopy());
+  }
+
+  {
+    base::DictionaryValue dict;
+    dict.SetBoolean("one", true);
+    dict.SetInteger("two", 2);
+    dict.SetString("additionally", "a string");
+    dict.SetString("and also", "another string");
+    bundle.Set("Object", dict.DeepCopy());
+  }
+
+  EXPECT_TRUE(schema.Matches(bundle));
+
+  bundle.SetString("boom", "bang");
+  EXPECT_FALSE(schema.Matches(bundle));
+}
+
 }  // namespace policy