Allow omitting optional parameters for Extensions API functions

chrome/test/data/extensions/json_schema_test.js

 // Copyright (c) 2011 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.
 
 function assert(truth) {
   if (!truth)
     throw new Error("Assertion failed.");
 }
 
 function assertValid(type, instance, schema, types) {
@@ skipping 21 matching lines @@
       log("Got expected error: " + validator.errors[i].message + " for path: " +
           validator.errors[i].path);
     } else {
       log("Missed expected error: " + errors[i] + ". Got: " +
           validator.errors[i].message + " instead.");
       assert(false);
     }
   }
 }
 
+function assertListConsistsOfElements(list, elements) {
+  for (var li = 0; li < list.length; li++) {
+    for (var ei = 0; ei < elements.length && list[li] != elements[ei]; ei++) { }
+    if (ei == elements.length) {
+      log("Expected type not found: " + list[li]);
+      assert(false);
+    }
+  }
+}
+
+function assertEqualSets(set1, set2) {
+  assertListConsistsOfElements(set1, set2);
+  assertListConsistsOfElements(set2, set1);
+}
+
 function formatError(key, replacements) {
   return chromeHidden.JSONSchemaValidator.formatError(key, replacements);
 }
 
 function testFormatError() {
   assert(formatError("propertyRequired") == "Property is required.");
   assert(formatError("invalidEnum", ["foo, bar"]) ==
          "Value must be one of: [foo, bar].");
   assert(formatError("invalidType", ["foo", "bar"]) ==
          "Expected 'foo' but got 'bar'.");
@@ skipping 422 matching lines @@
                  [formatError("invalidType", ["integer", "number"])]);
   assertNotValid("Type", 1, {type: "boolean"},
                  [formatError("invalidType", ["boolean", "integer"])]);
   assertNotValid("Type", false, {type: "null"},
                  [formatError("invalidType", ["null", "boolean"])]);
   assertNotValid("Type", undefined, {type: "null"},
                  [formatError("invalidType", ["null", "undefined"])]);
   assertNotValid("Type", {}, {type: "function"},
                  [formatError("invalidType", ["function", "object"])]);
 }
+
+function testGetAllTypesForSchema() {
+  var referencedTypes = [
+    {
+      id: "ChoicesRef",
+      choices: [
+        { type: "integer" },
+        { type: "string" }
+      ]
+    },
+    {
+      id: "ObjectRef",
+      type: "object",
+    }
+  ];
+
+  var arraySchema = {
+    type: "array"
+  };
+
+  var choicesSchema = {
+    choices: [
+      { type: "object" },
+      { type: "function" }
+    ]
+  };
+
+  var objectRefSchema = {
+    $ref: "ObjectRef"
+  };
+
+  var complexSchema = {
+    choices: [
+      { $ref: "ChoicesRef" },
+      { type: "function" },
+      { $ref: "ObjectRef" }
+    ]
+  };
+
+  var validator = new chromeHidden.JSONSchemaValidator();
+  validator.addTypes(referencedTypes);
+
+  var arraySchemaTypes = validator.getAllTypesForSchema(arraySchema);
+  assertEqualSets(arraySchemaTypes, ["array"]);
+
+  var choicesSchemaTypes = validator.getAllTypesForSchema(choicesSchema);
+  assertEqualSets(choicesSchemaTypes, ["object", "function"]);
+
+  var objectRefSchemaTypes = validator.getAllTypesForSchema(objectRefSchema);
+  assertEqualSets(objectRefSchemaTypes, ["object"]);
+
+  var complexSchemaTypes = validator.getAllTypesForSchema(complexSchema);
+  assertEqualSets(complexSchemaTypes,
+      ["integer", "string", "function", "object"]);
+}
+
+function testIsValidSchemaType() {
+  var referencedTypes = [
+    {
+      id: "ChoicesRef",
+      choices: [
+        { type: "integer" },
+        { type: "string" }
+      ]
+    }
+  ];
+
+  var objectSchema = {
+    type: "object",
+    optional: true
+  };
+
+  var complexSchema = {
+    choices: [
+      { $ref: "ChoicesRef" },
+      { type: "function" },
+    ]
+  };
+
+  var validator = new chromeHidden.JSONSchemaValidator();
+  validator.addTypes(referencedTypes);
+
+  assert(validator.isValidSchemaType("object", objectSchema));
+  assert(!validator.isValidSchemaType("integer", objectSchema));
+  assert(!validator.isValidSchemaType("array", objectSchema));
+  assert(validator.isValidSchemaType("null", objectSchema));
+  assert(validator.isValidSchemaType("undefined", objectSchema));
+
+  assert(validator.isValidSchemaType("integer", complexSchema));
+  assert(validator.isValidSchemaType("function", complexSchema));
+  assert(validator.isValidSchemaType("string", complexSchema));
+  assert(!validator.isValidSchemaType("object", complexSchema));
+  assert(!validator.isValidSchemaType("null", complexSchema));
+  assert(!validator.isValidSchemaType("undefined", complexSchema));
+}
+
+function testCheckSchemaOverlap() {
+  var referencedTypes = [
+    {
+      id: "ChoicesRef",
+      choices: [
+        { type: "integer" },
+        { type: "string" }
+      ]
+    },
+    {
+      id: "ObjectRef",
+      type: "object",
+    }
+  ];
+
+  var arraySchema = {
+    type: "array"
+  };
+
+  var choicesSchema = {
+    choices: [
+      { type: "object" },
+      { type: "function" }
+    ]
+  };
+
+  var objectRefSchema = {
+    $ref: "ObjectRef"
+  };
+
+  var complexSchema = {
+    choices: [
+      { $ref: "ChoicesRef" },
+      { type: "function" },
+      { $ref: "ObjectRef" }
+    ]
+  };
+
+  var validator = new chromeHidden.JSONSchemaValidator();
+  validator.addTypes(referencedTypes);
+
+  assert(!validator.checkSchemaOverlap(arraySchema, choicesSchema));
+  assert(!validator.checkSchemaOverlap(arraySchema, objectRefSchema));
+  assert(!validator.checkSchemaOverlap(arraySchema, complexSchema));
+  assert(validator.checkSchemaOverlap(choicesSchema, objectRefSchema));
+  assert(validator.checkSchemaOverlap(choicesSchema, complexSchema));
+  assert(validator.checkSchemaOverlap(objectRefSchema, complexSchema));
+}