Import wpt@758b3b4cfa805067f36121333ba031e583d3a62c

third_party/WebKit/LayoutTests/external/wpt/resources/idlharness.js

 /*
 Distributed under both the W3C Test Suite License [1] and the W3C
 3-clause BSD License [2]. To contribute to a W3C Test Suite, see the
 policies and contribution forms [3].
 
 [1] http://www.w3.org/Consortium/Legal/2008/04-testsuite-license
 [2] http://www.w3.org/Consortium/Legal/2008/03-bsd-license
 [3] http://www.w3.org/2004/10/27-testcases
 */
 
@@ skipping 304 matching lines @@
     {
         ret = ret.concat(this.recursively_get_implements(ret[i]));
         if (ret.indexOf(ret[i]) != ret.lastIndexOf(ret[i]))
         {
             throw "Circular implements statements involving " + ret[i];
         }
     }
     return ret;
 };
 
+function exposure_set(object, default_set) {
+    var exposed = object.extAttrs.filter(function(a) { return a.name == "Exposed" });
+    if (exposed.length > 1 || exposed.length < 0) {
+        throw "Unexpected Exposed extended attributes on " + memberName + ": " + exposed;
+    }
+
+    if (exposed.length === 0) {
+        return default_set;
+    }
+
+    var set = exposed[0].rhs.value;
+    // Could be a list or a string.
+    if (typeof set == "string") {
+        set = [ set ];
+    }
+    return set;
+}
+
 function exposed_in(globals) {
     if ('document' in self) {
         return globals.indexOf("Window") >= 0;
     }
     if ('DedicatedWorkerGlobalScope' in self &&
         self instanceof DedicatedWorkerGlobalScope) {
         return globals.indexOf("Worker") >= 0 ||
                globals.indexOf("DedicatedWorker") >= 0;
     }
     if ('SharedWorkerGlobalScope' in self &&
@@ skipping 54 matching lines @@
         }.bind(this));
     }
     this["implements"] = {};
 
     Object.getOwnPropertyNames(this.members).forEach(function(memberName) {
         var member = this.members[memberName];
         if (!(member instanceof IdlInterface)) {
             return;
         }
 
-        var exposed = member.extAttrs.filter(function(a) { return a.name == "Exposed" });
-        if (exposed.length > 1) {
-            throw "Unexpected Exposed extended attributes on " + memberName + ": " + exposed;
-        }
-
-        var globals = exposed.length === 1
-                    ? exposed[0].rhs.value
-                    : ["Window"];
+        var globals = exposure_set(member, ["Window"]);
         member.exposed = exposed_in(globals);
+        member.exposureSet = globals;
     }.bind(this));
 
     // Now run test() on every member, and test_object() for every object.
     for (var name in this.members)
     {
         this.members[name].test();
         if (name in this.objects)
         {
             this.objects[name].forEach(function(str)
             {
@@ skipping 33 matching lines @@
     }
 
     if (type.sequence)
     {
         assert_true(Array.isArray(value), "is not array");
         if (!value.length)
         {
             // Nothing we can do.
             return;
         }
-        this.assert_type_is(value[0], type.idlType.idlType);
+        this.assert_type_is(value[0], type.idlType);
         return;
     }
 
     if (type.generic === "Promise") {
         assert_true("then" in value, "Attribute with a Promise type has a then property");
         // TODO: Ideally, we would check on project fulfillment
         // that we get the right type
         // but that would require making the type check async
         return;
     }
 
+    if (type.generic === "FrozenArray") {
+        assert_true(Array.isArray(value), "Value should be array");
+        assert_true(Object.isFrozen(value), "Value should be frozen");
+        if (!value.length)
+        {
+            // Nothing we can do.
+            return;
+        }
+        this.assert_type_is(value[0], type.idlType);
+        return;
+    }
+
     type = type.idlType;
 
     switch(type)
     {
         case "void":
             assert_equals(value, undefined);
             return;
 
         case "boolean":
             assert_equals(typeof value, "boolean");
@@ skipping 485 matching lines @@
         // [NoInterfaceObject].)
         // TODO: Aryeh thinks there's at least other place in this file where
         //       we try to figure out if an interface prototype object is
         //       correct. Consolidate that code.
 
         // "The interface prototype object for a given interface A must have an
         // internal [[Prototype]] property whose value is returned from the
         // following steps:
         // "If A is declared with the [Global] or [PrimaryGlobal] extended
         // attribute, and A supports named properties, then return the named
-        // properties object for A, as defined in section 4.5.5 below.
+        // properties object for A, as defined in §3.6.4 Named properties
+        // object.
         // "Otherwise, if A is declared to inherit from another interface, then
         // return the interface prototype object for the inherited interface.
-        // "Otherwise, if A is declared with the [ArrayClass] extended
-        // attribute, then return %ArrayPrototype% ([ECMA-262], section
-        // 6.1.7.4).
-        // "Otherwise, return %ObjectPrototype% ([ECMA-262], section 6.1.7.4).
-        // ([ECMA-262], section 15.2.4).
+        // "Otherwise, if A is declared with the [LegacyArrayClass] extended
+        // attribute, then return %ArrayPrototype%.
+        // "Otherwise, return %ObjectPrototype%.
         if (this.name === "Window") {
             assert_class_string(Object.getPrototypeOf(self[this.name].prototype),
                                 'WindowProperties',
                                 'Class name for prototype of Window' +
                                 '.prototype is not "WindowProperties"');
         } else {
             var inherit_interface, inherit_interface_has_interface_object;
             if (this.base) {
                 inherit_interface = this.base;
                 inherit_interface_has_interface_object =
                     !this.array
                          .members[inherit_interface]
                          .has_extended_attribute("NoInterfaceObject");
-            } else if (this.has_extended_attribute('ArrayClass')) {
+            } else if (this.has_extended_attribute('LegacyArrayClass')) {
                 inherit_interface = 'Array';
                 inherit_interface_has_interface_object = true;
             } else {
                 inherit_interface = 'Object';
                 inherit_interface_has_interface_object = true;
             }
             if (inherit_interface_has_interface_object) {
                 assert_own_property(self, inherit_interface,
                                     'should inherit from ' + inherit_interface + ', but self has no such property');
                 assert_own_property(self[inherit_interface], 'prototype',
@@ skipping 342 matching lines @@
                       "calling operation with this = {} didn't throw TypeError", cb);
     } else {
         done();
     }
 }
 
 //@}
 IdlInterface.prototype.add_iterable_members = function(member)
 //@{
 {
-    this.members.push({type: "operation", name: "entries", idlType: "iterator", arguments: []});
-    this.members.push({type: "operation", name: "keys", idlType: "iterator", arguments: []});
-    this.members.push({type: "operation", name: "values", idlType: "iterator", arguments: []});
-    this.members.push({type: "operation", name: "forEach", idlType: "void", arguments:
-        [{ name: "callback", idlType: {idlType: "function"}},
-        { name: "thisValue", idlType: {idlType: "any"}, optional: true}]});
+    this.members.push(new IdlInterfaceMember(
+        { type: "operation", name: "entries", idlType: "iterator", arguments: []}));
+    this.members.push(new IdlInterfaceMember(
+        { type: "operation", name: "keys", idlType: "iterator", arguments: []}));
+    this.members.push(new IdlInterfaceMember(
+        { type: "operation", name: "values", idlType: "iterator", arguments: []}));
+    this.members.push(new IdlInterfaceMember(
+        { type: "operation", name: "forEach", idlType: "void",
+          arguments:
+          [{ name: "callback", idlType: {idlType: "function"}},
+           { name: "thisValue", idlType: {idlType: "any"}, optional: true}]}));
 };
 
 //@}
 IdlInterface.prototype.test_member_iterable = function(member)
 //@{
 {
     var interfaceName = this.name;
     var isPairIterator = member.idlType instanceof Array;
     test(function()
     {
@@ skipping 98 matching lines @@
         }
     }
 
     for (var i = 0; i < this.members.length; i++)
     {
         var member = this.members[i];
         if (member.untested) {
             continue;
         }
 
+        if (!exposed_in(exposure_set(member, this.exposureSet))) {
+            test(function() {
+                // It's not exposed, so we shouldn't find it anywhere.
+                assert_false(member.name in self[this.name],
+                             "The interface object must not have a property " +
+                             format_value(member.name));
+                assert_false(member.name in self[this.name].prototype,
+                             "The prototype object must not have a property " +
+                             format_value(member.name));
+            }.bind(this), this.name + " interface: member " + member.name);
+            continue;
+        }
+
         switch (member.type) {
         case "const":
             this.test_member_const(member);
             break;
 
         case "attribute":
             // For unforgeable attributes, we do the checks in
             // test_interface_of instead.
             if (!member.isUnforgeable)
             {
@@ skipping 113 matching lines @@
 //@}
 IdlInterface.prototype.test_interface_of = function(desc, obj, exception, expected_typeof)
 //@{
 {
     // TODO: Indexed and named properties, more checks on interface members
     this.already_tested = true;
 
     for (var i = 0; i < this.members.length; i++)
     {
         var member = this.members[i];
+        if (!exposed_in(exposure_set(member, this.exposureSet))) {
+            test(function() {
+                assert_false(member.name in obj);
+            }.bind(this), this.name + "interface: " + desc + 'must not have property "' + member.name + '"');
+            continue;
+        }
         if (member.type == "attribute" && member.isUnforgeable)
         {
             var a_test = async_test(this.name + " interface: " + desc + ' must have own property "' + member.name + '"');
             a_test.step(function() {
                 assert_equals(exception, null, "Unexpected exception when evaluating object");
                 assert_equals(typeof obj, expected_typeof, "wrong typeof object");
                 // Call do_interface_attribute_asserts last, since it will call a_test.done()
                 this.do_interface_attribute_asserts(obj, member, a_test);
             }.bind(this));
         }
@@ skipping 330 matching lines @@
     /** An array of values produced by the "typedef" production. */
     this.values = obj.values;
 
 }
 //@}
 
 IdlTypedef.prototype = Object.create(IdlObject.prototype);
 
 }());
 // vim: set expandtab shiftwidth=4 tabstop=4 foldmarker=@{,@} foldmethod=marker: