Import wpt@c875b4212a473363afe8c09f012edf201386cb5b

third_party/WebKit/LayoutTests/imported/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 289 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 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 &&
+        self instanceof SharedWorkerGlobalScope) {
+        return globals.indexOf("Worker") >= 0 ||
+               globals.indexOf("SharedWorker") >= 0;
+    }
+    if ('ServiceWorkerGlobalScope' in self &&
+        self instanceof ServiceWorkerGlobalScope) {
+        return globals.indexOf("Worker") >= 0 ||
+               globals.indexOf("ServiceWorker") >= 0;
+    }
+    throw "Unexpected global object";
+}
+
 //@}
 IdlArray.prototype.test = function()
 //@{
 {
     /** Entry point.  See documentation at beginning of file. */
 
     // First merge in all the partial interfaces and implements statements we
     // encountered.
     this.partials.forEach(function(parsed_idl)
     {
@@ skipping 26 matching lines @@
             if (!(rhs in this.members)) throw errStr + rhs + " is undefined.";
             if (!(this.members[rhs] instanceof IdlInterface)) throw errStr + rhs + " is not an interface.";
             this.members[rhs].members.forEach(function(member)
             {
                 this.members[lhs].members.push(new IdlInterfaceMember(member));
             }.bind(this));
         }.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"];
+        member.exposed = exposed_in(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)
             {
                 this.members[name].test_object(str);
             }.bind(this));
@@ skipping 305 matching lines @@
 //@{
 {
     if (this.has_extended_attribute("NoInterfaceObject"))
     {
         // No tests to do without an instance.  TODO: We should still be able
         // to run tests on the prototype object, if we obtain one through some
         // other means.
         return;
     }
 
+    if (!this.exposed) {
+        test(function() {
+            assert_false(this.name in self);
+        }.bind(this), this.name + " interface: existence and properties of interface object");
+        return;
+    }
+
     if (!this.untested)
     {
         // First test things to do with the exception/interface object and
         // exception/interface prototype object.
         this.test_self();
     }
     // Then test things to do with its members (constants, fields, attributes,
     // operations, . . .).  These are run even if .untested is true, because
     // members might themselves be marked as .untested.  This might happen to
     // interfaces if the interface itself is untested but a partial interface
     // that extends it is tested -- then the interface itself and its initial
     // members will be marked as untested, but the members added by the partial
     // interface are still tested.
     this.test_members();
 };
 //@}
 
 IdlInterface.prototype.test_self = function()
 //@{
 {
     test(function()
     {
         // This function tests WebIDL as of 2015-01-13.
-        // TODO: Consider [Exposed].
 
         // "For every interface that is exposed in a given ECMAScript global
         // environment and:
         // * is a callback interface that has constants declared on it, or
         // * is a non-callback interface that is not declared with the
         //   [NoInterfaceObject] extended attribute,
         // a corresponding property MUST exist on the ECMAScript global object.
         // The name of the property is the identifier of the interface, and its
         // value is an object called the interface object.
         // The property has the attributes { [[Writable]]: true,
@@ skipping 1081 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: