Import wpt@cf62b859e6b890abc34f8140d185ba91df95c5b6

third_party/WebKit/LayoutTests/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 31 matching lines @@
  *
  * (Note that the version of WebIDLParser.js we use might sometimes be
  * out-of-date or forked.)
  *
  * The members and methods of the classes defined by this file are all at least
  * briefly documented, hopefully.
  */
 (function(){
 "use strict";
 /// Helpers ///
-function constValue (cnt) {
+function constValue (cnt)
+//@{
+{
     if (cnt.type === "null") return null;
     if (cnt.type === "NaN") return NaN;
     if (cnt.type === "Infinity") return cnt.negative ? -Infinity : Infinity;
     return cnt.value;
 }
 
-function minOverloadLength(overloads) {
+//@}
+function minOverloadLength(overloads)
+//@{
+{
     if (!overloads.length) {
         return 0;
     }
 
     return overloads.map(function(attr) {
         return attr.arguments ? attr.arguments.filter(function(arg) {
             return !arg.optional && !arg.variadic;
         }).length : 0;
     })
     .reduce(function(m, n) { return Math.min(m, n); });
 }
 
-function throwOrReject(a_test, operation, fn, obj, args,  message, cb) {
+//@}
+function throwOrReject(a_test, operation, fn, obj, args,  message, cb)
+//@{
+{
     if (operation.idlType.generic !== "Promise") {
         assert_throws(new TypeError(), function() {
             fn.apply(obj, args);
         }, message);
         cb();
     } else {
         try {
             promise_rejects(a_test, new TypeError(), fn.apply(obj, args)).then(cb, cb);
         } catch (e){
             a_test.step(function() {
                 assert_unreached("Throws \"" + e + "\" instead of rejecting promise");
                 cb();
             });
         }
     }
 }
 
-function awaitNCallbacks(n, cb, ctx) {
+//@}
+function awaitNCallbacks(n, cb, ctx)
+//@{
+{
     var counter = 0;
     return function() {
         counter++;
         if (counter >= n) {
             cb();
         }
     };
 }
 
-var fround = (function(){
+//@}
+var fround =
+//@{
+(function(){
     if (Math.fround) return Math.fround;
 
     var arr = new Float32Array(1);
     return function fround(n) {
         arr[0] = n;
         return arr[0];
     };
 })();
+//@}
 
 /// IdlArray ///
 // Entry point
 self.IdlArray = function()
 //@{
 {
     /**
      * A map from strings to the corresponding named IdlObject, such as
      * IdlInterface or IdlException.  These are the things that test() will run
      * tests on.
@@ skipping 322 matching lines @@
         if (!value.length)
         {
             // Nothing we can do.
             return;
         }
         this.assert_type_is(value[0], type.idlType.idlType);
         return;
     }
 
     if (type.generic === "Promise") {
-        assert_own_property(value, "then", "Attribute with a Promise type has a then property");
+        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;
     }
 
     type = type.idlType;
 
     switch(type)
     {
@@ skipping 181 matching lines @@
      * The name (as a string) of the dictionary type we inherit from, or null
      * if there is none.
      */
     this.base = obj.inheritance;
 }
 
 //@}
 IdlDictionary.prototype = Object.create(IdlObject.prototype);
 
 /// IdlInterface ///
-function IdlInterface(obj, is_callback) {
+function IdlInterface(obj, is_callback)
+//@{
+{
     /**
      * obj is an object produced by the WebIDLParser.js "interface" production.
      */
 
     /** Self-explanatory. */
     this.name = obj.name;
 
     /** A back-reference to our IdlArray. */
     this.array = obj.array;
 
@@ skipping 16 matching lines @@
     }
 
     /**
      * The name (as a string) of the type we inherit from, or null if there is
      * none.
      */
     this.base = obj.inheritance;
 
     this._is_callback = is_callback;
 }
+//@}
 IdlInterface.prototype = Object.create(IdlObject.prototype);
 IdlInterface.prototype.is_callback = function()
 //@{
 {
     return this._is_callback;
 };
 //@}
 
 IdlInterface.prototype.has_constants = function()
 //@{
@@ skipping 76 matching lines @@
                             "self does not have own property " + format_value(this.name));
         var desc = Object.getOwnPropertyDescriptor(self, this.name);
         assert_false("get" in desc, "self's property " + format_value(this.name) + " has getter");
         assert_false("set" in desc, "self's property " + format_value(this.name) + " has setter");
         assert_true(desc.writable, "self's property " + format_value(this.name) + " is not writable");
         assert_false(desc.enumerable, "self's property " + format_value(this.name) + " is enumerable");
         assert_true(desc.configurable, "self's property " + format_value(this.name) + " is not configurable");
 
         if (this.is_callback()) {
             // "The internal [[Prototype]] property of an interface object for
-            // a callback interface MUST be the Object.prototype object."
-            assert_equals(Object.getPrototypeOf(self[this.name]), Object.prototype,
+            // a callback interface must be the Function.prototype object."
+            assert_equals(Object.getPrototypeOf(self[this.name]), Function.prototype,
                           "prototype of self's property " + format_value(this.name) + " is not Object.prototype");
 
             return;
         }
 
         // "The interface object for a given non-callback interface is a
         // function object."
         // "If an object is defined to be a function object, then it has
         // characteristics as follows:"
 
@@ skipping 312 matching lines @@
         assert_false(desc.writable, "property is writable");
         assert_true(desc.enumerable, "property is not enumerable");
         assert_false(desc.configurable, "property is configurable");
     }.bind(this), this.name + " interface: constant " + member.name + " on interface prototype object");
 };
 
 
 //@}
 IdlInterface.prototype.test_member_attribute = function(member)
 //@{
-{
-    test(function()
+  {
+    var a_test = async_test(this.name + " interface: attribute " + member.name);
+    a_test.step(function()
     {
         if (this.is_callback() && !this.has_constants()) {
+            a_test.done()
             return;
         }
 
         assert_own_property(self, this.name,
                             "self does not have own property " + format_value(this.name));
         assert_own_property(self[this.name], "prototype",
                             'interface "' + this.name + '" does not have own property "prototype"');
 
         if (member["static"]) {
             assert_own_property(self[this.name], member.name,
                 "The interface object must have a property " +
                 format_value(member.name));
+            a_test.done();
         } else if (this.is_global()) {
             assert_own_property(self, member.name,
                 "The global object must 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));
 
             var getter = Object.getOwnPropertyDescriptor(self, member.name).get;
             assert_equals(typeof(getter), "function",
                           format_value(member.name) + " must have a getter");
 
             // Try/catch around the get here, since it can legitimately throw.
             // If it does, we obviously can't check for equality with direct
             // invocation of the getter.
             var gotValue;
             var propVal;
             try {
                 propVal = self[member.name];
                 gotValue = true;
             } catch (e) {
                 gotValue = false;
             }
             if (gotValue) {
                 assert_equals(propVal, getter.call(undefined),
                               "Gets on a global should not require an explicit this");
             }
 
-            this.do_interface_attribute_asserts(self, member);
+            // do_interface_attribute_asserts must be the last thing we do,
+            // since it will call done() on a_test.
+            this.do_interface_attribute_asserts(self, member, a_test);
         } else {
             assert_true(member.name in self[this.name].prototype,
                 "The prototype object must have a property " +
                 format_value(member.name));
 
             if (!member.has_extended_attribute("LenientThis")) {
-                assert_throws(new TypeError(), function() {
-                    self[this.name].prototype[member.name];
-                }.bind(this), "getting property on prototype object must throw TypeError");
+                if (member.idlType.generic !== "Promise") {
+                    assert_throws(new TypeError(), function() {
+                        self[this.name].prototype[member.name];
+                    }.bind(this), "getting property on prototype object must throw TypeError");
+                    // do_interface_attribute_asserts must be the last thing we
+                    // do, since it will call done() on a_test.
+                    this.do_interface_attribute_asserts(self[this.name].prototype, member, a_test);
+                } else {
+                    promise_rejects(a_test, new TypeError(),
+                                    self[this.name].prototype[member.name])
+                        .then(function() {
+                            // do_interface_attribute_asserts must be the last
+                            // thing we do, since it will call done() on a_test.
+                            this.do_interface_attribute_asserts(self[this.name].prototype,
+                                                                member, a_test);
+                        }.bind(this));
+                }
             } else {
                 assert_equals(self[this.name].prototype[member.name], undefined,
                               "getting property on prototype object must return undefined");
+              // do_interface_attribute_asserts must be the last thing we do,
+              // since it will call done() on a_test.
+              this.do_interface_attribute_asserts(self[this.name].prototype, member, a_test);
             }
-            this.do_interface_attribute_asserts(self[this.name].prototype, member);
+
         }
-    }.bind(this), this.name + " interface: attribute " + member.name);
+    }.bind(this));
 };
 
 //@}
 IdlInterface.prototype.test_member_operation = function(member)
 //@{
 {
     var a_test = async_test(this.name + " interface: operation " + member.name +
                             "(" + member.arguments.map(
                                 function(m) {return m.idlType.idlType; } )
                             +")");
@@ skipping 118 matching lines @@
         // TODO: Test a platform object that implements some other
         // interface.  (Have to be sure to get inheritance right.)
         throwOrReject(a_test, member, memberHolderObject[member.name], {}, args,
                       "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}]});
+};
+
+//@}
+IdlInterface.prototype.test_member_iterable = function(member)
+//@{
+{
+    var interfaceName = this.name;
+    var isPairIterator = member.idlType instanceof Array;
+    test(function()
+    {
+        var descriptor = Object.getOwnPropertyDescriptor(self[interfaceName].prototype, Symbol.iterator);
+        assert_true(descriptor.writable, "property is not writable");
+        assert_true(descriptor.configurable, "property is not configurable");
+        assert_false(descriptor.enumerable, "property is enumerable");
+        assert_equals(self[interfaceName].prototype[Symbol.iterator].name, isPairIterator ? "entries" : "values", "@@iterator function does not have the right name");
+    }, "Testing Symbol.iterator property of iterable interface " + interfaceName);
+
+    if (isPairIterator) {
+        test(function() {
+            assert_equals(self[interfaceName].prototype["entries"], self[interfaceName].prototype[Symbol.iterator], "entries method is not the same as @@iterator");
+        }, "Testing pair iterable interface " + interfaceName);
+    } else {
+        test(function() {
+            ["entries", "keys", "values", "forEach", Symbol.Iterator].forEach(function(property) {
+                assert_equals(self[interfaceName].prototype[property], Array.prototype[property], property + " function is not the same as Array one");
+            });
+        }, "Testing value iterable interface " + interfaceName);
+    }
+};
+
+//@}
 IdlInterface.prototype.test_member_stringifier = function(member)
 //@{
 {
     test(function()
     {
         if (this.is_callback() && !this.has_constants()) {
             return;
         }
 
         assert_own_property(self, this.name,
@@ skipping 50 matching lines @@
     }.bind(this), this.name + " interface: stringifier");
 };
 
 //@}
 IdlInterface.prototype.test_members = function()
 //@{
 {
     for (var i = 0; i < this.members.length; i++)
     {
         var member = this.members[i];
+        switch (member.type) {
+        case "iterable":
+            this.add_iterable_members(member);
+            break;
+        // TODO: add setlike and maplike handling.
+        default:
+            break;
+        }
+    }
+
+    for (var i = 0; i < this.members.length; i++)
+    {
+        var member = this.members[i];
         if (member.untested) {
             continue;
         }
 
         switch (member.type) {
         case "const":
             this.test_member_const(member);
             break;
 
         case "attribute":
@@ skipping 16 matching lines @@
             if (member.name) {
                 if (!member.isUnforgeable)
                 {
                     this.test_member_operation(member);
                 }
             } else if (member.stringifier) {
                 this.test_member_stringifier(member);
             }
             break;
 
+        case "iterable":
+            this.test_member_iterable(member);
+            break;
         default:
             // TODO: check more member types.
             break;
         }
     }
 };
 
 //@}
 IdlInterface.prototype.test_object = function(desc)
 //@{
@@ skipping 80 matching lines @@
 //@{
 {
     // 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 (member.type == "attribute" && member.isUnforgeable)
         {
-            test(function()
-            {
+            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");
-                this.do_interface_attribute_asserts(obj, member);
-            }.bind(this), this.name + " interface: " + desc + ' must have own property "' + member.name + '"');
+                // Call do_interface_attribute_asserts last, since it will call a_test.done()
+                this.do_interface_attribute_asserts(obj, member, a_test);
+            }.bind(this));
         }
         else if (member.type == "operation" &&
                  member.name &&
                  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");
@@ skipping 98 matching lines @@
         return true;
     }
     if (this.base &&
         this.array.members[this.base].has_stringifier()) {
         return true;
     }
     return false;
 };
 
 //@}
-IdlInterface.prototype.do_interface_attribute_asserts = function(obj, member)
+IdlInterface.prototype.do_interface_attribute_asserts = function(obj, member, a_test)
 //@{
 {
     // This function tests WebIDL as of 2015-01-27.
     // TODO: Consider [Exposed].
 
     // This is called by test_member_attribute() with the prototype as obj if
     // it is not a global, and the global otherwise, and by test_interface_of()
     // with the object as obj.
 
+    var pendingPromises = [];
+
     // "For each exposed attribute of the interface, whether it was declared on
     // the interface itself or one of its consequential interfaces, there MUST
     // exist a corresponding property. The characteristics of this property are
     // as follows:"
 
     // "The name of the property is the identifier of the attribute."
     assert_own_property(obj, member.name);
 
     // "The property has attributes { [[Get]]: G, [[Set]]: S, [[Enumerable]]:
     // true, [[Configurable]]: configurable }, where:
@@ skipping 19 matching lines @@
     // is as follows:"
     assert_equals(typeof desc.get, "function", "getter must be Function");
 
     // "If the attribute is a regular attribute, then:"
     if (!member["static"]) {
         // "If O is not a platform object that implements I, then:
         // "If the attribute was specified with the [LenientThis] extended
         // attribute, then return undefined.
         // "Otherwise, throw a TypeError."
         if (!member.has_extended_attribute("LenientThis")) {
-            assert_throws(new TypeError(), function() {
-                desc.get.call({});
-            }.bind(this), "calling getter on wrong object type must throw TypeError");
+            if (member.idlType.generic !== "Promise") {
+                assert_throws(new TypeError(), function() {
+                    desc.get.call({});
+                }.bind(this), "calling getter on wrong object type must throw TypeError");
+            } else {
+                pendingPromises.push(
+                    promise_rejects(a_test, new TypeError(), desc.get.call({}),
+                                    "calling getter on wrong object type must reject the return promise with TypeError"));
+            }
         } else {
             assert_equals(desc.get.call({}), undefined,
                           "calling getter on wrong object type must return undefined");
         }
     }
 
     // "The value of the Function object’s “length” property is the Number
     // value 0."
     assert_equals(desc.get.length, 0, "getter length must be 0");
 
@@ skipping 30 matching lines @@
             } else {
                 assert_equals(desc.set.call({}), undefined,
                               "calling setter on wrong object type must return undefined");
             }
         }
 
         // "The value of the Function object’s “length” property is the Number
         // value 1."
         assert_equals(desc.set.length, 1, "setter length must be 1");
     }
+
+    Promise.all(pendingPromises).then(a_test.done.bind(a_test));
 }
 //@}
 
 /// IdlInterfaceMember ///
 function IdlInterfaceMember(obj)
 //@{
 {
     /**
      * obj is an object produced by the WebIDLParser.js "ifMember" production.
      * We just forward all properties to this object without modification,
@@ skipping 91 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: