Import web-platform-tests@028d354aba4c8ee6700def957a45f3927241d8b0

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 51 matching lines @@
     }
 
     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) {
+    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) {
+    var counter = 0;
+    return function() {
+        counter++;
+        if (counter >= n) {
+            cb();
+        }
+    };
+}
+
+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 340 matching lines @@
             assert_equals(typeof value, "number");
             return;
 
         case "unsigned long long":
         case "DOMTimeStamp":
             assert_equals(typeof value, "number");
             assert_true(0 <= value, "unsigned long long is negative");
             return;
 
         case "float":
+            assert_equals(typeof value, "number");
+            assert_equals(value, fround(value), "float rounded to 32-bit float should be itself");
+            assert_not_equals(value, Infinity);
+            assert_not_equals(value, -Infinity);
+            assert_not_equals(value, NaN);
+            return;
+
+        case "DOMHighResTimeStamp":
         case "double":
-        case "DOMHighResTimeStamp":
+            assert_equals(typeof value, "number");
+            assert_not_equals(value, Infinity);
+            assert_not_equals(value, -Infinity);
+            assert_not_equals(value, NaN);
+            return;
+
         case "unrestricted float":
+            assert_equals(typeof value, "number");
+            assert_equals(value, fround(value), "unrestricted float rounded to 32-bit float should be itself");
+            return;
+
         case "unrestricted double":
-            // TODO: distinguish these cases
             assert_equals(typeof value, "number");
             return;
 
         case "DOMString":
-        case "ByteString":
-        case "USVString":
-            // TODO: https://github.com/w3c/testharness.js/issues/92
             assert_equals(typeof value, "string");
             return;
 
+        case "ByteString":
+            assert_equals(typeof value, "string");
+            assert_regexp_match(value, /^[\x00-\x7F]*$/);
+            return;
+
+        case "USVString":
+            assert_equals(typeof value, "string");
+            assert_regexp_match(value, /^([\x00-\ud7ff\ue000-\uffff]|[\ud800-\udbff][\udc00-\udfff])*$/);
+            return;
+
         case "object":
             assert_true(typeof value == "object" || typeof value == "function", "wrong type: not object or function");
             return;
     }
 
     if (!(type in this.members))
     {
         throw "Unrecognized type " + type;
     }
 
@@ skipping 80 matching lines @@
      */
     this.base = obj.inheritance;
 }
 
 //@}
 IdlDictionary.prototype = Object.create(IdlObject.prototype);
 
 /// IdlInterface ///
 function IdlInterface(obj, is_callback) {
     /**
-     * obj is an object produced by the WebIDLParser.js "exception" or
-     * "interface" production, as appropriate.
+     * 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;
 
     /**
-     * An indicator of whether we should run tests on the (exception) interface
-     * object and (exception) interface prototype object.  Tests on members are
-     * controlled by .untested on each member, not this.
+     * An indicator of whether we should run tests on the interface object and
+     * interface prototype object. Tests on members are controlled by .untested
+     * on each member, not this.
      */
     this.untested = obj.untested;
 
     /** An array of objects produced by the "ExtAttr" production. */
     this.extAttrs = obj.extAttrs;
 
     /** An array of IdlInterfaceMembers. */
     this.members = obj.members.map(function(m){return new IdlInterfaceMember(m); });
     if (this.has_extended_attribute("Unforgeable")) {
         this.members
@@ skipping 366 matching lines @@
         assert_true(desc.configurable, this.name + ".prototype.constructor in not configurable");
         assert_equals(self[this.name].prototype.constructor, self[this.name],
                       this.name + '.prototype.constructor is not the same object as ' + this.name);
     }.bind(this), this.name + ' interface: existence and properties of interface prototype object\'s "constructor" property');
 };
 
 //@}
 IdlInterface.prototype.test_member_const = function(member)
 //@{
 {
+    if (!this.has_constants()) {
+        throw "Internal error: test_member_const called without any constants";
+    }
+
     test(function()
     {
-        if (this.is_callback() && !this.has_constants()) {
-            return;
-        }
-
         assert_own_property(self, this.name,
                             "self does not have own property " + format_value(this.name));
 
         // "For each constant defined on an interface A, there must be
         // a corresponding property on the interface object, if it
         // exists."
         assert_own_property(self[this.name], member.name);
         // "The value of the property is that which is obtained by
         // converting the constant’s IDL value to an ECMAScript
         // value."
         assert_equals(self[this.name][member.name], constValue(member.value),
                       "property has wrong value");
         // "The property has attributes { [[Writable]]: false,
         // [[Enumerable]]: true, [[Configurable]]: false }."
         var desc = Object.getOwnPropertyDescriptor(self[this.name], member.name);
         assert_false("get" in desc, "property has getter");
         assert_false("set" in desc, "property has setter");
         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 object");
+
     // "In addition, a property with the same characteristics must
     // exist on the interface prototype object."
     test(function()
     {
-        if (this.is_callback() && !this.has_constants()) {
-            return;
-        }
-
         assert_own_property(self, this.name,
                             "self does not have own property " + format_value(this.name));
 
         if (this.is_callback()) {
             assert_false("prototype" in self[this.name],
                          this.name + ' should not have a "prototype" property');
             return;
         }
 
         assert_own_property(self[this.name], "prototype",
@@ skipping 32 matching lines @@
                 "The interface object must have a property " +
                 format_value(member.name));
         } 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) {
-                var getter = Object.getOwnPropertyDescriptor(self, member.name).get;
-                assert_equals(typeof(getter), "function",
-                              format_value(member.name) + " must have a getter");
                 assert_equals(propVal, getter.call(undefined),
                               "Gets on a global should not require an explicit this");
             }
+
             this.do_interface_attribute_asserts(self, member);
         } 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");
             } else {
                 assert_equals(self[this.name].prototype[member.name], undefined,
                               "getting property on prototype object must return undefined");
             }
             this.do_interface_attribute_asserts(self[this.name].prototype, member);
         }
     }.bind(this), this.name + " interface: attribute " + member.name);
 };
 
 //@}
 IdlInterface.prototype.test_member_operation = function(member)
 //@{
 {
-    test(function()
+    var a_test = async_test(this.name + " interface: operation " + member.name +
+                            "(" + member.arguments.map(
+                                function(m) {return m.idlType.idlType; } )
+                            +")");
+    a_test.step(function()
     {
+        // This function tests WebIDL as of 2015-12-29.
+        // https://heycam.github.io/webidl/#es-operations
+
         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));
 
         if (this.is_callback()) {
             assert_false("prototype" in self[this.name],
                          this.name + ' should not have a "prototype" property');
+            a_test.done();
             return;
         }
 
         assert_own_property(self[this.name], "prototype",
                             'interface "' + this.name + '" does not have own property "prototype"');
 
-        // "For each unique identifier of an operation defined on the
-        // interface, there must be a corresponding property on the
-        // interface prototype object (if it is a regular operation) or
-        // the interface object (if it is a static operation), unless
-        // the effective overload set for that identifier and operation
-        // and with an argument count of 0 (for the ECMAScript language
-        // binding) has no entries."
-        //
+        // "For each unique identifier of an exposed operation defined on the
+        // interface, there must exist a corresponding property, unless the
+        // effective overload set for that identifier and operation and with an
+        // argument count of 0 has no entries."
+
+        // TODO: Consider [Exposed].
+
+        // "The location of the property is determined as follows:"
         var memberHolderObject;
+        // "* If the operation is static, then the property exists on the
+        //    interface object."
         if (member["static"]) {
             assert_own_property(self[this.name], member.name,
                     "interface object missing static operation");
             memberHolderObject = self[this.name];
+        // "* Otherwise, [...] if the interface was declared with the [Global]
+        //    or [PrimaryGlobal] extended attribute, then the property exists
+        //    on every object that implements the interface."
         } else if (this.is_global()) {
             assert_own_property(self, member.name,
                     "global object missing non-static operation");
             memberHolderObject = self;
+        // "* Otherwise, the property exists solely on the interface’s
+        //    interface prototype object."
         } else {
             assert_own_property(self[this.name].prototype, member.name,
                     "interface prototype object missing non-static operation");
             memberHolderObject = self[this.name].prototype;
         }
-
-        this.do_member_operation_asserts(memberHolderObject, member);
-    }.bind(this), this.name + " interface: operation " + member.name +
-    "(" + member.arguments.map(function(m) { return m.idlType.idlType; }) +
-    ")");
+        this.do_member_operation_asserts(memberHolderObject, member, a_test);
+    }.bind(this));
 };
 
 //@}
-IdlInterface.prototype.do_member_operation_asserts = function(memberHolderObject, member)
+IdlInterface.prototype.do_member_operation_asserts = function(memberHolderObject, member, a_test)
 //@{
 {
+    var done = a_test.done.bind(a_test);
     var operationUnforgeable = member.isUnforgeable;
     var desc = Object.getOwnPropertyDescriptor(memberHolderObject, member.name);
     // "The property has attributes { [[Writable]]: B,
     // [[Enumerable]]: true, [[Configurable]]: B }, where B is false if the
     // operation is unforgeable on the interface, and true otherwise".
     assert_false("get" in desc, "property has getter");
     assert_false("set" in desc, "property has setter");
     assert_equals(desc.writable, !operationUnforgeable,
                   "property should be writable if and only if not unforgeable");
     assert_true(desc.enumerable, "property is not enumerable");
@@ skipping 23 matching lines @@
     // ". . .
     // "Otherwise, throw a TypeError."
     // This should be hit if the operation is not static, there is
     // no [ImplicitThis] attribute, and the this value is null.
     //
     // TODO: We currently ignore the [ImplicitThis] case.  Except we manually
     // check for globals, since otherwise we'll invoke window.close().  And we
     // have to skip this test for anything that on the proto chain of "self",
     // since that does in fact have implicit-this behavior.
     if (!member["static"]) {
+        var cb;
         if (!this.is_global() &&
             memberHolderObject[member.name] != self[member.name])
         {
-            assert_throws(new TypeError(), function() {
-                memberHolderObject[member.name].apply(null, args);
-            }, "calling operation with this = null didn't throw TypeError");
+            cb = awaitNCallbacks(2, done);
+            throwOrReject(a_test, member, memberHolderObject[member.name], null, args,
+                          "calling operation with this = null didn't throw TypeError", cb);
+        } else {
+            cb = awaitNCallbacks(1, done);
         }
 
         // ". . . If O is not null and is also not a platform object
         // that implements interface I, throw a TypeError."
         //
         // TODO: Test a platform object that implements some other
         // interface.  (Have to be sure to get inheritance right.)
-        assert_throws(new TypeError(), function() {
-            memberHolderObject[member.name].apply({}, args);
-        }, "calling operation with this = {} didn't throw TypeError");
+        throwOrReject(a_test, member, memberHolderObject[member.name], {}, args,
+                      "calling operation with this = {} didn't throw TypeError", cb);
+    } else {
+        done();
     }
 }
 
 //@}
 IdlInterface.prototype.test_member_stringifier = function(member)
 //@{
 {
     test(function()
     {
         if (this.is_callback() && !this.has_constants()) {
@@ skipping 198 matching lines @@
             {
                 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 + '"');
         }
         else if (member.type == "operation" &&
                  member.name &&
                  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");
                 assert_own_property(obj, member.name,
                                     "Doesn't have the unforgeable operation property");
-                this.do_member_operation_asserts(obj, member);
-            }.bind(this), this.name + " interface: " + desc + ' must have own property "' + member.name + '"');
+                this.do_member_operation_asserts(obj, member, a_test);
+            }.bind(this));
         }
         else if ((member.type == "const"
         || member.type == "attribute"
         || member.type == "operation")
         && member.name)
         {
             test(function()
             {
                 assert_equals(exception, null, "Unexpected exception when evaluating object");
                 assert_equals(typeof obj, expected_typeof, "wrong typeof object");
@@ skipping 32 matching lines @@
                         assert_equals(typeof obj[member.name], "function");
                     }
                 }
             }.bind(this), this.name + " interface: " + desc + ' must inherit property "' + member.name + '" with the proper type (' + i + ')');
         }
         // TODO: This is wrong if there are multiple operations with the same
         // identifier.
         // TODO: Test passing arguments of the wrong type.
         if (member.type == "operation" && member.name && member.arguments.length)
         {
-            test(function()
+            var a_test = async_test( this.name + " interface: calling " + member.name +
+            "(" + member.arguments.map(function(m) { return m.idlType.idlType; }) +
+            ") on " + desc + " with too few arguments must throw TypeError");
+            a_test.step(function()
             {
                 assert_equals(exception, null, "Unexpected exception when evaluating object");
                 assert_equals(typeof obj, expected_typeof, "wrong typeof object");
                 if (!member["static"]) {
                     if (!this.is_global() && !member.isUnforgeable) {
                         assert_inherits(obj, member.name);
                     } else {
                         assert_own_property(obj, member.name);
                     }
                 }
                 else
                 {
                     assert_false(member.name in obj);
                 }
 
                 var minLength = minOverloadLength(this.members.filter(function(m) {
                     return m.type == "operation" && m.name == member.name;
                 }));
                 var args = [];
+                var cb = awaitNCallbacks(minLength, a_test.done.bind(a_test));
                 for (var i = 0; i < minLength; i++) {
-                    assert_throws(new TypeError(), function()
-                    {
-                        obj[member.name].apply(obj, args);
-                    }.bind(this), "Called with " + i + " arguments");
+                    throwOrReject(a_test, member, obj[member.name], obj, args,  "Called with " + i + " arguments", cb);
 
                     args.push(create_suitable_object(member.arguments[i].idlType));
                 }
-            }.bind(this), this.name + " interface: calling " + member.name +
-            "(" + member.arguments.map(function(m) { return m.idlType.idlType; }) +
-            ") on " + desc + " with too few arguments must throw TypeError");
+                if (minLength === 0) {
+                    cb();
+                }
+            }.bind(this));
         }
     }
 };
 
 //@}
 IdlInterface.prototype.has_stringifier = function()
 //@{
 {
     if (this.members.some(function(member) { return member.stringifier; })) {
         return true;
@@ skipping 212 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: