components/policy/core/common/schema_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/policy/core/common/schema.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/strings/stringprintf.h"
   9 #include "components/policy/core/common/schema_internal.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 namespace policy {
  13
  14 namespace {
  15
  16 #define TestSchemaValidation(a, b, c, d) \
  17     TestSchemaValidationHelper(          \
  18         base::StringPrintf("%s:%i", __FILE__, __LINE__), a, b, c, d)
  19
  20 const char kTestSchema[] =
  21     "{"
  22     "  \"type\": \"object\","
  23     "  \"properties\": {"
  24     "    \"Boolean\": { \"type\": \"boolean\" },"
  25     "    \"Integer\": { \"type\": \"integer\" },"
  26     "    \"Null\": { \"type\": \"null\" },"
  27     "    \"Number\": { \"type\": \"number\" },"
  28     "    \"String\": { \"type\": \"string\" },"
  29     "    \"Array\": {"
  30     "      \"type\": \"array\","
  31     "      \"items\": { \"type\": \"string\" }"
  32     "    },"
  33     "    \"ArrayOfObjects\": {"
  34     "      \"type\": \"array\","
  35     "      \"items\": {"
  36     "        \"type\": \"object\","
  37     "        \"properties\": {"
  38     "          \"one\": { \"type\": \"string\" },"
  39     "          \"two\": { \"type\": \"integer\" }"
  40     "        }"
  41     "      }"
  42     "    },"
  43     "    \"ArrayOfArray\": {"
  44     "      \"type\": \"array\","
  45     "      \"items\": {"
  46     "        \"type\": \"array\","
  47     "        \"items\": { \"type\": \"string\" }"
  48     "      }"
  49     "    },"
  50     "    \"Object\": {"
  51     "      \"type\": \"object\","
  52     "      \"properties\": {"
  53     "        \"one\": { \"type\": \"boolean\" },"
  54     "        \"two\": { \"type\": \"integer\" }"
  55     "      },"
  56     "      \"additionalProperties\": { \"type\": \"string\" }"
  57     "    },"
  58     "    \"ObjectOfObject\": {"
  59     "      \"type\": \"object\","
  60     "      \"properties\": {"
  61     "        \"Object\": {"
  62     "          \"type\": \"object\","
  63     "          \"properties\": {"
  64     "            \"one\": { \"type\": \"string\" },"
  65     "            \"two\": { \"type\": \"integer\" }"
  66     "          }"
  67     "        }"
  68     "      }"
  69     "    },"
  70     "    \"IntegerWithEnums\": {"
  71     "      \"type\": \"integer\","
  72     "      \"enum\": [1, 2, 3]"
  73     "    },"
  74     "    \"IntegerWithEnumsGaps\": {"
  75     "      \"type\": \"integer\","
  76     "      \"enum\": [10, 20, 30]"
  77     "    },"
  78     "    \"StringWithEnums\": {"
  79     "      \"type\": \"string\","
  80     "      \"enum\": [\"one\", \"two\", \"three\"]"
  81     "    },"
  82     "    \"IntegerWithRange\": {"
  83     "      \"type\": \"integer\","
  84     "      \"minimum\": 1,"
  85     "      \"maximum\": 3"
  86     "    },"
  87     "    \"ObjectOfArray\": {"
  88     "      \"type\": \"object\","
  89     "      \"properties\": {"
  90     "        \"List\": {"
  91     "          \"type\": \"array\","
  92     "          \"items\": { \"type\": \"integer\" }"
  93     "        }"
  94     "      }"
  95     "    },"
  96     "    \"ArrayOfObjectOfArray\": {"
  97     "      \"type\": \"array\","
  98     "      \"items\": {"
  99     "        \"type\": \"object\","
 100     "        \"properties\": {"
 101     "          \"List\": {"
 102     "            \"type\": \"array\","
 103     "            \"items\": { \"type\": \"string\" }"
 104     "          }"
 105     "        }"
 106     "      }"
 107     "    },"
 108     "    \"StringWithPattern\": {"
 109     "      \"type\": \"string\","
 110     "      \"pattern\": \"^foo+$\""
 111     "    },"
 112     "    \"ObjectWithPatternProperties\": {"
 113     "      \"type\": \"object\","
 114     "      \"patternProperties\": {"
 115     "        \"^foo+$\": { \"type\": \"integer\" },"
 116     "        \"^bar+$\": {"
 117     "          \"type\": \"string\","
 118     "          \"enum\": [\"one\", \"two\"]"
 119     "        }"
 120     "      },"
 121     "      \"properties\": {"
 122     "        \"bar\": {"
 123     "          \"type\": \"string\","
 124     "          \"enum\": [\"one\", \"three\"]"
 125     "        }"
 126     "      }"
 127     "    }"
 128     "  }"
 129     "}";
 130
 131 bool ParseFails(const std::string& content) {
 132   std::string error;
 133   Schema schema = Schema::Parse(content, &error);
 134   if (schema.valid())
 135     return false;
 136   EXPECT_FALSE(error.empty());
 137   return true;
 138 }
 139
 140 void TestSchemaValidationHelper(const std::string& source,
 141                                 Schema schema,
 142                                 const base::Value& value,
 143                                 SchemaOnErrorStrategy strategy,
 144                                 bool expected_return_value) {
 145   std::string error;
 146   static const char kNoErrorReturned[] = "No error returned.";
 147
 148   // Test that Schema::Validate() works as expected.
 149   error = kNoErrorReturned;
 150   bool returned = schema.Validate(value, strategy, NULL, &error);
 151   ASSERT_EQ(expected_return_value, returned) << source << ": " << error;
 152
 153   // Test that Schema::Normalize() will return the same value as
 154   // Schema::Validate().
 155   error = kNoErrorReturned;
 156   scoped_ptr<base::Value> cloned_value(value.DeepCopy());
 157   bool touched = false;
 158   returned =
 159       schema.Normalize(cloned_value.get(), strategy, NULL, &error, &touched);
 160   EXPECT_EQ(expected_return_value, returned) << source << ": " << error;
 161
 162   bool strictly_valid = schema.Validate(value, SCHEMA_STRICT, NULL, &error);
 163   EXPECT_EQ(touched, !strictly_valid && returned) << source;
 164
 165   // Test that Schema::Normalize() have actually dropped invalid and unknown
 166   // properties.
 167   if (expected_return_value) {
 168     EXPECT_TRUE(
 169         schema.Validate(*cloned_value.get(), SCHEMA_STRICT, NULL, &error))
 170         << source;
 171     EXPECT_TRUE(
 172         schema.Normalize(cloned_value.get(), SCHEMA_STRICT, NULL, &error, NULL))
 173         << source;
 174   }
 175 }
 176
 177 void TestSchemaValidationWithPath(Schema schema,
 178                                   const base::Value& value,
 179                                   const std::string& expected_failure_path) {
 180   std::string error_path = "NOT_SET";
 181   std::string error;
 182
 183   bool returned = schema.Validate(value, SCHEMA_STRICT, &error_path, &error);
 184   ASSERT_FALSE(returned) << error_path;
 185   EXPECT_EQ(error_path, expected_failure_path);
 186 }
 187
 188 std::string SchemaObjectWrapper(const std::string& subschema) {
 189   return "{"
 190          "  \"type\": \"object\","
 191          "  \"properties\": {"
 192          "    \"SomePropertyName\":" + subschema +
 193          "  }"
 194          "}";
 195 }
 196
 197 }  // namespace
 198
 199 TEST(SchemaTest, MinimalSchema) {
 200   EXPECT_FALSE(ParseFails("{ \"type\": \"object\" }"));
 201 }
 202
 203 TEST(SchemaTest, InvalidSchemas) {
 204   EXPECT_TRUE(ParseFails(""));
 205   EXPECT_TRUE(ParseFails("omg"));
 206   EXPECT_TRUE(ParseFails("\"omg\""));
 207   EXPECT_TRUE(ParseFails("123"));
 208   EXPECT_TRUE(ParseFails("[]"));
 209   EXPECT_TRUE(ParseFails("null"));
 210   EXPECT_TRUE(ParseFails("{}"));
 211
 212   EXPECT_TRUE(ParseFails(
 213       "{"
 214       "  \"type\": \"object\","
 215         "\"additionalProperties\": { \"type\":\"object\" }"
 216       "}"));
 217
 218   EXPECT_TRUE(ParseFails(
 219       "{"
 220       "  \"type\": \"object\","
 221       "  \"patternProperties\": { \"a+b*\": { \"type\": \"object\" } }"
 222       "}"));
 223
 224   EXPECT_TRUE(ParseFails(
 225       "{"
 226       "  \"type\": \"object\","
 227       "  \"properties\": { \"Policy\": { \"type\": \"bogus\" } }"
 228       "}"));
 229
 230   EXPECT_TRUE(ParseFails(
 231       "{"
 232       "  \"type\": \"object\","
 233       "  \"properties\": { \"Policy\": { \"type\": [\"string\", \"number\"] } }"
 234       "}"));
 235
 236   EXPECT_TRUE(ParseFails(
 237       "{"
 238       "  \"type\": \"object\","
 239       "  \"properties\": { \"Policy\": { \"type\": \"any\" } }"
 240       "}"));
 241
 242   EXPECT_TRUE(ParseFails(
 243       "{"
 244       "  \"type\": \"object\","
 245       "  \"properties\": { \"Policy\": 123 }"
 246       "}"));
 247
 248   EXPECT_FALSE(ParseFails(
 249       "{"
 250       "  \"type\": \"object\","
 251       "  \"unknown attribute\": \"is ignored\""
 252       "}"));
 253 }
 254
 255 TEST(SchemaTest, Ownership) {
 256   std::string error;
 257   Schema schema = Schema::Parse(
 258       "{"
 259       "  \"type\": \"object\","
 260       "  \"properties\": {"
 261       "    \"sub\": {"
 262       "      \"type\": \"object\","
 263       "      \"properties\": {"
 264       "        \"subsub\": { \"type\": \"string\" }"
 265       "      }"
 266       "    }"
 267       "  }"
 268       "}", &error);
 269   ASSERT_TRUE(schema.valid()) << error;
 270   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 271
 272   schema = schema.GetKnownProperty("sub");
 273   ASSERT_TRUE(schema.valid());
 274   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 275
 276   {
 277     Schema::Iterator it = schema.GetPropertiesIterator();
 278     ASSERT_FALSE(it.IsAtEnd());
 279     EXPECT_STREQ("subsub", it.key());
 280
 281     schema = it.schema();
 282     it.Advance();
 283     EXPECT_TRUE(it.IsAtEnd());
 284   }
 285
 286   ASSERT_TRUE(schema.valid());
 287   EXPECT_EQ(base::Value::TYPE_STRING, schema.type());
 288
 289   // This test shouldn't leak nor use invalid memory.
 290 }
 291
 292 TEST(SchemaTest, ValidSchema) {
 293   std::string error;
 294   Schema schema = Schema::Parse(kTestSchema, &error);
 295   ASSERT_TRUE(schema.valid()) << error;
 296
 297   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 298   EXPECT_FALSE(schema.GetProperty("invalid").valid());
 299
 300   Schema sub = schema.GetProperty("Boolean");
 301   ASSERT_TRUE(sub.valid());
 302   EXPECT_EQ(base::Value::TYPE_BOOLEAN, sub.type());
 303
 304   sub = schema.GetProperty("Integer");
 305   ASSERT_TRUE(sub.valid());
 306   EXPECT_EQ(base::Value::TYPE_INTEGER, sub.type());
 307
 308   sub = schema.GetProperty("Null");
 309   ASSERT_TRUE(sub.valid());
 310   EXPECT_EQ(base::Value::TYPE_NULL, sub.type());
 311
 312   sub = schema.GetProperty("Number");
 313   ASSERT_TRUE(sub.valid());
 314   EXPECT_EQ(base::Value::TYPE_DOUBLE, sub.type());
 315
 316   sub = schema.GetProperty("String");
 317   ASSERT_TRUE(sub.valid());
 318   EXPECT_EQ(base::Value::TYPE_STRING, sub.type());
 319
 320   sub = schema.GetProperty("Array");
 321   ASSERT_TRUE(sub.valid());
 322   ASSERT_EQ(base::Value::TYPE_LIST, sub.type());
 323   sub = sub.GetItems();
 324   ASSERT_TRUE(sub.valid());
 325   EXPECT_EQ(base::Value::TYPE_STRING, sub.type());
 326
 327   sub = schema.GetProperty("ArrayOfObjects");
 328   ASSERT_TRUE(sub.valid());
 329   ASSERT_EQ(base::Value::TYPE_LIST, sub.type());
 330   sub = sub.GetItems();
 331   ASSERT_TRUE(sub.valid());
 332   EXPECT_EQ(base::Value::TYPE_DICTIONARY, sub.type());
 333   Schema subsub = sub.GetProperty("one");
 334   ASSERT_TRUE(subsub.valid());
 335   EXPECT_EQ(base::Value::TYPE_STRING, subsub.type());
 336   subsub = sub.GetProperty("two");
 337   ASSERT_TRUE(subsub.valid());
 338   EXPECT_EQ(base::Value::TYPE_INTEGER, subsub.type());
 339   subsub = sub.GetProperty("invalid");
 340   EXPECT_FALSE(subsub.valid());
 341
 342   sub = schema.GetProperty("ArrayOfArray");
 343   ASSERT_TRUE(sub.valid());
 344   ASSERT_EQ(base::Value::TYPE_LIST, sub.type());
 345   sub = sub.GetItems();
 346   ASSERT_TRUE(sub.valid());
 347   ASSERT_EQ(base::Value::TYPE_LIST, sub.type());
 348   sub = sub.GetItems();
 349   ASSERT_TRUE(sub.valid());
 350   EXPECT_EQ(base::Value::TYPE_STRING, sub.type());
 351
 352   sub = schema.GetProperty("Object");
 353   ASSERT_TRUE(sub.valid());
 354   ASSERT_EQ(base::Value::TYPE_DICTIONARY, sub.type());
 355   subsub = sub.GetProperty("one");
 356   ASSERT_TRUE(subsub.valid());
 357   EXPECT_EQ(base::Value::TYPE_BOOLEAN, subsub.type());
 358   subsub = sub.GetProperty("two");
 359   ASSERT_TRUE(subsub.valid());
 360   EXPECT_EQ(base::Value::TYPE_INTEGER, subsub.type());
 361   subsub = sub.GetProperty("undeclared");
 362   ASSERT_TRUE(subsub.valid());
 363   EXPECT_EQ(base::Value::TYPE_STRING, subsub.type());
 364
 365   sub = schema.GetProperty("IntegerWithEnums");
 366   ASSERT_TRUE(sub.valid());
 367   ASSERT_EQ(base::Value::TYPE_INTEGER, sub.type());
 368
 369   sub = schema.GetProperty("IntegerWithEnumsGaps");
 370   ASSERT_TRUE(sub.valid());
 371   ASSERT_EQ(base::Value::TYPE_INTEGER, sub.type());
 372
 373   sub = schema.GetProperty("StringWithEnums");
 374   ASSERT_TRUE(sub.valid());
 375   ASSERT_EQ(base::Value::TYPE_STRING, sub.type());
 376
 377   sub = schema.GetProperty("IntegerWithRange");
 378   ASSERT_TRUE(sub.valid());
 379   ASSERT_EQ(base::Value::TYPE_INTEGER, sub.type());
 380
 381   sub = schema.GetProperty("StringWithPattern");
 382   ASSERT_TRUE(sub.valid());
 383   ASSERT_EQ(base::Value::TYPE_STRING, sub.type());
 384
 385   sub = schema.GetProperty("ObjectWithPatternProperties");
 386   ASSERT_TRUE(sub.valid());
 387   ASSERT_EQ(base::Value::TYPE_DICTIONARY, sub.type());
 388
 389   struct {
 390     const char* expected_key;
 391     base::Value::Type expected_type;
 392   } kExpectedProperties[] = {
 393     { "Array",                       base::Value::TYPE_LIST },
 394     { "ArrayOfArray",                base::Value::TYPE_LIST },
 395     { "ArrayOfObjectOfArray",        base::Value::TYPE_LIST },
 396     { "ArrayOfObjects",              base::Value::TYPE_LIST },
 397     { "Boolean",                     base::Value::TYPE_BOOLEAN },
 398     { "Integer",                     base::Value::TYPE_INTEGER },
 399     { "IntegerWithEnums",            base::Value::TYPE_INTEGER },
 400     { "IntegerWithEnumsGaps",        base::Value::TYPE_INTEGER },
 401     { "IntegerWithRange",            base::Value::TYPE_INTEGER },
 402     { "Null",                        base::Value::TYPE_NULL },
 403     { "Number",                      base::Value::TYPE_DOUBLE },
 404     { "Object",                      base::Value::TYPE_DICTIONARY },
 405     { "ObjectOfArray",               base::Value::TYPE_DICTIONARY },
 406     { "ObjectOfObject",              base::Value::TYPE_DICTIONARY },
 407     { "ObjectWithPatternProperties", base::Value::TYPE_DICTIONARY },
 408     { "String",                      base::Value::TYPE_STRING },
 409     { "StringWithEnums",             base::Value::TYPE_STRING },
 410     { "StringWithPattern",           base::Value::TYPE_STRING },
 411   };
 412   Schema::Iterator it = schema.GetPropertiesIterator();
 413   for (size_t i = 0; i < arraysize(kExpectedProperties); ++i) {
 414     ASSERT_FALSE(it.IsAtEnd());
 415     EXPECT_STREQ(kExpectedProperties[i].expected_key, it.key());
 416     ASSERT_TRUE(it.schema().valid());
 417     EXPECT_EQ(kExpectedProperties[i].expected_type, it.schema().type());
 418     it.Advance();
 419   }
 420   EXPECT_TRUE(it.IsAtEnd());
 421 }
 422
 423 TEST(SchemaTest, Lookups) {
 424   std::string error;
 425
 426   Schema schema = Schema::Parse("{ \"type\": \"object\" }", &error);
 427   ASSERT_TRUE(schema.valid()) << error;
 428   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 429
 430   // This empty schema should never find named properties.
 431   EXPECT_FALSE(schema.GetKnownProperty("").valid());
 432   EXPECT_FALSE(schema.GetKnownProperty("xyz").valid());
 433   EXPECT_TRUE(schema.GetPropertiesIterator().IsAtEnd());
 434
 435   schema = Schema::Parse(
 436       "{"
 437       "  \"type\": \"object\","
 438       "  \"properties\": {"
 439       "    \"Boolean\": { \"type\": \"boolean\" }"
 440       "  }"
 441       "}", &error);
 442   ASSERT_TRUE(schema.valid()) << error;
 443   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 444
 445   EXPECT_FALSE(schema.GetKnownProperty("").valid());
 446   EXPECT_FALSE(schema.GetKnownProperty("xyz").valid());
 447   EXPECT_TRUE(schema.GetKnownProperty("Boolean").valid());
 448
 449   schema = Schema::Parse(
 450       "{"
 451       "  \"type\": \"object\","
 452       "  \"properties\": {"
 453       "    \"bb\" : { \"type\": \"null\" },"
 454       "    \"aa\" : { \"type\": \"boolean\" },"
 455       "    \"abab\" : { \"type\": \"string\" },"
 456       "    \"ab\" : { \"type\": \"number\" },"
 457       "    \"aba\" : { \"type\": \"integer\" }"
 458       "  }"
 459       "}", &error);
 460   ASSERT_TRUE(schema.valid()) << error;
 461   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 462
 463   EXPECT_FALSE(schema.GetKnownProperty("").valid());
 464   EXPECT_FALSE(schema.GetKnownProperty("xyz").valid());
 465
 466   struct {
 467     const char* expected_key;
 468     base::Value::Type expected_type;
 469   } kExpectedKeys[] = {
 470     { "aa",     base::Value::TYPE_BOOLEAN },
 471     { "ab",     base::Value::TYPE_DOUBLE },
 472     { "aba",    base::Value::TYPE_INTEGER },
 473     { "abab",   base::Value::TYPE_STRING },
 474     { "bb",     base::Value::TYPE_NULL },
 475   };
 476   for (size_t i = 0; i < arraysize(kExpectedKeys); ++i) {
 477     Schema sub = schema.GetKnownProperty(kExpectedKeys[i].expected_key);
 478     ASSERT_TRUE(sub.valid());
 479     EXPECT_EQ(kExpectedKeys[i].expected_type, sub.type());
 480   }
 481 }
 482
 483 TEST(SchemaTest, Wrap) {
 484   const internal::SchemaNode kSchemas[] = {
 485     { base::Value::TYPE_DICTIONARY,   0 },    //  0: root node
 486     { base::Value::TYPE_BOOLEAN,      -1 },   //  1
 487     { base::Value::TYPE_INTEGER,      -1 },   //  2
 488     { base::Value::TYPE_DOUBLE,       -1 },   //  3
 489     { base::Value::TYPE_STRING,       -1 },   //  4
 490     { base::Value::TYPE_LIST,         4 },    //  5: list of strings.
 491     { base::Value::TYPE_LIST,         5 },    //  6: list of lists of strings.
 492     { base::Value::TYPE_INTEGER,      0 },    //  7: integer enumerations.
 493     { base::Value::TYPE_INTEGER,      1 },    //  8: ranged integers.
 494     { base::Value::TYPE_STRING,       2 },    //  9: string enumerations.
 495     { base::Value::TYPE_STRING,       3 },    // 10: string with pattern.
 496   };
 497
 498   const internal::PropertyNode kPropertyNodes[] = {
 499     { "Boolean",   1 },  // 0
 500     { "Integer",   2 },  // 1
 501     { "Number",    3 },  // 2
 502     { "String",    4 },  // 3
 503     { "List",      5 },  // 4
 504     { "IntEnum",   7 },  // 5
 505     { "RangedInt", 8 },  // 6
 506     { "StrEnum",   9 },  // 7
 507     { "StrPat",   10 },  // 8
 508     { "bar+$",     4 },  // 9
 509   };
 510
 511   const internal::PropertiesNode kProperties[] = {
 512     // 0 to 9 (exclusive) are the known properties in kPropertyNodes, 9 is
 513     // patternProperties and 6 is the additionalProperties node.
 514     { 0, 9, 10, 6 },
 515   };
 516
 517   const internal::RestrictionNode kRestriction[] = {
 518     {{0, 3}},  // 0: [1, 2, 3]
 519     {{5, 1}},  // 1: minimum = 1, maximum = 5
 520     {{0, 3}},  // 2: ["one", "two", "three"]
 521     {{3, 3}},  // 3: pattern "foo+"
 522   };
 523
 524   const int kIntEnums[] = {1, 2, 3};
 525
 526   const char* kStringEnums[] = {
 527     "one",    // 0
 528     "two",    // 1
 529     "three",  // 2
 530     "foo+",   // 3
 531   };
 532
 533   const internal::SchemaData kData = {
 534     kSchemas,
 535     kPropertyNodes,
 536     kProperties,
 537     kRestriction,
 538     kIntEnums,
 539     kStringEnums,
 540   };
 541
 542   Schema schema = Schema::Wrap(&kData);
 543   ASSERT_TRUE(schema.valid());
 544   EXPECT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 545
 546   struct {
 547     const char* key;
 548     base::Value::Type type;
 549   } kExpectedProperties[] = {
 550     { "Boolean", base::Value::TYPE_BOOLEAN },
 551     { "Integer", base::Value::TYPE_INTEGER },
 552     { "Number", base::Value::TYPE_DOUBLE },
 553     { "String", base::Value::TYPE_STRING },
 554     { "List", base::Value::TYPE_LIST },
 555     { "IntEnum", base::Value::TYPE_INTEGER },
 556     { "RangedInt", base::Value::TYPE_INTEGER },
 557     { "StrEnum", base::Value::TYPE_STRING },
 558     { "StrPat", base::Value::TYPE_STRING },
 559   };
 560
 561   Schema::Iterator it = schema.GetPropertiesIterator();
 562   for (size_t i = 0; i < arraysize(kExpectedProperties); ++i) {
 563     ASSERT_FALSE(it.IsAtEnd());
 564     EXPECT_STREQ(kExpectedProperties[i].key, it.key());
 565     Schema sub = it.schema();
 566     ASSERT_TRUE(sub.valid());
 567     EXPECT_EQ(kExpectedProperties[i].type, sub.type());
 568
 569     if (sub.type() == base::Value::TYPE_LIST) {
 570       Schema items = sub.GetItems();
 571       ASSERT_TRUE(items.valid());
 572       EXPECT_EQ(base::Value::TYPE_STRING, items.type());
 573     }
 574
 575     it.Advance();
 576   }
 577   EXPECT_TRUE(it.IsAtEnd());
 578
 579   Schema sub = schema.GetAdditionalProperties();
 580   ASSERT_TRUE(sub.valid());
 581   ASSERT_EQ(base::Value::TYPE_LIST, sub.type());
 582   Schema subsub = sub.GetItems();
 583   ASSERT_TRUE(subsub.valid());
 584   ASSERT_EQ(base::Value::TYPE_LIST, subsub.type());
 585   Schema subsubsub = subsub.GetItems();
 586   ASSERT_TRUE(subsubsub.valid());
 587   ASSERT_EQ(base::Value::TYPE_STRING, subsubsub.type());
 588
 589   SchemaList schema_list = schema.GetPatternProperties("barr");
 590   ASSERT_EQ(1u, schema_list.size());
 591   sub = schema_list[0];
 592   ASSERT_TRUE(sub.valid());
 593   EXPECT_EQ(base::Value::TYPE_STRING, sub.type());
 594
 595   EXPECT_TRUE(schema.GetPatternProperties("ba").empty());
 596   EXPECT_TRUE(schema.GetPatternProperties("bar+$").empty());
 597 }
 598
 599 TEST(SchemaTest, Validate) {
 600   std::string error;
 601   Schema schema = Schema::Parse(kTestSchema, &error);
 602   ASSERT_TRUE(schema.valid()) << error;
 603
 604   base::DictionaryValue bundle;
 605   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, true);
 606
 607   // Wrong type, expected integer.
 608   bundle.SetBoolean("Integer", true);
 609   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 610
 611   // Wrong type, expected list of strings.
 612   {
 613     bundle.Clear();
 614     base::ListValue list;
 615     list.AppendInteger(1);
 616     bundle.Set("Array", list.DeepCopy());
 617     TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 618   }
 619
 620   // Wrong type in a sub-object.
 621   {
 622     bundle.Clear();
 623     base::DictionaryValue dict;
 624     dict.SetString("one", "one");
 625     bundle.Set("Object", dict.DeepCopy());
 626     TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 627   }
 628
 629   // Unknown name.
 630   bundle.Clear();
 631   bundle.SetBoolean("Unknown", true);
 632   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 633
 634   // All of these will be valid.
 635   bundle.Clear();
 636   bundle.SetBoolean("Boolean", true);
 637   bundle.SetInteger("Integer", 123);
 638   bundle.Set("Null", base::Value::CreateNullValue());
 639   bundle.Set("Number", new base::FundamentalValue(3.14));
 640   bundle.SetString("String", "omg");
 641
 642   {
 643     base::ListValue list;
 644     list.AppendString("a string");
 645     list.AppendString("another string");
 646     bundle.Set("Array", list.DeepCopy());
 647   }
 648
 649   {
 650     base::DictionaryValue dict;
 651     dict.SetString("one", "string");
 652     dict.SetInteger("two", 2);
 653     base::ListValue list;
 654     list.Append(dict.DeepCopy());
 655     list.Append(dict.DeepCopy());
 656     bundle.Set("ArrayOfObjects", list.DeepCopy());
 657   }
 658
 659   {
 660     base::ListValue list;
 661     list.AppendString("a string");
 662     list.AppendString("another string");
 663     base::ListValue listlist;
 664     listlist.Append(list.DeepCopy());
 665     listlist.Append(list.DeepCopy());
 666     bundle.Set("ArrayOfArray", listlist.DeepCopy());
 667   }
 668
 669   {
 670     base::DictionaryValue dict;
 671     dict.SetBoolean("one", true);
 672     dict.SetInteger("two", 2);
 673     dict.SetString("additionally", "a string");
 674     dict.SetString("and also", "another string");
 675     bundle.Set("Object", dict.DeepCopy());
 676   }
 677
 678   bundle.SetInteger("IntegerWithEnums", 1);
 679   bundle.SetInteger("IntegerWithEnumsGaps", 20);
 680   bundle.SetString("StringWithEnums", "two");
 681   bundle.SetInteger("IntegerWithRange", 3);
 682
 683   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, true);
 684
 685   bundle.SetInteger("IntegerWithEnums", 0);
 686   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 687   bundle.SetInteger("IntegerWithEnums", 1);
 688
 689   bundle.SetInteger("IntegerWithEnumsGaps", 0);
 690   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 691   bundle.SetInteger("IntegerWithEnumsGaps", 9);
 692   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 693   bundle.SetInteger("IntegerWithEnumsGaps", 10);
 694   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, true);
 695   bundle.SetInteger("IntegerWithEnumsGaps", 11);
 696   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 697   bundle.SetInteger("IntegerWithEnumsGaps", 19);
 698   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 699   bundle.SetInteger("IntegerWithEnumsGaps", 21);
 700   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 701   bundle.SetInteger("IntegerWithEnumsGaps", 29);
 702   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 703   bundle.SetInteger("IntegerWithEnumsGaps", 30);
 704   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, true);
 705   bundle.SetInteger("IntegerWithEnumsGaps", 31);
 706   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 707   bundle.SetInteger("IntegerWithEnumsGaps", 100);
 708   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 709   bundle.SetInteger("IntegerWithEnumsGaps", 20);
 710
 711   bundle.SetString("StringWithEnums", "FOUR");
 712   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 713   bundle.SetString("StringWithEnums", "two");
 714
 715   bundle.SetInteger("IntegerWithRange", 4);
 716   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 717   bundle.SetInteger("IntegerWithRange", 3);
 718
 719   // Unknown top level property.
 720   bundle.SetString("boom", "bang");
 721   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 722   TestSchemaValidation(schema, bundle, SCHEMA_ALLOW_UNKNOWN_TOPLEVEL, true);
 723   TestSchemaValidation(schema, bundle, SCHEMA_ALLOW_UNKNOWN, true);
 724   TestSchemaValidationWithPath(schema, bundle, "");
 725   bundle.Remove("boom", NULL);
 726
 727   // Invalid top level property.
 728   bundle.SetInteger("Boolean", 12345);
 729   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, false);
 730   TestSchemaValidation(schema, bundle, SCHEMA_ALLOW_INVALID_TOPLEVEL, true);
 731   TestSchemaValidation(schema, bundle, SCHEMA_ALLOW_INVALID, true);
 732   TestSchemaValidationWithPath(schema, bundle, "Boolean");
 733   bundle.SetBoolean("Boolean", true);
 734
 735   // Tests on ObjectOfObject.
 736   {
 737     Schema subschema = schema.GetProperty("ObjectOfObject");
 738     ASSERT_TRUE(subschema.valid());
 739     base::DictionaryValue root;
 740
 741     // Unknown property.
 742     root.SetBoolean("Object.three", false);
 743     TestSchemaValidation(subschema, root, SCHEMA_STRICT, false);
 744     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN_TOPLEVEL, false);
 745     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN, true);
 746     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID_TOPLEVEL, true);
 747     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID, true);
 748     TestSchemaValidationWithPath(subschema, root, "Object");
 749     root.Remove("Object.three", NULL);
 750
 751     // Invalid property.
 752     root.SetInteger("Object.one", 12345);
 753     TestSchemaValidation(subschema, root, SCHEMA_STRICT, false);
 754     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN_TOPLEVEL, false);
 755     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN, false);
 756     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID_TOPLEVEL, true);
 757     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID, true);
 758     TestSchemaValidationWithPath(subschema, root, "Object.one");
 759     root.Remove("Object.one", NULL);
 760   }
 761
 762   // Tests on ArrayOfObjects.
 763   {
 764     Schema subschema = schema.GetProperty("ArrayOfObjects");
 765     ASSERT_TRUE(subschema.valid());
 766     base::ListValue root;
 767
 768     // Unknown property.
 769     base::DictionaryValue* dict_value = new base::DictionaryValue();
 770     dict_value->SetBoolean("three", true);
 771     root.Append(dict_value);  // Pass ownership to root.
 772     TestSchemaValidation(subschema, root, SCHEMA_STRICT, false);
 773     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN_TOPLEVEL, false);
 774     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN, true);
 775     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID_TOPLEVEL, true);
 776     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID, true);
 777     TestSchemaValidationWithPath(subschema, root, "items[0]");
 778     root.Remove(root.GetSize() - 1, NULL);
 779
 780     // Invalid property.
 781     dict_value = new base::DictionaryValue();
 782     dict_value->SetBoolean("two", true);
 783     root.Append(dict_value);  // Pass ownership to root.
 784     TestSchemaValidation(subschema, root, SCHEMA_STRICT, false);
 785     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN_TOPLEVEL, false);
 786     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN, false);
 787     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID_TOPLEVEL, true);
 788     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID, true);
 789     TestSchemaValidationWithPath(subschema, root, "items[0].two");
 790     root.Remove(root.GetSize() - 1, NULL);
 791   }
 792
 793   // Tests on ObjectOfArray.
 794   {
 795     Schema subschema = schema.GetProperty("ObjectOfArray");
 796     ASSERT_TRUE(subschema.valid());
 797     base::DictionaryValue root;
 798
 799     base::ListValue* list_value = new base::ListValue();
 800     root.Set("List", list_value);  // Pass ownership to root.
 801
 802     // Test that there are not errors here.
 803     list_value->Append(new base::FundamentalValue(12345));
 804     TestSchemaValidation(subschema, root, SCHEMA_STRICT, true);
 805     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN_TOPLEVEL, true);
 806     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN, true);
 807     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID_TOPLEVEL, true);
 808     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID, true);
 809
 810     // Invalid list item.
 811     list_value->Append(new base::StringValue("blabla"));
 812     TestSchemaValidation(subschema, root, SCHEMA_STRICT, false);
 813     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN_TOPLEVEL, false);
 814     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN, false);
 815     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID_TOPLEVEL, true);
 816     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID, true);
 817     TestSchemaValidationWithPath(subschema, root, "List.items[1]");
 818   }
 819
 820   // Tests on ArrayOfObjectOfArray.
 821   {
 822     Schema subschema = schema.GetProperty("ArrayOfObjectOfArray");
 823     ASSERT_TRUE(subschema.valid());
 824     base::ListValue root;
 825
 826     base::ListValue* list_value = new base::ListValue();
 827     base::DictionaryValue* dict_value = new base::DictionaryValue();
 828     dict_value->Set("List", list_value);  // Pass ownership to dict_value.
 829     root.Append(dict_value);  // Pass ownership to root.
 830
 831     // Test that there are not errors here.
 832     list_value->Append(new base::StringValue("blabla"));
 833     TestSchemaValidation(subschema, root, SCHEMA_STRICT, true);
 834     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN_TOPLEVEL, true);
 835     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN, true);
 836     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID_TOPLEVEL, true);
 837     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID, true);
 838
 839     // Invalid list item.
 840     list_value->Append(new base::FundamentalValue(12345));
 841     TestSchemaValidation(subschema, root, SCHEMA_STRICT, false);
 842     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN_TOPLEVEL, false);
 843     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN, false);
 844     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID_TOPLEVEL, true);
 845     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_INVALID, true);
 846     TestSchemaValidationWithPath(subschema, root, "items[0].List.items[1]");
 847   }
 848
 849   // Tests on StringWithPattern.
 850   {
 851     Schema subschema = schema.GetProperty("StringWithPattern");
 852     ASSERT_TRUE(subschema.valid());
 853
 854     TestSchemaValidation(
 855         subschema, base::StringValue("foobar"), SCHEMA_STRICT, false);
 856     TestSchemaValidation(
 857         subschema, base::StringValue("foo"), SCHEMA_STRICT, true);
 858     TestSchemaValidation(
 859         subschema, base::StringValue("fo"), SCHEMA_STRICT, false);
 860     TestSchemaValidation(
 861         subschema, base::StringValue("fooo"), SCHEMA_STRICT, true);
 862     TestSchemaValidation(
 863         subschema, base::StringValue("^foo+$"), SCHEMA_STRICT, false);
 864   }
 865
 866   // Tests on ObjectWithPatternProperties.
 867   {
 868     Schema subschema = schema.GetProperty("ObjectWithPatternProperties");
 869     ASSERT_TRUE(subschema.valid());
 870     base::DictionaryValue root;
 871
 872     ASSERT_EQ(1u, subschema.GetPatternProperties("fooo").size());
 873     ASSERT_EQ(1u, subschema.GetPatternProperties("foo").size());
 874     ASSERT_EQ(1u, subschema.GetPatternProperties("barr").size());
 875     ASSERT_EQ(1u, subschema.GetPatternProperties("bar").size());
 876     ASSERT_EQ(1u, subschema.GetMatchingProperties("fooo").size());
 877     ASSERT_EQ(1u, subschema.GetMatchingProperties("foo").size());
 878     ASSERT_EQ(1u, subschema.GetMatchingProperties("barr").size());
 879     ASSERT_EQ(2u, subschema.GetMatchingProperties("bar").size());
 880     ASSERT_TRUE(subschema.GetPatternProperties("foobar").empty());
 881
 882     root.SetInteger("fooo", 123);
 883     TestSchemaValidation(subschema, root, SCHEMA_STRICT, true);
 884     root.SetBoolean("fooo", false);
 885     TestSchemaValidation(subschema, root, SCHEMA_STRICT, false);
 886     root.Remove("fooo", NULL);
 887
 888     root.SetInteger("foo", 123);
 889     TestSchemaValidation(subschema, root, SCHEMA_STRICT, true);
 890     root.SetBoolean("foo", false);
 891     TestSchemaValidation(subschema, root, SCHEMA_STRICT, false);
 892     root.Remove("foo", NULL);
 893
 894     root.SetString("barr", "one");
 895     TestSchemaValidation(subschema, root, SCHEMA_STRICT, true);
 896     root.SetString("barr", "three");
 897     TestSchemaValidation(subschema, root, SCHEMA_STRICT, false);
 898     root.SetBoolean("barr", false);
 899     TestSchemaValidation(subschema, root, SCHEMA_STRICT, false);
 900     root.Remove("barr", NULL);
 901
 902     root.SetString("bar", "one");
 903     TestSchemaValidation(subschema, root, SCHEMA_STRICT, true);
 904     root.SetString("bar", "two");
 905     TestSchemaValidation(subschema, root, SCHEMA_STRICT, false);
 906     root.SetString("bar", "three");
 907     TestSchemaValidation(subschema, root, SCHEMA_STRICT, false);
 908     root.Remove("bar", NULL);
 909
 910     root.SetInteger("foobar", 123);
 911     TestSchemaValidation(subschema, root, SCHEMA_STRICT, false);
 912     TestSchemaValidation(subschema, root, SCHEMA_ALLOW_UNKNOWN, true);
 913     root.Remove("foobar", NULL);
 914   }
 915
 916   // Test that integer to double promotion is allowed.
 917   bundle.SetInteger("Number", 31415);
 918   TestSchemaValidation(schema, bundle, SCHEMA_STRICT, true);
 919 }
 920
 921 TEST(SchemaTest, InvalidReferences) {
 922   // References to undeclared schemas fail.
 923   EXPECT_TRUE(ParseFails(
 924       "{"
 925       "  \"type\": \"object\","
 926       "  \"properties\": {"
 927       "    \"name\": { \"$ref\": \"undeclared\" }"
 928       "  }"
 929       "}"));
 930
 931   // Can't refer to self.
 932   EXPECT_TRUE(ParseFails(
 933       "{"
 934       "  \"type\": \"object\","
 935       "  \"properties\": {"
 936       "    \"name\": {"
 937       "      \"id\": \"self\","
 938       "      \"$ref\": \"self\""
 939       "    }"
 940       "  }"
 941       "}"));
 942
 943   // Duplicated IDs are invalid.
 944   EXPECT_TRUE(ParseFails(
 945       "{"
 946       "  \"type\": \"object\","
 947       "  \"properties\": {"
 948       "    \"name\": {"
 949       "      \"id\": \"x\","
 950       "      \"type\": \"string\""
 951       "    },"
 952       "    \"another\": {"
 953       "      \"id\": \"x\","
 954       "      \"type\": \"string\""
 955       "    }"
 956       "  }"
 957       "}"));
 958
 959   // Main object can't be a reference.
 960   EXPECT_TRUE(ParseFails(
 961       "{"
 962       "  \"type\": \"object\","
 963       "  \"id\": \"main\","
 964       "  \"$ref\": \"main\""
 965       "}"));
 966
 967   EXPECT_TRUE(ParseFails(
 968       "{"
 969       "  \"type\": \"object\","
 970       "  \"$ref\": \"main\""
 971       "}"));
 972 }
 973
 974 TEST(SchemaTest, RecursiveReferences) {
 975   // Verifies that references can go to a parent schema, to define a
 976   // recursive type.
 977   std::string error;
 978   Schema schema = Schema::Parse(
 979       "{"
 980       "  \"type\": \"object\","
 981       "  \"properties\": {"
 982       "    \"bookmarks\": {"
 983       "      \"type\": \"array\","
 984       "      \"id\": \"ListOfBookmarks\","
 985       "      \"items\": {"
 986       "        \"type\": \"object\","
 987       "        \"properties\": {"
 988       "          \"name\": { \"type\": \"string\" },"
 989       "          \"url\": { \"type\": \"string\" },"
 990       "          \"children\": { \"$ref\": \"ListOfBookmarks\" }"
 991       "        }"
 992       "      }"
 993       "    }"
 994       "  }"
 995       "}", &error);
 996   ASSERT_TRUE(schema.valid()) << error;
 997   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
 998
 999   Schema parent = schema.GetKnownProperty("bookmarks");
1000   ASSERT_TRUE(parent.valid());
1001   ASSERT_EQ(base::Value::TYPE_LIST, parent.type());
1002
1003   // Check the recursive type a number of times.
1004   for (int i = 0; i < 10; ++i) {
1005     Schema items = parent.GetItems();
1006     ASSERT_TRUE(items.valid());
1007     ASSERT_EQ(base::Value::TYPE_DICTIONARY, items.type());
1008
1009     Schema prop = items.GetKnownProperty("name");
1010     ASSERT_TRUE(prop.valid());
1011     ASSERT_EQ(base::Value::TYPE_STRING, prop.type());
1012
1013     prop = items.GetKnownProperty("url");
1014     ASSERT_TRUE(prop.valid());
1015     ASSERT_EQ(base::Value::TYPE_STRING, prop.type());
1016
1017     prop = items.GetKnownProperty("children");
1018     ASSERT_TRUE(prop.valid());
1019     ASSERT_EQ(base::Value::TYPE_LIST, prop.type());
1020
1021     parent = prop;
1022   }
1023 }
1024
1025 TEST(SchemaTest, UnorderedReferences) {
1026   // Verifies that references and IDs can come in any order.
1027   std::string error;
1028   Schema schema = Schema::Parse(
1029       "{"
1030       "  \"type\": \"object\","
1031       "  \"properties\": {"
1032       "    \"a\": { \"$ref\": \"shared\" },"
1033       "    \"b\": { \"$ref\": \"shared\" },"
1034       "    \"c\": { \"$ref\": \"shared\" },"
1035       "    \"d\": { \"$ref\": \"shared\" },"
1036       "    \"e\": {"
1037       "      \"type\": \"boolean\","
1038       "      \"id\": \"shared\""
1039       "    },"
1040       "    \"f\": { \"$ref\": \"shared\" },"
1041       "    \"g\": { \"$ref\": \"shared\" },"
1042       "    \"h\": { \"$ref\": \"shared\" },"
1043       "    \"i\": { \"$ref\": \"shared\" }"
1044       "  }"
1045       "}", &error);
1046   ASSERT_TRUE(schema.valid()) << error;
1047   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
1048
1049   for (char c = 'a'; c <= 'i'; ++c) {
1050     Schema sub = schema.GetKnownProperty(std::string(1, c));
1051     ASSERT_TRUE(sub.valid()) << c;
1052     ASSERT_EQ(base::Value::TYPE_BOOLEAN, sub.type()) << c;
1053   }
1054 }
1055
1056 TEST(SchemaTest, AdditionalPropertiesReference) {
1057   // Verifies that "additionalProperties" can be a reference.
1058   std::string error;
1059   Schema schema = Schema::Parse(
1060       "{"
1061       "  \"type\": \"object\","
1062       "  \"properties\": {"
1063       "    \"policy\": {"
1064       "      \"type\": \"object\","
1065       "      \"properties\": {"
1066       "        \"foo\": {"
1067       "          \"type\": \"boolean\","
1068       "          \"id\": \"FooId\""
1069       "        }"
1070       "      },"
1071       "      \"additionalProperties\": { \"$ref\": \"FooId\" }"
1072       "    }"
1073       "  }"
1074       "}", &error);
1075   ASSERT_TRUE(schema.valid()) << error;
1076   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
1077
1078   Schema policy = schema.GetKnownProperty("policy");
1079   ASSERT_TRUE(policy.valid());
1080   ASSERT_EQ(base::Value::TYPE_DICTIONARY, policy.type());
1081
1082   Schema foo = policy.GetKnownProperty("foo");
1083   ASSERT_TRUE(foo.valid());
1084   EXPECT_EQ(base::Value::TYPE_BOOLEAN, foo.type());
1085
1086   Schema additional = policy.GetAdditionalProperties();
1087   ASSERT_TRUE(additional.valid());
1088   EXPECT_EQ(base::Value::TYPE_BOOLEAN, additional.type());
1089
1090   Schema x = policy.GetProperty("x");
1091   ASSERT_TRUE(x.valid());
1092   EXPECT_EQ(base::Value::TYPE_BOOLEAN, x.type());
1093 }
1094
1095 TEST(SchemaTest, ItemsReference) {
1096   // Verifies that "items" can be a reference.
1097   std::string error;
1098   Schema schema = Schema::Parse(
1099       "{"
1100       "  \"type\": \"object\","
1101       "  \"properties\": {"
1102       "    \"foo\": {"
1103       "      \"type\": \"boolean\","
1104       "      \"id\": \"FooId\""
1105       "    },"
1106       "    \"list\": {"
1107       "      \"type\": \"array\","
1108       "      \"items\": { \"$ref\": \"FooId\" }"
1109       "    }"
1110       "  }"
1111       "}", &error);
1112   ASSERT_TRUE(schema.valid()) << error;
1113   ASSERT_EQ(base::Value::TYPE_DICTIONARY, schema.type());
1114
1115   Schema foo = schema.GetKnownProperty("foo");
1116   ASSERT_TRUE(foo.valid());
1117   EXPECT_EQ(base::Value::TYPE_BOOLEAN, foo.type());
1118
1119   Schema list = schema.GetKnownProperty("list");
1120   ASSERT_TRUE(list.valid());
1121   ASSERT_EQ(base::Value::TYPE_LIST, list.type());
1122
1123   Schema items = list.GetItems();
1124   ASSERT_TRUE(items.valid());
1125   ASSERT_EQ(base::Value::TYPE_BOOLEAN, items.type());
1126 }
1127
1128 TEST(SchemaTest, EnumerationRestriction) {
1129   // Enum attribute is a list.
1130   EXPECT_TRUE(ParseFails(SchemaObjectWrapper(
1131       "{"
1132       "  \"type\": \"string\","
1133       "  \"enum\": 12"
1134       "}")));
1135
1136   // Empty enum attributes is not allowed.
1137   EXPECT_TRUE(ParseFails(SchemaObjectWrapper(
1138       "{"
1139       "  \"type\": \"integer\","
1140       "  \"enum\": []"
1141       "}")));
1142
1143   // Enum elements type should be same as stated.
1144   EXPECT_TRUE(ParseFails(SchemaObjectWrapper(
1145       "{"
1146       "  \"type\": \"string\","
1147       "  \"enum\": [1, 2, 3]"
1148       "}")));
1149
1150   EXPECT_FALSE(ParseFails(SchemaObjectWrapper(
1151       "{"
1152       "  \"type\": \"integer\","
1153       "  \"enum\": [1, 2, 3]"
1154       "}")));
1155
1156   EXPECT_FALSE(ParseFails(SchemaObjectWrapper(
1157       "{"
1158       "  \"type\": \"string\","
1159       "  \"enum\": [\"1\", \"2\", \"3\"]"
1160       "}")));
1161 }
1162
1163 TEST(SchemaTest, RangedRestriction) {
1164   EXPECT_TRUE(ParseFails(SchemaObjectWrapper(
1165       "{"
1166       "  \"type\": \"integer\","
1167       "  \"minimum\": 10,"
1168       "  \"maximum\": 5"
1169       "}")));
1170
1171   EXPECT_FALSE(ParseFails(SchemaObjectWrapper(
1172       "{"
1173       "  \"type\": \"integer\","
1174       "  \"minimum\": 10,"
1175       "  \"maximum\": 20"
1176       "}")));
1177 }
1178
1179 }  // namespace policy