| /* |
| 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 |
| */ |
| |
| /* For user documentation see docs/_writing-tests/idlharness.md */ |
| |
| /** |
| * Notes for people who want to edit this file (not just use it as a library): |
| * |
| * Most of the interesting stuff happens in the derived classes of IdlObject, |
| * especially IdlInterface. The entry point for all IdlObjects is .test(), |
| * which is called by IdlArray.test(). An IdlObject is conceptually just |
| * "thing we want to run tests on", and an IdlArray is an array of IdlObjects |
| * with some additional data thrown in. |
| * |
| * The object model is based on what WebIDLParser.js produces, which is in turn |
| * based on its pegjs grammar. If you want to figure out what properties an |
| * object will have from WebIDLParser.js, the best way is to look at the |
| * grammar: |
| * |
| * https://github.com/darobin/webidl.js/blob/master/lib/grammar.peg |
| * |
| * So for instance: |
| * |
| * // interface definition |
| * interface |
| * = extAttrs:extendedAttributeList? S? "interface" S name:identifier w herit:ifInheritance? w "{" w mem:ifMember* w "}" w ";" w |
| * { return { type: "interface", name: name, inheritance: herit, members: mem, extAttrs: extAttrs }; } |
| * |
| * This means that an "interface" object will have a .type property equal to |
| * the string "interface", a .name property equal to the identifier that the |
| * parser found, an .inheritance property equal to either null or the result of |
| * the "ifInheritance" production found elsewhere in the grammar, and so on. |
| * After each grammatical production is a JavaScript function in curly braces |
| * that gets called with suitable arguments and returns some JavaScript value. |
| * |
| * (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"; |
| // Support subsetTestByKey from /common/subset-tests-by-key.js, but make it optional |
| if (!('subsetTestByKey' in self)) { |
| self.subsetTestByKey = function(key, callback, ...args) { |
| return callback(...args); |
| } |
| self.shouldRunSubTest = () => true; |
| } |
| /// Helpers /// |
| function constValue (cnt) |
| { |
| if (cnt.type === "null") return null; |
| if (cnt.type === "NaN") return NaN; |
| if (cnt.type === "Infinity") return cnt.negative ? -Infinity : Infinity; |
| if (cnt.type === "number") return +cnt.value; |
| return cnt.value; |
| } |
| |
| function minOverloadLength(overloads) |
| { |
| // "The value of the Function object’s “length” property is |
| // a Number determined as follows: |
| // ". . . |
| // "Return the length of the shortest argument list of the |
| // entries in S." |
| 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); }); |
| } |
| |
| // A helper to get the global of a Function object. This is needed to determine |
| // which global exceptions the function throws will come from. |
| function globalOf(func) |
| { |
| try { |
| // Use the fact that .constructor for a Function object is normally the |
| // Function constructor, which can be used to mint a new function in the |
| // right global. |
| return func.constructor("return this;")(); |
| } catch (e) { |
| } |
| // If the above fails, because someone gave us a non-function, or a function |
| // with a weird proto chain or weird .constructor property, just fall back |
| // to 'self'. |
| return self; |
| } |
| |
| function throwOrReject(a_test, operation, fn, obj, args, message, cb) |
| { |
| if (operation.idlType.generic !== "Promise") { |
| assert_throws_js(globalOf(fn).TypeError, function() { |
| fn.apply(obj, args); |
| }, message); |
| cb(); |
| } else { |
| try { |
| promise_rejects_js(a_test, TypeError, fn.apply(obj, args), message).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]; |
| }; |
| })(); |
| |
| /// IdlHarnessError /// |
| // Entry point |
| self.IdlHarnessError = function(message) |
| { |
| /** |
| * Message to be printed as the error's toString invocation. |
| */ |
| this.message = message; |
| }; |
| |
| IdlHarnessError.prototype = Object.create(Error.prototype); |
| |
| IdlHarnessError.prototype.toString = function() |
| { |
| return this.message; |
| }; |
| |
| |
| /// 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. |
| */ |
| this.members = {}; |
| |
| /** |
| * A map from strings to arrays of strings. The keys are interface or |
| * exception names, and are expected to also exist as keys in this.members |
| * (otherwise they'll be ignored). This is populated by add_objects() -- |
| * see documentation at the start of the file. The actual tests will be |
| * run by calling this.members[name].test_object(obj) for each obj in |
| * this.objects[name]. obj is a string that will be eval'd to produce a |
| * JavaScript value, which is supposed to be an object implementing the |
| * given IdlObject (interface, exception, etc.). |
| */ |
| this.objects = {}; |
| |
| /** |
| * When adding multiple collections of IDLs one at a time, an earlier one |
| * might contain a partial interface or implements statement that depends |
| * on a later one. Save these up and handle them right before we run |
| * tests. |
| * |
| * .partials is simply an array of objects from WebIDLParser.js' |
| * "partialinterface" production. .implements maps strings to arrays of |
| * strings, such that |
| * |
| * A implements B; |
| * A implements C; |
| * D implements E; |
| * |
| * results in this["implements"] = { A: ["B", "C"], D: ["E"] }. |
| * |
| * Similarly, |
| * |
| * interface A : B {}; |
| * interface B : C {}; |
| * |
| * results in this["inheritance"] = { A: "B", B: "C" } |
| */ |
| this.partials = []; |
| this["implements"] = {}; |
| this["includes"] = {}; |
| this["inheritance"] = {}; |
| |
| /** |
| * Record of skipped IDL items, in case we later realize that they are a |
| * dependency (to retroactively process them). |
| */ |
| this.skipped = new Map(); |
| }; |
| |
| IdlArray.prototype.add_idls = function(raw_idls, options) |
| { |
| /** Entry point. See documentation at beginning of file. */ |
| this.internal_add_idls(WebIDL2.parse(raw_idls), options); |
| }; |
| |
| IdlArray.prototype.add_untested_idls = function(raw_idls, options) |
| { |
| /** Entry point. See documentation at beginning of file. */ |
| var parsed_idls = WebIDL2.parse(raw_idls); |
| this.mark_as_untested(parsed_idls); |
| this.internal_add_idls(parsed_idls, options); |
| }; |
| |
| IdlArray.prototype.mark_as_untested = function (parsed_idls) |
| { |
| for (var i = 0; i < parsed_idls.length; i++) { |
| parsed_idls[i].untested = true; |
| if ("members" in parsed_idls[i]) { |
| for (var j = 0; j < parsed_idls[i].members.length; j++) { |
| parsed_idls[i].members[j].untested = true; |
| } |
| } |
| } |
| }; |
| |
| IdlArray.prototype.is_excluded_by_options = function (name, options) |
| { |
| return options && |
| (options.except && options.except.includes(name) |
| || options.only && !options.only.includes(name)); |
| }; |
| |
| IdlArray.prototype.add_dependency_idls = function(raw_idls, options) |
| { |
| return this.internal_add_dependency_idls(WebIDL2.parse(raw_idls), options); |
| }; |
| |
| IdlArray.prototype.internal_add_dependency_idls = function(parsed_idls, options) |
| { |
| const new_options = { only: [] } |
| |
| const all_deps = new Set(); |
| Object.values(this.inheritance).forEach(v => all_deps.add(v)); |
| Object.entries(this.implements).forEach(([k, v]) => { |
| all_deps.add(k); |
| all_deps.add(v); |
| }); |
| // NOTE: If 'A includes B' for B that we care about, then A is also a dep. |
| Object.keys(this.includes).forEach(k => { |
| all_deps.add(k); |
| this.includes[k].forEach(v => all_deps.add(v)); |
| }); |
| this.partials.forEach(p => all_deps.add(p.name)); |
| // Add 'TypeOfType' for each "typedef TypeOfType MyType;" entry. |
| Object.entries(this.members).forEach(([k, v]) => { |
| if (v instanceof IdlTypedef) { |
| let defs = v.idlType.union |
| ? v.idlType.idlType.map(t => t.idlType) |
| : [v.idlType.idlType]; |
| defs.forEach(d => all_deps.add(d)); |
| } |
| }); |
| |
| // Add the attribute idlTypes of all the nested members of idls. |
| const attrDeps = parsedIdls => { |
| return parsedIdls.reduce((deps, parsed) => { |
| if (parsed.members) { |
| for (const attr of Object.values(parsed.members).filter(m => m.type === 'attribute')) { |
| let attrType = attr.idlType; |
| // Check for generic members (e.g. FrozenArray<MyType>) |
| if (attrType.generic) { |
| deps.add(attrType.generic); |
| attrType = attrType.idlType; |
| } |
| deps.add(attrType.idlType); |
| } |
| } |
| if (parsed.base in this.members) { |
| attrDeps([this.members[parsed.base]]).forEach(dep => deps.add(dep)); |
| } |
| return deps; |
| }, new Set()); |
| }; |
| |
| const testedMembers = Object.values(this.members).filter(m => !m.untested && m.members); |
| attrDeps(testedMembers).forEach(dep => all_deps.add(dep)); |
| |
| const testedPartials = this.partials.filter(m => !m.untested && m.members); |
| attrDeps(testedPartials).forEach(dep => all_deps.add(dep)); |
| |
| |
| if (options && options.except && options.only) { |
| throw new IdlHarnessError("The only and except options can't be used together."); |
| } |
| |
| const defined_or_untested = name => { |
| // NOTE: Deps are untested, so we're lenient, and skip re-encountered definitions. |
| // e.g. for 'idl' containing A:B, B:C, C:D |
| // array.add_idls(idl, {only: ['A','B']}). |
| // array.add_dependency_idls(idl); |
| // B would be encountered as tested, and encountered as a dep, so we ignore. |
| return name in this.members |
| || this.is_excluded_by_options(name, options); |
| } |
| // Maps name -> [parsed_idl, ...] |
| const process = function(parsed) { |
| var deps = []; |
| if (parsed.name) { |
| deps.push(parsed.name); |
| } else if (parsed.type === "implements") { |
| deps.push(parsed.target); |
| deps.push(parsed.implements); |
| } else if (parsed.type === "includes") { |
| deps.push(parsed.target); |
| deps.push(parsed.includes); |
| } |
| |
| deps = deps.filter(function(name) { |
| if (!name |
| || name === parsed.name && defined_or_untested(name) |
| || !all_deps.has(name)) { |
| // Flag as skipped, if it's not already processed, so we can |
| // come back to it later if we retrospectively call it a dep. |
| if (name && !(name in this.members)) { |
| this.skipped.has(name) |
| ? this.skipped.get(name).push(parsed) |
| : this.skipped.set(name, [parsed]); |
| } |
| return false; |
| } |
| return true; |
| }.bind(this)); |
| |
| deps.forEach(function(name) { |
| if (!new_options.only.includes(name)) { |
| new_options.only.push(name); |
| } |
| |
| const follow_up = new Set(); |
| for (const dep_type of ["inheritance", "implements", "includes"]) { |
| if (parsed[dep_type]) { |
| const inheriting = parsed[dep_type]; |
| const inheritor = parsed.name || parsed.target; |
| const deps = [inheriting]; |
| // For A includes B, we can ignore A, unless B (or some of its |
| // members) is being tested. |
| if (dep_type !== "includes" |
| || inheriting in this.members && !this.members[inheriting].untested |
| || this.partials.some(function(p) { |
| return p.name === inheriting; |
| })) { |
| deps.push(inheritor); |
| } |
| for (const dep of deps) { |
| if (!new_options.only.includes(dep)) { |
| new_options.only.push(dep); |
| } |
| all_deps.add(dep); |
| follow_up.add(dep); |
| } |
| } |
| } |
| |
| for (const deferred of follow_up) { |
| if (this.skipped.has(deferred)) { |
| const next = this.skipped.get(deferred); |
| this.skipped.delete(deferred); |
| next.forEach(process); |
| } |
| } |
| }.bind(this)); |
| }.bind(this); |
| |
| for (let parsed of parsed_idls) { |
| process(parsed); |
| } |
| |
| this.mark_as_untested(parsed_idls); |
| |
| if (new_options.only.length) { |
| this.internal_add_idls(parsed_idls, new_options); |
| } |
| } |
| |
| IdlArray.prototype.internal_add_idls = function(parsed_idls, options) |
| { |
| /** |
| * Internal helper called by add_idls() and add_untested_idls(). |
| * |
| * parsed_idls is an array of objects that come from WebIDLParser.js's |
| * "definitions" production. The add_untested_idls() entry point |
| * additionally sets an .untested property on each object (and its |
| * .members) so that they'll be skipped by test() -- they'll only be |
| * used for base interfaces of tested interfaces, return types, etc. |
| * |
| * options is a dictionary that can have an only or except member which are |
| * arrays. If only is given then only members, partials and interface |
| * targets listed will be added, and if except is given only those that |
| * aren't listed will be added. Only one of only and except can be used. |
| */ |
| |
| if (options && options.only && options.except) |
| { |
| throw new IdlHarnessError("The only and except options can't be used together."); |
| } |
| |
| var should_skip = name => { |
| return this.is_excluded_by_options(name, options); |
| } |
| |
| parsed_idls.forEach(function(parsed_idl) |
| { |
| var partial_types = [ |
| "interface", |
| "interface mixin", |
| "dictionary", |
| "namespace", |
| ]; |
| if (parsed_idl.partial && partial_types.includes(parsed_idl.type)) |
| { |
| if (should_skip(parsed_idl.name)) |
| { |
| return; |
| } |
| this.partials.push(parsed_idl); |
| return; |
| } |
| |
| if (parsed_idl.type == "implements") |
| { |
| if (should_skip(parsed_idl.target)) |
| { |
| return; |
| } |
| if (!(parsed_idl.target in this["implements"])) |
| { |
| this["implements"][parsed_idl.target] = []; |
| } |
| this["implements"][parsed_idl.target].push(parsed_idl["implements"]); |
| return; |
| } |
| |
| if (parsed_idl.type == "includes") |
| { |
| if (should_skip(parsed_idl.target)) |
| { |
| return; |
| } |
| if (!(parsed_idl.target in this["includes"])) |
| { |
| this["includes"][parsed_idl.target] = []; |
| } |
| this["includes"][parsed_idl.target].push(parsed_idl["includes"]); |
| return; |
| } |
| |
| parsed_idl.array = this; |
| if (should_skip(parsed_idl.name)) |
| { |
| return; |
| } |
| if (parsed_idl.name in this.members) |
| { |
| throw new IdlHarnessError("Duplicate identifier " + parsed_idl.name); |
| } |
| |
| if (parsed_idl["inheritance"]) { |
| // NOTE: Clash should be impossible (would require redefinition of parsed_idl.name). |
| if (parsed_idl.name in this["inheritance"] |
| && parsed_idl["inheritance"] != this["inheritance"][parsed_idl.name]) { |
| throw new IdlHarnessError( |
| `Inheritance for ${parsed_idl.name} was already defined`); |
| } |
| this["inheritance"][parsed_idl.name] = parsed_idl["inheritance"]; |
| } |
| |
| switch(parsed_idl.type) |
| { |
| case "interface": |
| this.members[parsed_idl.name] = |
| new IdlInterface(parsed_idl, /* is_callback = */ false, /* is_mixin = */ false); |
| break; |
| |
| case "interface mixin": |
| this.members[parsed_idl.name] = |
| new IdlInterface(parsed_idl, /* is_callback = */ false, /* is_mixin = */ true); |
| break; |
| |
| case "dictionary": |
| // Nothing to test, but we need the dictionary info around for type |
| // checks |
| this.members[parsed_idl.name] = new IdlDictionary(parsed_idl); |
| break; |
| |
| case "typedef": |
| this.members[parsed_idl.name] = new IdlTypedef(parsed_idl); |
| break; |
| |
| case "callback": |
| this.members[parsed_idl.name] = new IdlCallback(parsed_idl); |
| break; |
| |
| case "enum": |
| this.members[parsed_idl.name] = new IdlEnum(parsed_idl); |
| break; |
| |
| case "callback interface": |
| this.members[parsed_idl.name] = |
| new IdlInterface(parsed_idl, /* is_callback = */ true, /* is_mixin = */ false); |
| break; |
| |
| case "namespace": |
| this.members[parsed_idl.name] = new IdlNamespace(parsed_idl); |
| break; |
| |
| default: |
| throw parsed_idl.name + ": " + parsed_idl.type + " not yet supported"; |
| } |
| }.bind(this)); |
| }; |
| |
| IdlArray.prototype.add_objects = function(dict) |
| { |
| /** Entry point. See documentation at beginning of file. */ |
| for (var k in dict) |
| { |
| if (k in this.objects) |
| { |
| this.objects[k] = this.objects[k].concat(dict[k]); |
| } |
| else |
| { |
| this.objects[k] = dict[k]; |
| } |
| } |
| }; |
| |
| IdlArray.prototype.prevent_multiple_testing = function(name) |
| { |
| /** Entry point. See documentation at beginning of file. */ |
| this.members[name].prevent_multiple_testing = true; |
| }; |
| |
| IdlArray.prototype.recursively_get_implements = function(interface_name) |
| { |
| /** |
| * Helper function for test(). Returns an array of things that implement |
| * interface_name, so if the IDL contains |
| * |
| * A implements B; |
| * B implements C; |
| * B implements D; |
| * |
| * then recursively_get_implements("A") should return ["B", "C", "D"]. |
| */ |
| var ret = this["implements"][interface_name]; |
| if (ret === undefined) |
| { |
| return []; |
| } |
| for (var i = 0; i < this["implements"][interface_name].length; i++) |
| { |
| ret = ret.concat(this.recursively_get_implements(ret[i])); |
| if (ret.indexOf(ret[i]) != ret.lastIndexOf(ret[i])) |
| { |
| throw new IdlHarnessError("Circular implements statements involving " + ret[i]); |
| } |
| } |
| return ret; |
| }; |
| |
| IdlArray.prototype.recursively_get_includes = function(interface_name) |
| { |
| /** |
| * Helper function for test(). Returns an array of things that implement |
| * interface_name, so if the IDL contains |
| * |
| * A includes B; |
| * B includes C; |
| * B includes D; |
| * |
| * then recursively_get_includes("A") should return ["B", "C", "D"]. |
| */ |
| var ret = this["includes"][interface_name]; |
| if (ret === undefined) |
| { |
| return []; |
| } |
| for (var i = 0; i < this["includes"][interface_name].length; i++) |
| { |
| ret = ret.concat(this.recursively_get_includes(ret[i])); |
| if (ret.indexOf(ret[i]) != ret.lastIndexOf(ret[i])) |
| { |
| throw new IdlHarnessError("Circular includes statements involving " + ret[i]); |
| } |
| } |
| return ret; |
| }; |
| |
| IdlArray.prototype.is_json_type = function(type) |
| { |
| /** |
| * Checks whether type is a JSON type as per |
| * https://heycam.github.io/webidl/#dfn-json-types |
| */ |
| |
| var idlType = type.idlType; |
| |
| if (type.generic == "Promise") { return false; } |
| |
| // nullable and annotated types don't need to be handled separately, |
| // as webidl2 doesn't represent them wrapped-up (as they're described |
| // in WebIDL). |
| |
| // union and record types |
| if (type.union || type.generic == "record") { |
| return idlType.every(this.is_json_type, this); |
| } |
| |
| // sequence types |
| if (type.generic == "sequence" || type.generic == "FrozenArray") { |
| return this.is_json_type(idlType[0]); |
| } |
| |
| if (typeof idlType != "string") { throw new Error("Unexpected type " + JSON.stringify(idlType)); } |
| |
| switch (idlType) |
| { |
| // Numeric types |
| case "byte": |
| case "octet": |
| case "short": |
| case "unsigned short": |
| case "long": |
| case "unsigned long": |
| case "long long": |
| case "unsigned long long": |
| case "float": |
| case "double": |
| case "unrestricted float": |
| case "unrestricted double": |
| // boolean |
| case "boolean": |
| // string types |
| case "DOMString": |
| case "ByteString": |
| case "USVString": |
| // object type |
| case "object": |
| return true; |
| case "Error": |
| case "DOMException": |
| case "Int8Array": |
| case "Int16Array": |
| case "Int32Array": |
| case "Uint8Array": |
| case "Uint16Array": |
| case "Uint32Array": |
| case "Uint8ClampedArray": |
| case "Float32Array": |
| case "Float64Array": |
| case "ArrayBuffer": |
| case "DataView": |
| case "any": |
| return false; |
| default: |
| var thing = this.members[idlType]; |
| if (!thing) { throw new Error("Type " + idlType + " not found"); } |
| if (thing instanceof IdlEnum) { return true; } |
| |
| if (thing instanceof IdlTypedef) { |
| return this.is_json_type(thing.idlType); |
| } |
| |
| // dictionaries where all of their members are JSON types |
| if (thing instanceof IdlDictionary) { |
| var stack = thing.get_inheritance_stack(); |
| var map = new Map(); |
| while (stack.length) |
| { |
| stack.pop().members.forEach(function(m) { |
| map.set(m.name, m.idlType) |
| }); |
| } |
| return Array.from(map.values()).every(this.is_json_type, this); |
| } |
| |
| // interface types that have a toJSON operation declared on themselves or |
| // one of their inherited or consequential interfaces. |
| if (thing instanceof IdlInterface) { |
| var base; |
| while (thing) |
| { |
| if (thing.has_to_json_regular_operation()) { return true; } |
| var mixins = this.implements[thing.name] || this.includes[thing.name]; |
| if (mixins) { |
| mixins = mixins.map(function(id) { |
| var mixin = this.members[id]; |
| if (!mixin) { |
| throw new Error("Interface " + id + " not found (implemented by " + thing.name + ")"); |
| } |
| return mixin; |
| }, this); |
| if (mixins.some(function(m) { return m.has_to_json_regular_operation() } )) { return true; } |
| } |
| if (!thing.base) { return false; } |
| base = this.members[thing.base]; |
| if (!base) { |
| throw new Error("Interface " + thing.base + " not found (inherited by " + thing.name + ")"); |
| } |
| thing = base; |
| } |
| return false; |
| } |
| return false; |
| } |
| }; |
| |
| function exposure_set(object, default_set) { |
| var exposed = object.extAttrs && object.extAttrs.filter(a => a.name === "Exposed"); |
| if (exposed && exposed.length > 1) { |
| throw new IdlHarnessError( |
| `Multiple 'Exposed' extended attributes on ${object.name}`); |
| } |
| |
| let result = default_set || ["Window"]; |
| if (result && !(result instanceof Set)) { |
| result = new Set(result); |
| } |
| if (exposed && exposed.length) { |
| const { rhs } = exposed[0]; |
| // Could be a list or a string. |
| const set = rhs.type === "identifier-list" ? |
| rhs.value.map(id => id.value) : |
| [ rhs.value ]; |
| result = new Set(set); |
| } |
| if (result && result.has("Worker")) { |
| result.delete("Worker"); |
| result.add("DedicatedWorker"); |
| result.add("ServiceWorker"); |
| result.add("SharedWorker"); |
| } |
| return result; |
| } |
| |
| function exposed_in(globals) { |
| if ('document' in self) { |
| return globals.has("Window"); |
| } |
| if ('DedicatedWorkerGlobalScope' in self && |
| self instanceof DedicatedWorkerGlobalScope) { |
| return globals.has("DedicatedWorker"); |
| } |
| if ('SharedWorkerGlobalScope' in self && |
| self instanceof SharedWorkerGlobalScope) { |
| return globals.has("SharedWorker"); |
| } |
| if ('ServiceWorkerGlobalScope' in self && |
| self instanceof ServiceWorkerGlobalScope) { |
| return globals.has("ServiceWorker"); |
| } |
| throw new IdlHarnessError("Unexpected global object"); |
| } |
| |
| /** |
| * Asserts that the given error message is thrown for the given function. |
| * @param {string|IdlHarnessError} error Expected Error message. |
| * @param {Function} idlArrayFunc Function operating on an IdlArray that should throw. |
| */ |
| IdlArray.prototype.assert_throws = function(error, idlArrayFunc) |
| { |
| try { |
| idlArrayFunc.call(this, this); |
| } catch (e) { |
| if (e instanceof AssertionError) { |
| throw e; |
| } |
| // Assertions for behaviour of the idlharness.js engine. |
| if (error instanceof IdlHarnessError) { |
| error = error.message; |
| } |
| if (e.message !== error) { |
| throw new IdlHarnessError(`${idlArrayFunc} threw "${e}", not the expected IdlHarnessError "${error}"`); |
| } |
| return; |
| } |
| throw new IdlHarnessError(`${idlArrayFunc} did not throw the expected IdlHarnessError`); |
| } |
| |
| 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.collapse_partials(); |
| |
| for (var lhs in this["implements"]) |
| { |
| this.recursively_get_implements(lhs).forEach(function(rhs) |
| { |
| var errStr = lhs + " implements " + rhs + ", but "; |
| if (!(lhs in this.members)) throw errStr + lhs + " is undefined."; |
| if (!(this.members[lhs] instanceof IdlInterface)) throw errStr + lhs + " is not an interface."; |
| if (!(rhs in this.members)) throw errStr + rhs + " is undefined."; |
| if (!(this.members[rhs] instanceof IdlInterface)) throw errStr + rhs + " is not an interface."; |
| |
| if (this.members[rhs].members.length) { |
| test(function () { |
| var clash = this.members[rhs].members.find(function(member) { |
| return this.members[lhs].members.find(function(m) { |
| return this.are_duplicate_members(m, member); |
| }.bind(this)); |
| }.bind(this)); |
| this.members[rhs].members.forEach(function(member) { |
| this.members[lhs].members.push(new IdlInterfaceMember(member)); |
| }.bind(this)); |
| assert_true(!clash, "member " + (clash && clash.name) + " is unique"); |
| }.bind(this), lhs + " implements " + rhs + ": member names are unique"); |
| } |
| }.bind(this)); |
| } |
| this["implements"] = {}; |
| |
| for (var lhs in this["includes"]) |
| { |
| this.recursively_get_includes(lhs).forEach(function(rhs) |
| { |
| var errStr = lhs + " includes " + rhs + ", but "; |
| if (!(lhs in this.members)) throw errStr + lhs + " is undefined."; |
| if (!(this.members[lhs] instanceof IdlInterface)) throw errStr + lhs + " is not an interface."; |
| if (!(rhs in this.members)) throw errStr + rhs + " is undefined."; |
| if (!(this.members[rhs] instanceof IdlInterface)) throw errStr + rhs + " is not an interface."; |
| |
| if (this.members[rhs].members.length) { |
| test(function () { |
| var clash = this.members[rhs].members.find(function(member) { |
| return this.members[lhs].members.find(function(m) { |
| return this.are_duplicate_members(m, member); |
| }.bind(this)); |
| }.bind(this)); |
| this.members[rhs].members.forEach(function(member) { |
| assert_true( |
| this.members[lhs].members.every(m => !this.are_duplicate_members(m, member)), |
| "member " + member.name + " is unique"); |
| this.members[lhs].members.push(new IdlInterfaceMember(member)); |
| }.bind(this)); |
| assert_true(!clash, "member " + (clash && clash.name) + " is unique"); |
| }.bind(this), lhs + " includes " + rhs + ": member names are unique"); |
| } |
| }.bind(this)); |
| } |
| this["includes"] = {}; |
| |
| // Assert B defined for A : B |
| for (const member of Object.values(this.members).filter(m => m.base)) { |
| const lhs = member.name; |
| const rhs = member.base; |
| if (!(rhs in this.members)) throw new IdlHarnessError(`${lhs} inherits ${rhs}, but ${rhs} is undefined.`); |
| const lhs_is_interface = this.members[lhs] instanceof IdlInterface; |
| const rhs_is_interface = this.members[rhs] instanceof IdlInterface; |
| if (rhs_is_interface != lhs_is_interface) { |
| if (!lhs_is_interface) throw new IdlHarnessError(`${lhs} inherits ${rhs}, but ${lhs} is not an interface.`); |
| if (!rhs_is_interface) throw new IdlHarnessError(`${lhs} inherits ${rhs}, but ${rhs} is not an interface.`); |
| } |
| // Check for circular dependencies. |
| member.get_inheritance_stack(); |
| } |
| |
| Object.getOwnPropertyNames(this.members).forEach(function(memberName) { |
| var member = this.members[memberName]; |
| if (!(member instanceof IdlInterface)) { |
| return; |
| } |
| |
| var globals = exposure_set(member); |
| 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) |
| { |
| const objects = this.objects[name]; |
| if (!objects || !Array.isArray(objects)) { |
| throw new IdlHarnessError(`Invalid or empty objects for member ${name}`); |
| } |
| objects.forEach(function(str) |
| { |
| if (!this.members[name] || !(this.members[name] instanceof IdlInterface)) { |
| throw new IdlHarnessError(`Invalid object member name ${name}`); |
| } |
| this.members[name].test_object(str); |
| }.bind(this)); |
| } |
| } |
| }; |
| |
| IdlArray.prototype.collapse_partials = function() |
| { |
| const testedPartials = new Map(); |
| this.partials.forEach(function(parsed_idl) |
| { |
| const originalExists = parsed_idl.name in this.members |
| && (this.members[parsed_idl.name] instanceof IdlInterface |
| || this.members[parsed_idl.name] instanceof IdlDictionary |
| || this.members[parsed_idl.name] instanceof IdlNamespace); |
| |
| // Ensure unique test name in case of multiple partials. |
| let partialTestName = parsed_idl.name; |
| let partialTestCount = 1; |
| if (testedPartials.has(parsed_idl.name)) { |
| partialTestCount += testedPartials.get(parsed_idl.name); |
| partialTestName = `${partialTestName}[${partialTestCount}]`; |
| } |
| testedPartials.set(parsed_idl.name, partialTestCount); |
| |
| if (!parsed_idl.untested) { |
| test(function () { |
| assert_true(originalExists, `Original ${parsed_idl.type} should be defined`); |
| |
| var expected; |
| switch (parsed_idl.type) { |
| case 'dictionary': expected = IdlDictionary; break; |
| case 'namespace': expected = IdlNamespace; break; |
| case 'interface': |
| case 'interface mixin': |
| default: |
| expected = IdlInterface; break; |
| } |
| assert_true( |
| expected.prototype.isPrototypeOf(this.members[parsed_idl.name]), |
| `Original ${parsed_idl.name} definition should have type ${parsed_idl.type}`); |
| }.bind(this), `Partial ${parsed_idl.type} ${partialTestName}: original ${parsed_idl.type} defined`); |
| } |
| if (!originalExists) { |
| // Not good.. but keep calm and carry on. |
| return; |
| } |
| |
| if (parsed_idl.extAttrs) |
| { |
| // Special-case "Exposed". Must be a subset of original interface's exposure. |
| // Exposed on a partial is the equivalent of having the same Exposed on all nested members. |
| // See https://github.com/heycam/webidl/issues/154 for discrepency between Exposed and |
| // other extended attributes on partial interfaces. |
| const exposureAttr = parsed_idl.extAttrs.find(a => a.name === "Exposed"); |
| if (exposureAttr) { |
| if (!parsed_idl.untested) { |
| test(function () { |
| const partialExposure = exposure_set(parsed_idl); |
| const memberExposure = exposure_set(this.members[parsed_idl.name]); |
| partialExposure.forEach(name => { |
| if (!memberExposure || !memberExposure.has(name)) { |
| throw new IdlHarnessError( |
| `Partial ${parsed_idl.name} ${parsed_idl.type} is exposed to '${name}', the original ${parsed_idl.type} is not.`); |
| } |
| }); |
| }.bind(this), `Partial ${parsed_idl.type} ${partialTestName}: valid exposure set`); |
| } |
| parsed_idl.members.forEach(function (member) { |
| member.extAttrs.push(exposureAttr); |
| }.bind(this)); |
| } |
| |
| parsed_idl.extAttrs.forEach(function(extAttr) |
| { |
| // "Exposed" already handled above. |
| if (extAttr.name === "Exposed") { |
| return; |
| } |
| this.members[parsed_idl.name].extAttrs.push(extAttr); |
| }.bind(this)); |
| } |
| if (parsed_idl.members.length) { |
| test(function () { |
| var clash = parsed_idl.members.find(function(member) { |
| return this.members[parsed_idl.name].members.find(function(m) { |
| return this.are_duplicate_members(m, member); |
| }.bind(this)); |
| }.bind(this)); |
| parsed_idl.members.forEach(function(member) |
| { |
| this.members[parsed_idl.name].members.push(new IdlInterfaceMember(member)); |
| }.bind(this)); |
| assert_true(!clash, "member " + (clash && clash.name) + " is unique"); |
| }.bind(this), `Partial ${parsed_idl.type} ${partialTestName}: member names are unique`); |
| } |
| }.bind(this)); |
| this.partials = []; |
| } |
| |
| IdlArray.prototype.are_duplicate_members = function(m1, m2) { |
| if (m1.name !== m2.name) { |
| return false; |
| } |
| if (m1.type === 'operation' && m2.type === 'operation' |
| && m1.arguments.length !== m2.arguments.length) { |
| // Method overload. TODO: Deep comparison of arguments. |
| return false; |
| } |
| return true; |
| } |
| |
| IdlArray.prototype.assert_type_is = function(value, type) |
| { |
| if (type.idlType in this.members |
| && this.members[type.idlType] instanceof IdlTypedef) { |
| this.assert_type_is(value, this.members[type.idlType].idlType); |
| return; |
| } |
| |
| if (type.nullable && value === null) |
| { |
| // This is fine |
| return; |
| } |
| |
| if (type.union) { |
| for (var i = 0; i < type.idlType.length; i++) { |
| try { |
| this.assert_type_is(value, type.idlType[i]); |
| // No AssertionError, so we match one type in the union |
| return; |
| } catch(e) { |
| if (e instanceof AssertionError) { |
| // We didn't match this type, let's try some others |
| continue; |
| } |
| throw e; |
| } |
| } |
| // TODO: Is there a nice way to list the union's types in the message? |
| assert_true(false, "Attribute has value " + format_value(value) |
| + " which doesn't match any of the types in the union"); |
| |
| } |
| |
| /** |
| * Helper function that tests that value is an instance of type according |
| * to the rules of WebIDL. value is any JavaScript value, and type is an |
| * object produced by WebIDLParser.js' "type" production. That production |
| * is fairly elaborate due to the complexity of WebIDL's types, so it's |
| * best to look at the grammar to figure out what properties it might have. |
| */ |
| if (type.idlType == "any") |
| { |
| // No assertions to make |
| return; |
| } |
| |
| if (type.array) |
| { |
| // TODO: not supported yet |
| return; |
| } |
| |
| if (type.generic === "sequence") |
| { |
| assert_true(Array.isArray(value), "should be an Array"); |
| if (!value.length) |
| { |
| // Nothing we can do. |
| return; |
| } |
| this.assert_type_is(value[0], type.idlType[0]); |
| return; |
| } |
| |
| if (type.generic === "Promise") { |
| assert_true("then" in value, "Attribute with a Promise type should have 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[0]); |
| return; |
| } |
| |
| type = Array.isArray(type.idlType) ? type.idlType[0] : type.idlType; |
| |
| switch(type) |
| { |
| case "void": |
| assert_equals(value, undefined); |
| return; |
| |
| case "boolean": |
| assert_equals(typeof value, "boolean"); |
| return; |
| |
| case "byte": |
| assert_equals(typeof value, "number"); |
| assert_equals(value, Math.floor(value), "should be an integer"); |
| assert_true(-128 <= value && value <= 127, "byte " + value + " should be in range [-128, 127]"); |
| return; |
| |
| case "octet": |
| assert_equals(typeof value, "number"); |
| assert_equals(value, Math.floor(value), "should be an integer"); |
| assert_true(0 <= value && value <= 255, "octet " + value + " should be in range [0, 255]"); |
| return; |
| |
| case "short": |
| assert_equals(typeof value, "number"); |
| assert_equals(value, Math.floor(value), "should be an integer"); |
| assert_true(-32768 <= value && value <= 32767, "short " + value + " should be in range [-32768, 32767]"); |
| return; |
| |
| case "unsigned short": |
| assert_equals(typeof value, "number"); |
| assert_equals(value, Math.floor(value), "should be an integer"); |
| assert_true(0 <= value && value <= 65535, "unsigned short " + value + " should be in range [0, 65535]"); |
| return; |
| |
| case "long": |
| assert_equals(typeof value, "number"); |
| assert_equals(value, Math.floor(value), "should be an integer"); |
| assert_true(-2147483648 <= value && value <= 2147483647, "long " + value + " should be in range [-2147483648, 2147483647]"); |
| return; |
| |
| case "unsigned long": |
| assert_equals(typeof value, "number"); |
| assert_equals(value, Math.floor(value), "should be an integer"); |
| assert_true(0 <= value && value <= 4294967295, "unsigned long " + value + " should be in range [0, 4294967295]"); |
| return; |
| |
| case "long long": |
| assert_equals(typeof value, "number"); |
| return; |
| |
| case "unsigned long long": |
| case "DOMTimeStamp": |
| assert_equals(typeof value, "number"); |
| assert_true(0 <= value, "unsigned long long should be positive"); |
| 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": |
| 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": |
| assert_equals(typeof value, "number"); |
| return; |
| |
| case "DOMString": |
| 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 "Int8Array": |
| case "Int16Array": |
| case "Int32Array": |
| case "Uint8Array": |
| case "Uint16Array": |
| case "Uint32Array": |
| case "Uint8ClampedArray": |
| case "Float32Array": |
| case "Float64Array": |
| case "ArrayBuffer": |
| case "DataView": |
| case "Function": |
| assert_true(value instanceof self[type], "wrong type: not a " + type); |
| return; |
| |
| case "object": |
| assert_in_array(typeof value, ["object", "function"], "wrong type: not object or function"); |
| return; |
| } |
| |
| if (!(type in this.members)) |
| { |
| throw new IdlHarnessError("Unrecognized type " + type); |
| } |
| |
| if (this.members[type] instanceof IdlInterface) |
| { |
| // We don't want to run the full |
| // IdlInterface.prototype.test_instance_of, because that could result |
| // in an infinite loop. TODO: This means we don't have tests for |
| // NoInterfaceObject interfaces, and we also can't test objects that |
| // come from another self. |
| assert_in_array(typeof value, ["object", "function"], "wrong type: not object or function"); |
| if (value instanceof Object |
| && !this.members[type].has_extended_attribute("NoInterfaceObject") |
| && type in self) |
| { |
| assert_true(value instanceof self[type], "instanceof " + type); |
| } |
| } |
| else if (this.members[type] instanceof IdlEnum) |
| { |
| assert_equals(typeof value, "string"); |
| } |
| else if (this.members[type] instanceof IdlDictionary) |
| { |
| // TODO: Test when we actually have something to test this on |
| } |
| else if (this.members[type] instanceof IdlCallback) |
| { |
| assert_equals(typeof value, "function"); |
| } |
| else |
| { |
| throw new IdlHarnessError("Type " + type + " isn't an interface, callback or dictionary"); |
| } |
| }; |
| |
| /// IdlObject /// |
| function IdlObject() {} |
| IdlObject.prototype.test = function() |
| { |
| /** |
| * By default, this does nothing, so no actual tests are run for IdlObjects |
| * that don't define any (e.g., IdlDictionary at the time of this writing). |
| */ |
| }; |
| |
| IdlObject.prototype.has_extended_attribute = function(name) |
| { |
| /** |
| * This is only meaningful for things that support extended attributes, |
| * such as interfaces, exceptions, and members. |
| */ |
| return this.extAttrs.some(function(o) |
| { |
| return o.name == name; |
| }); |
| }; |
| |
| |
| /// IdlDictionary /// |
| // Used for IdlArray.prototype.assert_type_is |
| function IdlDictionary(obj) |
| { |
| /** |
| * obj is an object produced by the WebIDLParser.js "dictionary" |
| * production. |
| */ |
| |
| /** Self-explanatory. */ |
| this.name = obj.name; |
| |
| /** A back-reference to our IdlArray. */ |
| this.array = obj.array; |
| |
| /** An array of objects produced by the "dictionaryMember" production. */ |
| this.members = obj.members; |
| |
| /** |
| * 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); |
| |
| IdlDictionary.prototype.get_inheritance_stack = function() { |
| return IdlInterface.prototype.get_inheritance_stack.call(this); |
| }; |
| |
| /// IdlInterface /// |
| function IdlInterface(obj, is_callback, is_mixin) |
| { |
| /** |
| * 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 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.has_extended_attribute("LegacyUnforgeable")) { |
| this.members |
| .filter(function(m) { return m.special !== "static" && (m.type == "attribute" || m.type == "operation"); }) |
| .forEach(function(m) { return m.isUnforgeable = true; }); |
| } |
| |
| /** |
| * 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; |
| this._is_mixin = is_mixin; |
| } |
| IdlInterface.prototype = Object.create(IdlObject.prototype); |
| IdlInterface.prototype.is_callback = function() |
| { |
| return this._is_callback; |
| }; |
| |
| IdlInterface.prototype.is_mixin = function() |
| { |
| return this._is_mixin; |
| }; |
| |
| IdlInterface.prototype.has_constants = function() |
| { |
| return this.members.some(function(member) { |
| return member.type === "const"; |
| }); |
| }; |
| |
| IdlInterface.prototype.get_unscopables = function() |
| { |
| return this.members.filter(function(member) { |
| return member.isUnscopable; |
| }); |
| }; |
| |
| IdlInterface.prototype.is_global = function() |
| { |
| return this.extAttrs.some(function(attribute) { |
| return attribute.name === "Global"; |
| }); |
| }; |
| |
| /** |
| * Value of the LegacyNamespace extended attribute, if any. |
| * |
| * https://heycam.github.io/webidl/#LegacyNamespace |
| */ |
| IdlInterface.prototype.get_legacy_namespace = function() |
| { |
| var legacyNamespace = this.extAttrs.find(function(attribute) { |
| return attribute.name === "LegacyNamespace"; |
| }); |
| return legacyNamespace ? legacyNamespace.rhs.value : undefined; |
| }; |
| |
| IdlInterface.prototype.get_interface_object_owner = function() |
| { |
| var legacyNamespace = this.get_legacy_namespace(); |
| return legacyNamespace ? self[legacyNamespace] : self; |
| }; |
| |
| IdlInterface.prototype.assert_interface_object_exists = function() |
| { |
| var owner = this.get_legacy_namespace() || "self"; |
| assert_own_property(self[owner], this.name, owner + " does not have own property " + format_value(this.name)); |
| }; |
| |
| IdlInterface.prototype.get_interface_object = function() { |
| if (this.has_extended_attribute("NoInterfaceObject")) { |
| throw new IdlHarnessError(this.name + " has no interface object due to NoInterfaceObject"); |
| } |
| |
| return this.get_interface_object_owner()[this.name]; |
| }; |
| |
| IdlInterface.prototype.get_qualified_name = function() { |
| // https://heycam.github.io/webidl/#qualified-name |
| var legacyNamespace = this.get_legacy_namespace(); |
| if (legacyNamespace) { |
| return legacyNamespace + "." + this.name; |
| } |
| return this.name; |
| }; |
| |
| IdlInterface.prototype.has_to_json_regular_operation = function() { |
| return this.members.some(function(m) { |
| return m.is_to_json_regular_operation(); |
| }); |
| }; |
| |
| IdlInterface.prototype.has_default_to_json_regular_operation = function() { |
| return this.members.some(function(m) { |
| return m.is_to_json_regular_operation() && m.has_extended_attribute("Default"); |
| }); |
| }; |
| |
| IdlInterface.prototype.get_inheritance_stack = function() { |
| /** |
| * See https://heycam.github.io/webidl/#create-an-inheritance-stack |
| * |
| * Returns an array of IdlInterface objects which contains itself |
| * and all of its inherited interfaces. |
| * |
| * So given: |
| * |
| * A : B {}; |
| * B : C {}; |
| * C {}; |
| * |
| * then A.get_inheritance_stack() should return [A, B, C], |
| * and B.get_inheritance_stack() should return [B, C]. |
| * |
| * Note: as dictionary inheritance is expressed identically by the AST, |
| * this works just as well for getting a stack of inherited dictionaries. |
| */ |
| |
| var stack = [this]; |
| var idl_interface = this; |
| while (idl_interface.base) { |
| var base = this.array.members[idl_interface.base]; |
| if (!base) { |
| throw new Error(idl_interface.type + " " + idl_interface.base + " not found (inherited by " + idl_interface.name + ")"); |
| } else if (stack.indexOf(base) > -1) { |
| stack.push(base); |
| let dep_chain = stack.map(i => i.name).join(','); |
| throw new IdlHarnessError(`${this.name} has a circular dependency: ${dep_chain}`); |
| } |
| idl_interface = base; |
| stack.push(idl_interface); |
| } |
| return stack; |
| }; |
| |
| /** |
| * Implementation of |
| * https://heycam.github.io/webidl/#default-tojson-operation |
| * for testing purposes. |
| * |
| * Collects the IDL types of the attributes that meet the criteria |
| * for inclusion in the default toJSON operation for easy |
| * comparison with actual value |
| */ |
| IdlInterface.prototype.default_to_json_operation = function(callback) { |
| var map = new Map(), isDefault = false; |
| this.traverse_inherited_and_consequential_interfaces(function(I) { |
| if (I.has_default_to_json_regular_operation()) { |
| isDefault = true; |
| I.members.forEach(function(m) { |
| if (m.special !== "static" && m.type == "attribute" && I.array.is_json_type(m.idlType)) { |
| map.set(m.name, m.idlType); |
| } |
| }); |
| } else if (I.has_to_json_regular_operation()) { |
| isDefault = false; |
| } |
| }); |
| return isDefault ? map : null; |
| }; |
| |
| /** |
| * Traverses inherited interfaces from the top down |
| * and imeplemented interfaces inside out. |
| * Invokes |callback| on each interface. |
| * |
| * This is an abstract implementation of the traversal |
| * algorithm specified in: |
| * https://heycam.github.io/webidl/#collect-attribute-values |
| * Given the following inheritance tree: |
| * |
| * F |
| * | |
| * C E - I |
| * | | |
| * B - D |
| * | |
| * G - A - H - J |
| * |
| * Invoking traverse_inherited_and_consequential_interfaces() on A |
| * would traverse the tree in the following order: |
| * C -> B -> F -> E -> I -> D -> A -> G -> H -> J |
| */ |
| |
| IdlInterface.prototype.traverse_inherited_and_consequential_interfaces = function(callback) { |
| if (typeof callback != "function") { |
| throw new TypeError(); |
| } |
| var stack = this.get_inheritance_stack(); |
| _traverse_inherited_and_consequential_interfaces(stack, callback); |
| }; |
| |
| function _traverse_inherited_and_consequential_interfaces(stack, callback) { |
| var I = stack.pop(); |
| callback(I); |
| var mixins = I.array["implements"][I.name] || I.array["includes"][I.name]; |
| if (mixins) { |
| mixins.forEach(function(id) { |
| var mixin = I.array.members[id]; |
| if (!mixin) { |
| throw new Error("Interface " + id + " not found (implemented by " + I.name + ")"); |
| } |
| var interfaces = mixin.get_inheritance_stack(); |
| _traverse_inherited_and_consequential_interfaces(interfaces, callback); |
| }); |
| } |
| if (stack.length > 0) { |
| _traverse_inherited_and_consequential_interfaces(stack, callback); |
| } |
| } |
| |
| IdlInterface.prototype.test = function() |
| { |
| if (this.has_extended_attribute("NoInterfaceObject") || this.is_mixin()) |
| { |
| // 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) { |
| subsetTestByKey(this.name, 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(); |
| }; |
| |
| // This supports both Constructor extended attributes and constructor |
| // operations until all idl fragments have been updated. |
| IdlInterface.prototype.constructors = function() |
| { |
| var extendedAttributes = this.extAttrs |
| .filter(function(attr) { return attr.name == "Constructor"; }); |
| var operations = this.members |
| .filter(function(m) { return m.type == "constructor"; }); |
| return extendedAttributes.concat(operations); |
| } |
| |
| IdlInterface.prototype.test_self = function() |
| { |
| subsetTestByKey(this.name, test, function() |
| { |
| // This function tests WebIDL as of 2015-01-13. |
| |
| // "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, |
| // [[Enumerable]]: false, [[Configurable]]: true }." |
| if (this.is_callback() && !this.has_constants()) { |
| return; |
| } |
| |
| // TODO: Should we test here that the property is actually writable |
| // etc., or trust getOwnPropertyDescriptor? |
| this.assert_interface_object_exists(); |
| var desc = Object.getOwnPropertyDescriptor(this.get_interface_object_owner(), this.name); |
| assert_false("get" in desc, "self's property " + format_value(this.name) + " should not have a getter"); |
| assert_false("set" in desc, "self's property " + format_value(this.name) + " should not have a setter"); |
| assert_true(desc.writable, "self's property " + format_value(this.name) + " should be writable"); |
| assert_false(desc.enumerable, "self's property " + format_value(this.name) + " should not be enumerable"); |
| assert_true(desc.configurable, "self's property " + format_value(this.name) + " should be configurable"); |
| |
| if (this.is_callback()) { |
| // "The internal [[Prototype]] property of an interface object for |
| // a callback interface must be the Function.prototype object." |
| assert_equals(Object.getPrototypeOf(this.get_interface_object()), 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:" |
| |
| // Its [[Prototype]] internal property is otherwise specified (see |
| // below). |
| |
| // "* Its [[Get]] internal property is set as described in ECMA-262 |
| // section 9.1.8." |
| // Not much to test for this. |
| |
| // "* Its [[Construct]] internal property is set as described in |
| // ECMA-262 section 19.2.2.3." |
| // Tested below if no constructor is defined. TODO: test constructors |
| // if defined. |
| |
| // "* Its @@hasInstance property is set as described in ECMA-262 |
| // section 19.2.3.8, unless otherwise specified." |
| // TODO |
| |
| // ES6 (rev 30) 19.1.3.6: |
| // "Else, if O has a [[Call]] internal method, then let builtinTag be |
| // "Function"." |
| assert_class_string(this.get_interface_object(), "Function", "class string of " + this.name); |
| |
| // "The [[Prototype]] internal property of an interface object for a |
| // non-callback interface is determined as follows:" |
| var prototype = Object.getPrototypeOf(this.get_interface_object()); |
| if (this.base) { |
| // "* If the interface inherits from some other interface, the |
| // value of [[Prototype]] is the interface object for that other |
| // interface." |
| var inherited_interface = this.array.members[this.base]; |
| if (!inherited_interface.has_extended_attribute("NoInterfaceObject")) { |
| inherited_interface.assert_interface_object_exists(); |
| assert_equals(prototype, inherited_interface.get_interface_object(), |
| 'prototype of ' + this.name + ' is not ' + |
| this.base); |
| } |
| } else { |
| // "If the interface doesn't inherit from any other interface, the |
| // value of [[Prototype]] is %FunctionPrototype% ([ECMA-262], |
| // section 6.1.7.4)." |
| assert_equals(prototype, Function.prototype, |
| "prototype of self's property " + format_value(this.name) + " is not Function.prototype"); |
| } |
| |
| if (!this.constructors().length) { |
| // "The internal [[Call]] method of the interface object behaves as |
| // follows . . . |
| // |
| // "If I was not declared with a [Constructor] extended attribute, |
| // then throw a TypeError." |
| var interface_object = this.get_interface_object(); |
| assert_throws_js(globalOf(interface_object).TypeError, function() { |
| interface_object(); |
| }, "interface object didn't throw TypeError when called as a function"); |
| assert_throws_js(globalOf(interface_object).TypeError, function() { |
| new interface_object(); |
| }, "interface object didn't throw TypeError when called as a constructor"); |
| } |
| }.bind(this), this.name + " interface: existence and properties of interface object"); |
| |
| if (!this.is_callback()) { |
| subsetTestByKey(this.name, test, function() { |
| // This function tests WebIDL as of 2014-10-25. |
| // https://heycam.github.io/webidl/#es-interface-call |
| |
| this.assert_interface_object_exists(); |
| |
| // "Interface objects for non-callback interfaces MUST have a |
| // property named “length” with attributes { [[Writable]]: false, |
| // [[Enumerable]]: false, [[Configurable]]: true } whose value is |
| // a Number." |
| assert_own_property(this.get_interface_object(), "length"); |
| var desc = Object.getOwnPropertyDescriptor(this.get_interface_object(), "length"); |
| assert_false("get" in desc, this.name + ".length should not have a getter"); |
| assert_false("set" in desc, this.name + ".length should not have a setter"); |
| assert_false(desc.writable, this.name + ".length should not be writable"); |
| assert_false(desc.enumerable, this.name + ".length should not be enumerable"); |
| assert_true(desc.configurable, this.name + ".length should be configurable"); |
| |
| var constructors = this.constructors(); |
| var expected_length = minOverloadLength(constructors); |
| assert_equals(this.get_interface_object().length, expected_length, "wrong value for " + this.name + ".length"); |
| }.bind(this), this.name + " interface object length"); |
| } |
| |
| if (!this.is_callback() || this.has_constants()) { |
| subsetTestByKey(this.name, test, function() { |
| // This function tests WebIDL as of 2015-11-17. |
| // https://heycam.github.io/webidl/#interface-object |
| |
| this.assert_interface_object_exists(); |
| |
| // "All interface objects must have a property named “name” with |
| // attributes { [[Writable]]: false, [[Enumerable]]: false, |
| // [[Configurable]]: true } whose value is the identifier of the |
| // corresponding interface." |
| |
| assert_own_property(this.get_interface_object(), "name"); |
| var desc = Object.getOwnPropertyDescriptor(this.get_interface_object(), "name"); |
| assert_false("get" in desc, this.name + ".name should not have a getter"); |
| assert_false("set" in desc, this.name + ".name should not have a setter"); |
| assert_false(desc.writable, this.name + ".name should not be writable"); |
| assert_false(desc.enumerable, this.name + ".name should not be enumerable"); |
| assert_true(desc.configurable, this.name + ".name should be configurable"); |
| assert_equals(this.get_interface_object().name, this.name, "wrong value for " + this.name + ".name"); |
| }.bind(this), this.name + " interface object name"); |
| } |
| |
| |
| if (this.has_extended_attribute("LegacyWindowAlias")) { |
| subsetTestByKey(this.name, test, function() |
| { |
| var aliasAttrs = this.extAttrs.filter(function(o) { return o.name === "LegacyWindowAlias"; }); |
| if (aliasAttrs.length > 1) { |
| throw new IdlHarnessError("Invalid IDL: multiple LegacyWindowAlias extended attributes on " + this.name); |
| } |
| if (this.is_callback()) { |
| throw new IdlHarnessError("Invalid IDL: LegacyWindowAlias extended attribute on non-interface " + this.name); |
| } |
| if (!this.exposureSet.has("Window")) { |
| throw new IdlHarnessError("Invalid IDL: LegacyWindowAlias extended attribute on " + this.name + " which is not exposed in Window"); |
| } |
| // TODO: when testing of [NoInterfaceObject] interfaces is supported, |
| // check that it's not specified together with LegacyWindowAlias. |
| |
| // TODO: maybe check that [LegacyWindowAlias] is not specified on a partial interface. |
| |
| var rhs = aliasAttrs[0].rhs; |
| if (!rhs) { |
| throw new IdlHarnessError("Invalid IDL: LegacyWindowAlias extended attribute on " + this.name + " without identifier"); |
| } |
| var aliases; |
| if (rhs.type === "identifier-list") { |
| aliases = rhs.value.map(id => id.value); |
| } else { // rhs.type === identifier |
| aliases = [ rhs.value ]; |
| } |
| |
| // OK now actually check the aliases... |
| var alias; |
| if (exposed_in(exposure_set(this, this.exposureSet)) && 'document' in self) { |
| for (alias of aliases) { |
| assert_true(alias in self, alias + " should exist"); |
| assert_equals(self[alias], this.get_interface_object(), "self." + alias + " should be the same value as self." + this.get_qualified_name()); |
| var desc = Object.getOwnPropertyDescriptor(self, alias); |
| assert_equals(desc.value, this.get_interface_object(), "wrong value in " + alias + " property descriptor"); |
| assert_true(desc.writable, alias + " should be writable"); |
| assert_false(desc.enumerable, alias + " should not be enumerable"); |
| assert_true(desc.configurable, alias + " should be configurable"); |
| assert_false('get' in desc, alias + " should not have a getter"); |
| assert_false('set' in desc, alias + " should not have a setter"); |
| } |
| } else { |
| for (alias of aliases) { |
| assert_false(alias in self, alias + " should not exist"); |
| } |
| } |
| |
| }.bind(this), this.name + " interface: legacy window alias"); |
| } |
| |
| if (this.has_extended_attribute("NamedConstructor") || |
| this.has_extended_attribute("LegacyFactoryFunction")) { |
| var constructors = this.extAttrs |
| .filter(function(attr) { return attr.name == "NamedConstructor" || attr.name == "LegacyFactoryFunction"; }); |
| if (constructors.length !== 1) { |
| throw new IdlHarnessError("Internal error: missing support for multiple LegacyFactoryFunction extended attributes"); |
| } |
| var constructor = constructors[0]; |
| var min_length = minOverloadLength([constructor]); |
| |
| subsetTestByKey(this.name, test, function() |
| { |
| // This function tests WebIDL as of 2019-01-14. |
| |
| // "for every [LegacyFactoryFunction] extended attribute on an exposed |
| // interface, a corresponding property must exist on the ECMAScript |
| // global object. The name of the property is the |
| // [LegacyFactoryFunction]'s identifier, and its value is an object |
| // called a named constructor, ... . The property has the attributes |
| // { [[Writable]]: true, [[Enumerable]]: false, |
| // [[Configurable]]: true }." |
| var name = constructor.rhs.value; |
| assert_own_property(self, name); |
| var desc = Object.getOwnPropertyDescriptor(self, name); |
| assert_equals(desc.value, self[name], "wrong value in " + name + " property descriptor"); |
| assert_true(desc.writable, name + " should be writable"); |
| assert_false(desc.enumerable, name + " should not be enumerable"); |
| assert_true(desc.configurable, name + " should be configurable"); |
| assert_false("get" in desc, name + " should not have a getter"); |
| assert_false("set" in desc, name + " should not have a setter"); |
| }.bind(this), this.name + " interface: named constructor"); |
| |
| subsetTestByKey(this.name, test, function() |
| { |
| // This function tests WebIDL as of 2019-01-14. |
| |
| // "2. Let F be ! CreateBuiltinFunction(realm, steps, |
| // realm.[[Intrinsics]].[[%FunctionPrototype%]])." |
| var name = constructor.rhs.value; |
| var value = self[name]; |
| assert_equals(typeof value, "function", "type of value in " + name + " property descriptor"); |
| assert_not_equals(value, this.get_interface_object(), "wrong value in " + name + " property descriptor"); |
| assert_equals(Object.getPrototypeOf(value), Function.prototype, "wrong value for " + name + "'s prototype"); |
| }.bind(this), this.name + " interface: named constructor object"); |
| |
| subsetTestByKey(this.name, test, function() |
| { |
| // This function tests WebIDL as of 2019-01-14. |
| |
| // "7. Let proto be the interface prototype object of interface I |
| // in realm. |
| // "8. Perform ! DefinePropertyOrThrow(F, "prototype", |
| // PropertyDescriptor{ |
| // [[Value]]: proto, [[Writable]]: false, |
| // [[Enumerable]]: false, [[Configurable]]: false |
| // })." |
| var name = constructor.rhs.value; |
| var expected = this.get_interface_object().prototype; |
| var desc = Object.getOwnPropertyDescriptor(self[name], "prototype"); |
| assert_equals(desc.value, expected, "wrong value for " + name + ".prototype"); |
| assert_false(desc.writable, "prototype should not be writable"); |
| assert_false(desc.enumerable, "prototype should not be enumerable"); |
| assert_false(desc.configurable, "prototype should not be configurable"); |
| assert_false("get" in desc, "prototype should not have a getter"); |
| assert_false("set" in desc, "prototype should not have a setter"); |
| }.bind(this), this.name + " interface: named constructor prototype property"); |
| |
| subsetTestByKey(this.name, test, function() |
| { |
| // This function tests WebIDL as of 2019-01-14. |
| |
| // "3. Perform ! SetFunctionName(F, id)." |
| var name = constructor.rhs.value; |
| var desc = Object.getOwnPropertyDescriptor(self[name], "name"); |
| assert_equals(desc.value, name, "wrong value for " + name + ".name"); |
| assert_false(desc.writable, "name should not be writable"); |
| assert_false(desc.enumerable, "name should not be enumerable"); |
| assert_true(desc.configurable, "name should be configurable"); |
| assert_false("get" in desc, "name should not have a getter"); |
| assert_false("set" in desc, "name should not have a setter"); |
| }.bind(this), this.name + " interface: named constructor name"); |
| |
| subsetTestByKey(this.name, test, function() |
| { |
| // This function tests WebIDL as of 2019-01-14. |
| |
| // "4. Initialize S to the effective overload set for constructors |
| // with identifier id on interface I and with argument count 0. |
| // "5. Let length be the length of the shortest argument list of |
| // the entries in S. |
| // "6. Perform ! SetFunctionLength(F, length)." |
| var name = constructor.rhs.value; |
| var desc = Object.getOwnPropertyDescriptor(self[name], "length"); |
| assert_equals(desc.value, min_length, "wrong value for " + name + ".length"); |
| assert_false(desc.writable, "length should not be writable"); |
| assert_false(desc.enumerable, "length should not be enumerable"); |
| assert_true(desc.configurable, "length should be configurable"); |
| assert_false("get" in desc, "length should not have a getter"); |
| assert_false("set" in desc, "length should not have a setter"); |
| }.bind(this), this.name + " interface: named constructor length"); |
| |
| subsetTestByKey(this.name, test, function() |
| { |
| // This function tests WebIDL as of 2019-01-14. |
| |
| // "1. Let steps be the following steps: |
| // " 1. If NewTarget is undefined, then throw a TypeError." |
| var name = constructor.rhs.value; |
| var args = constructor.arguments.map(function(arg) { |
| return create_suitable_object(arg.idlType); |
| }); |
| assert_throws_js(globalOf(self[name]).TypeError, function() { |
| self[name](...args); |
| }.bind(this)); |
| }.bind(this), this.name + " interface: named constructor without 'new'"); |
| } |
| |
| subsetTestByKey(this.name, test, function() |
| { |
| // This function tests WebIDL as of 2015-01-21. |
| // https://heycam.github.io/webidl/#interface-object |
| |
| if (this.is_callback() && !this.has_constants()) { |
| return; |
| } |
| |
| this.assert_interface_object_exists(); |
| |
| if (this.is_callback()) { |
| assert_false("prototype" in this.get_interface_object(), |
| this.name + ' should not have a "prototype" property'); |
| return; |
| } |
| |
| // "An interface object for a non-callback interface must have a |
| // property named “prototype” with attributes { [[Writable]]: false, |
| // [[Enumerable]]: false, [[Configurable]]: false } whose value is an |
| // object called the interface prototype object. This object has |
| // properties that correspond to the regular attributes and regular |
| // operations defined on the interface, and is described in more detail |
| // in section 4.5.4 below." |
| assert_own_property(this.get_interface_object(), "prototype", |
| 'interface "' + this.name + '" does not have own property "prototype"'); |
| var desc = Object.getOwnPropertyDescriptor(this.get_interface_object(), "prototype"); |
| assert_false("get" in desc, this.name + ".prototype should not have a getter"); |
| assert_false("set" in desc, this.name + ".prototype should not have a setter"); |
| assert_false(desc.writable, this.name + ".prototype should not be writable"); |
| assert_false(desc.enumerable, this.name + ".prototype should not be enumerable"); |
| assert_false(desc.configurable, this.name + ".prototype should not be configurable"); |
| |
| // Next, test that the [[Prototype]] of the interface prototype object |
| // is correct. (This is made somewhat difficult by the existence of |
| // [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] extended |
| // attribute, and A supports named properties, then return the named |
| // 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, return %ObjectPrototype%. |
| // |
| // "In the ECMAScript binding, the DOMException type has some additional |
| // requirements: |
| // |
| // "Unlike normal interface types, the interface prototype object |
| // for DOMException must have as its [[Prototype]] the intrinsic |
| // object %ErrorPrototype%." |
| // |
| if (this.name === "Window") { |
| assert_class_string(Object.getPrototypeOf(this.get_interface_object().prototype), |
| 'WindowProperties', |
| 'Class name for prototype of Window' + |
| '.prototype is not "WindowProperties"'); |
| } else { |
| var inherit_interface, inherit_interface_interface_object; |
| if (this.base) { |
| inherit_interface = this.base; |
| var parent = this.array.members[inherit_interface]; |
| if (!parent.has_extended_attribute("NoInterfaceObject")) { |
| parent.assert_interface_object_exists(); |
| inherit_interface_interface_object = parent.get_interface_object(); |
| } |
| } else if (this.name === "DOMException") { |
| inherit_interface = 'Error'; |
| inherit_interface_interface_object = self.Error; |
| } else { |
| inherit_interface = 'Object'; |
| inherit_interface_interface_object = self.Object; |
| } |
| if (inherit_interface_interface_object) { |
| assert_not_equals(inherit_interface_interface_object, undefined, |
| 'should inherit from ' + inherit_interface + ', but there is no such property'); |
| assert_own_property(inherit_interface_interface_object, 'prototype', |
| 'should inherit from ' + inherit_interface + ', but that object has no "prototype" property'); |
| assert_equals(Object.getPrototypeOf(this.get_interface_object().prototype), |
| inherit_interface_interface_object.prototype, |
| 'prototype of ' + this.name + '.prototype is not ' + inherit_interface + '.prototype'); |
| } else { |
| // We can't test that we get the correct object, because this is the |
| // only way to get our hands on it. We only test that its class |
| // string, at least, is correct. |
| assert_class_string(Object.getPrototypeOf(this.get_interface_object().prototype), |
| inherit_interface + 'Prototype', |
| 'Class name for prototype of ' + this.name + |
| '.prototype is not "' + inherit_interface + 'Prototype"'); |
| } |
| } |
| |
| // "The class string of an interface prototype object is the |
| // concatenation of the interface’s qualified identifier and the string |
| // “Prototype”." |
| |
| // Skip these tests for now due to a specification issue about |
| // prototype name. |
| // https://www.w3.org/Bugs/Public/show_bug.cgi?id=28244 |
| |
| // assert_class_string(this.get_interface_object().prototype, this.get_qualified_name() + "Prototype", |
| // "class string of " + this.name + ".prototype"); |
| |
| // String() should end up calling {}.toString if nothing defines a |
| // stringifier. |
| if (!this.has_stringifier()) { |
| // assert_equals(String(this.get_interface_object().prototype), "[object " + this.get_qualified_name() + "Prototype]", |
| // "String(" + this.name + ".prototype)"); |
| } |
| }.bind(this), this.name + " interface: existence and properties of interface prototype object"); |
| |
| // "If the interface is declared with the [Global] |
| // extended attribute, or the interface is in the set of inherited |
| // interfaces for any other interface that is declared with one of these |
| // attributes, then the interface prototype object must be an immutable |
| // prototype exotic object." |
| // https://heycam.github.io/webidl/#interface-prototype-object |
| if (this.is_global()) { |
| this.test_immutable_prototype("interface prototype object", this.get_interface_object().prototype); |
| } |
| |
| subsetTestByKey(this.name, test, function() |
| { |
| if (this.is_callback() && !this.has_constants()) { |
| return; |
| } |
| |
| this.assert_interface_object_exists(); |
| |
| if (this.is_callback()) { |
| assert_false("prototype" in this.get_interface_object(), |
| this.name + ' should not have a "prototype" property'); |
| return; |
| } |
| |
| assert_own_property(this.get_interface_object(), "prototype", |
| 'interface "' + this.name + '" does not have own property "prototype"'); |
| |
| // "If the [NoInterfaceObject] extended attribute was not specified on |
| // the interface, then the interface prototype object must also have a |
| // property named “constructor” with attributes { [[Writable]]: true, |
| // [[Enumerable]]: false, [[Configurable]]: true } whose value is a |
| // reference to the interface object for the interface." |
| assert_own_property(this.get_interface_object().prototype, "constructor", |
| this.name + '.prototype does not have own property "constructor"'); |
| var desc = Object.getOwnPropertyDescriptor(this.get_interface_object().prototype, "constructor"); |
| assert_false("get" in desc, this.name + ".prototype.constructor should not have a getter"); |
| assert_false("set" in desc, this.name + ".prototype.constructor should not have a setter"); |
| assert_true(desc.writable, this.name + ".prototype.constructor should be writable"); |
| assert_false(desc.enumerable, this.name + ".prototype.constructor should not be enumerable"); |
| assert_true(desc.configurable, this.name + ".prototype.constructor should be configurable"); |
| assert_equals(this.get_interface_object().prototype.constructor, this.get_interface_object(), |
| 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'); |
| |
| |
| subsetTestByKey(this.name, test, function() |
| { |
| if (this.is_callback() && !this.has_constants()) { |
| return; |
| } |
| |
| this.assert_interface_object_exists(); |
| |
| if (this.is_callback()) { |
| assert_false("prototype" in this.get_interface_object(), |
| this.name + ' should not have a "prototype" property'); |
| return; |
| } |
| |
| assert_own_property(this.get_interface_object(), "prototype", |
| 'interface "' + this.name + '" does not have own property "prototype"'); |
| |
| // If the interface has any member declared with the [Unscopable] extended |
| // attribute, then there must be a property on the interface prototype object |
| // whose name is the @@unscopables symbol, which has the attributes |
| // { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }, |
| // and whose value is an object created as follows... |
| var unscopables = this.get_unscopables().map(m => m.name); |
| var proto = this.get_interface_object().prototype; |
| if (unscopables.length != 0) { |
| assert_own_property( |
| proto, Symbol.unscopables, |
| this.name + '.prototype should have an @@unscopables property'); |
| var desc = Object.getOwnPropertyDescriptor(proto, Symbol.unscopables); |
| assert_false("get" in desc, |
| this.name + ".prototype[Symbol.unscopables] should not have a getter"); |
| assert_false("set" in desc, this.name + ".prototype[Symbol.unscopables] should not have a setter"); |
| assert_false(desc.writable, this.name + ".prototype[Symbol.unscopables] should not be writable"); |
| assert_false(desc.enumerable, this.name + ".prototype[Symbol.unscopables] should not be enumerable"); |
| assert_true(desc.configurable, this.name + ".prototype[Symbol.unscopables] should be configurable"); |
| assert_equals(desc.value, proto[Symbol.unscopables], |
| this.name + '.prototype[Symbol.unscopables] should be in the descriptor'); |
| assert_equals(typeof desc.value, "object", |
| this.name + '.prototype[Symbol.unscopables] should be an object'); |
| assert_equals(Object.getPrototypeOf(desc.value), null, |
| this.name + '.prototype[Symbol.unscopables] should have a null prototype'); |
| assert_equals(Object.getOwnPropertySymbols(desc.value).length, |
| 0, |
| this.name + '.prototype[Symbol.unscopables] should have the right number of symbol-named properties'); |
| |
| // Check that we do not have _extra_ unscopables. Checking that we |
| // have all the ones we should will happen in the per-member tests. |
| var observed = Object.getOwnPropertyNames(desc.value); |
| for (var prop of observed) { |
| assert_not_equals(unscopables.indexOf(prop), |
| -1, |
| this.name + '.prototype[Symbol.unscopables] has unexpected property "' + prop + '"'); |
| } |
| } else { |
| assert_equals(Object.getOwnPropertyDescriptor(this.get_interface_object().prototype, Symbol.unscopables), |
| undefined, |
| this.name + '.prototype should not have @@unscopables'); |
| } |
| }.bind(this), this.name + ' interface: existence and properties of interface prototype object\'s @@unscopables property'); |
| }; |
| |
| IdlInterface.prototype.test_immutable_prototype = function(type, obj) |
| { |
| if (typeof Object.setPrototypeOf !== "function") { |
| return; |
| } |
| |
| subsetTestByKey(this.name, test, function(t) { |
| var originalValue = Object.getPrototypeOf(obj); |
| var newValue = Object.create(null); |
| |
| t.add_cleanup(function() { |
| try { |
| Object.setPrototypeOf(obj, originalValue); |
| } catch (err) {} |
| }); |
| |
| assert_throws_js(TypeError, function() { |
| Object.setPrototypeOf(obj, newValue); |
| }); |
| |
| assert_equals( |
| Object.getPrototypeOf(obj), |
| originalValue, |
| "original value not modified" |
| ); |
| }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " + |
| "of " + type + " - setting to a new value via Object.setPrototypeOf " + |
| "should throw a TypeError"); |
| |
| subsetTestByKey(this.name, test, function(t) { |
| var originalValue = Object.getPrototypeOf(obj); |
| var newValue = Object.create(null); |
| |
| t.add_cleanup(function() { |
| let setter = Object.getOwnPropertyDescriptor( |
| Object.prototype, '__proto__' |
| ).set; |
| |
| try { |
| setter.call(obj, originalValue); |
| } catch (err) {} |
| }); |
| |
| // We need to find the actual setter for the '__proto__' property, so we |
| // can determine the right global for it. Walk up the prototype chain |
| // looking for that property until we find it. |
| let setter; |
| { |
| let cur = obj; |
| while (cur) { |
| const desc = Object.getOwnPropertyDescriptor(cur, "__proto__"); |
| if (desc) { |
| setter = desc.set; |
| break; |
| } |
| cur = Object.getPrototypeOf(cur); |
| } |
| } |
| assert_throws_js(globalOf(setter).TypeError, function() { |
| obj.__proto__ = newValue; |
| }); |
| |
| assert_equals( |
| Object.getPrototypeOf(obj), |
| originalValue, |
| "original value not modified" |
| ); |
| }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " + |
| "of " + type + " - setting to a new value via __proto__ " + |
| "should throw a TypeError"); |
| |
| subsetTestByKey(this.name, test, function(t) { |
| var originalValue = Object.getPrototypeOf(obj); |
| var newValue = Object.create(null); |
| |
| t.add_cleanup(function() { |
| try { |
| Reflect.setPrototypeOf(obj, originalValue); |
| } catch (err) {} |
| }); |
| |
| assert_false(Reflect.setPrototypeOf(obj, newValue)); |
| |
| assert_equals( |
| Object.getPrototypeOf(obj), |
| originalValue, |
| "original value not modified" |
| ); |
| }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " + |
| "of " + type + " - setting to a new value via Reflect.setPrototypeOf " + |
| "should return false"); |
| |
| subsetTestByKey(this.name, test, function() { |
| var originalValue = Object.getPrototypeOf(obj); |
| |
| Object.setPrototypeOf(obj, originalValue); |
| }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " + |
| "of " + type + " - setting to its original value via Object.setPrototypeOf " + |
| "should not throw"); |
| |
| subsetTestByKey(this.name, test, function() { |
| var originalValue = Object.getPrototypeOf(obj); |
| |
| obj.__proto__ = originalValue; |
| }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " + |
| "of " + type + " - setting to its original value via __proto__ " + |
| "should not throw"); |
| |
| subsetTestByKey(this.name, test, function() { |
| var originalValue = Object.getPrototypeOf(obj); |
| |
| assert_true(Reflect.setPrototypeOf(obj, originalValue)); |
| }.bind(this), this.name + " interface: internal [[SetPrototypeOf]] method " + |
| "of " + type + " - setting to its original value via Reflect.setPrototypeOf " + |
| "should return true"); |
| }; |
| |
| IdlInterface.prototype.test_member_const = function(member) |
| { |
| if (!this.has_constants()) { |
| throw new IdlHarnessError("Internal error: test_member_const called without any constants"); |
| } |
| |
| subsetTestByKey(this.name, test, function() |
| { |
| this.assert_interface_object_exists(); |
| |
| // "For each constant defined on an interface A, there must be |
| // a corresponding property on the interface object, if it |
| // exists." |
| assert_own_property(this.get_interface_object(), 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(this.get_interface_object()[member.name], constValue(member.value), |
| "property has wrong value"); |
| // "The property has attributes { [[Writable]]: false, |
| // [[Enumerable]]: true, [[Configurable]]: false }." |
| var desc = Object.getOwnPropertyDescriptor(this.get_interface_object(), member.name); |
| assert_false("get" in desc, "property should not have a getter"); |
| assert_false("set" in desc, "property should not have a setter"); |
| assert_false(desc.writable, "property should not be writable"); |
| assert_true(desc.enumerable, "property should be enumerable"); |
| assert_false(desc.configurable, "property should not be 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." |
| subsetTestByKey(this.name, test, function() |
| { |
| this.assert_interface_object_exists(); |
| |
| if (this.is_callback()) { |
| assert_false("prototype" in this.get_interface_object(), |
| this.name + ' should not have a "prototype" property'); |
| return; |
| } |
| |
| assert_own_property(this.get_interface_object(), "prototype", |
| 'interface "' + this.name + '" does not have own property "prototype"'); |
| |
| assert_own_property(this.get_interface_object().prototype, member.name); |
| assert_equals(this.get_interface_object().prototype[member.name], constValue(member.value), |
| "property has wrong value"); |
| var desc = Object.getOwnPropertyDescriptor(this.get_interface_object(), member.name); |
| assert_false("get" in desc, "property should not have a getter"); |
| assert_false("set" in desc, "property should not have a setter"); |
| assert_false(desc.writable, "property should not be writable"); |
| assert_true(desc.enumerable, "property should be enumerable"); |
| assert_false(desc.configurable, "property should not be configurable"); |
| }.bind(this), this.name + " interface: constant " + member.name + " on interface prototype object"); |
| }; |
| |
| |
| IdlInterface.prototype.test_member_attribute = function(member) |
| { |
| if (!shouldRunSubTest(this.name)) { |
| return; |
| } |
| var a_test = subsetTestByKey(this.name, async_test, this.name + " interface: attribute " + member.name); |
| a_test.step(function() |
| { |
| if (this.is_callback() && !this.has_constants()) { |
| a_test.done() |
| return; |
| } |
| |
| this.assert_interface_object_exists(); |
| assert_own_property(this.get_interface_object(), "prototype", |
| 'interface "' + this.name + '" does not have own property "prototype"'); |
| |
| if (member.special === "static") { |
| assert_own_property(this.get_interface_object(), member.name, |
| "The interface object must have a property " + |
| format_value(member.name)); |
| a_test.done(); |
| return; |
| } |
| |
| this.do_member_unscopable_asserts(member); |
| |
| 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 this.get_interface_object().prototype, |
| "The prototype object should 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"); |
| } |
| |
| // 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 this.get_interface_object().prototype, |
| "The prototype object must have a property " + |
| format_value(member.name)); |
| |
| if (!member.has_extended_attribute("LenientThis") && |
| !member.has_extended_attribute("LegacyLenientThis")) { |
| if (member.idlType.generic !== "Promise") { |
| // this.get_interface_object() returns a thing in our global |
| assert_throws_js(TypeError, function() { |
| this.get_interface_object().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(this.get_interface_object().prototype, member, a_test); |
| } else { |
| promise_rejects_js(a_test, TypeError, |
| this.get_interface_object().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(this.get_interface_object().prototype, |
| member, a_test); |
| }.bind(this)); |
| } |
| } else { |
| assert_equals(this.get_interface_object().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(this.get_interface_object().prototype, member, a_test); |
| } |
| } |
| }.bind(this)); |
| }; |
| |
| IdlInterface.prototype.test_member_operation = function(member) |
| { |
| if (!shouldRunSubTest(this.name)) { |
| return; |
| } |
| var a_test = subsetTestByKey(this.name, async_test, this.name + " interface: operation " + member); |
| 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; |
| } |
| |
| this.assert_interface_object_exists(); |
| |
| if (this.is_callback()) { |
| assert_false("prototype" in this.get_interface_object(), |
| this.name + ' should not have a "prototype" property'); |
| a_test.done(); |
| return; |
| } |
| |
| assert_own_property(this.get_interface_object(), "prototype", |
| 'interface "' + this.name + '" does not have own property "prototype"'); |
| |
| // "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.special === "static") { |
| assert_own_property(this.get_interface_object(), member.name, |
| "interface object missing static operation"); |
| memberHolderObject = this.get_interface_object(); |
| // "* Otherwise, [...] if the interface was declared with the [Global] |
| // 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(this.get_interface_object().prototype, member.name, |
| "interface prototype object missing non-static operation"); |
| memberHolderObject = this.get_interface_object().prototype; |
| } |
| this.do_member_unscopable_asserts(member); |
| this.do_member_operation_asserts(memberHolderObject, member, a_test); |
| }.bind(this)); |
| }; |
| |
| IdlInterface.prototype.do_member_unscopable_asserts = function(member) |
| { |
| // Check that if the member is unscopable then it's in the |
| // @@unscopables object properly. |
| if (!member.isUnscopable) { |
| return; |
| } |
| |
| var unscopables = this.get_interface_object().prototype[Symbol.unscopables]; |
| var prop = member.name; |
| var propDesc = Object.getOwnPropertyDescriptor(unscopables, prop); |
| assert_equals(typeof propDesc, "object", |
| this.name + '.prototype[Symbol.unscopables].' + prop + ' must exist') |
| assert_false("get" in propDesc, |
| this.name + '.prototype[Symbol.unscopables].' + prop + ' must have no getter'); |
| assert_false("set" in propDesc, |
| this.name + '.prototype[Symbol.unscopables].' + prop + ' must have no setter'); |
| assert_true(propDesc.writable, |
| this.name + '.prototype[Symbol.unscopables].' + prop + ' must be writable'); |
| assert_true(propDesc.enumerable, |
| this.name + '.prototype[Symbol.unscopables].' + prop + ' must be enumerable'); |
| assert_true(propDesc.configurable, |
| this.name + '.prototype[Symbol.unscopables].' + prop + ' must be configurable'); |
| assert_equals(propDesc.value, true, |
| this.name + '.prototype[Symbol.unscopables].' + prop + ' must have the value `true`'); |
| }; |
| |
| 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 should not have a getter"); |
| assert_false("set" in desc, "property should not have a setter"); |
| assert_equals(desc.writable, !operationUnforgeable, |
| "property should be writable if and only if not unforgeable"); |
| assert_true(desc.enumerable, "property should be enumerable"); |
| assert_equals(desc.configurable, !operationUnforgeable, |
| "property should be configurable if and only if not unforgeable"); |
| // "The value of the property is a Function object whose |
| // behavior is as follows . . ." |
| assert_equals(typeof memberHolderObject[member.name], "function", |
| "property must be a function"); |
| |
| const ctors = this.members.filter(function(m) { |
| return m.type == "operation" && m.name == member.name; |
| }); |
| assert_equals( |
| memberHolderObject[member.name].length, |
| minOverloadLength(ctors), |
| "property has wrong .length"); |
| |
| // Make some suitable arguments |
| var args = member.arguments.map(function(arg) { |
| return create_suitable_object(arg.idlType); |
| }); |
| |
| // "Let O be a value determined as follows: |
| // ". . . |
| // "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.special !== "static") { |
| var cb; |
| if (!this.is_global() && |
| memberHolderObject[member.name] != self[member.name]) |
| { |
| 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.) |
| throwOrReject(a_test, member, memberHolderObject[member.name], {}, args, |
| "calling operation with this = {} didn't throw TypeError", cb); |
| } else { |
| done(); |
| } |
| } |
| |
| IdlInterface.prototype.test_to_json_operation = function(desc, memberHolderObject, member) { |
| var instanceName = memberHolderObject && memberHolderObject.constructor.name |
| || member.name + " object"; |
| if (member.has_extended_attribute("Default")) { |
| subsetTestByKey(this.name, test, function() { |
| var map = this.default_to_json_operation(); |
| var json = memberHolderObject.toJSON(); |
| map.forEach(function(type, k) { |
| assert_true(k in json, "property " + JSON.stringify(k) + " should be present in the output of " + this.name + ".prototype.toJSON()"); |
| var descriptor = Object.getOwnPropertyDescriptor(json, k); |
| assert_true(descriptor.writable, "property " + k + " should be writable"); |
| assert_true(descriptor.configurable, "property " + k + " should be configurable"); |
| assert_true(descriptor.enumerable, "property " + k + " should be enumerable"); |
| this.array.assert_type_is(json[k], type); |
| delete json[k]; |
| }, this); |
| }.bind(this), this.name + " interface: default toJSON operation on " + desc); |
| } else { |
| subsetTestByKey(this.name, test, function() { |
| assert_true(this.array.is_json_type(member.idlType), JSON.stringify(member.idlType) + " is not an appropriate return value for the toJSON operation of " + instanceName); |
| this.array.assert_type_is(memberHolderObject.toJSON(), member.idlType); |
| }.bind(this), this.name + " interface: toJSON operation on " + desc); |
| } |
| }; |
| |
| IdlInterface.prototype.test_member_iterable = function(member) |
| { |
| subsetTestByKey(this.name, test, function() |
| { |
| var isPairIterator = member.idlType.length === 2; |
| var proto = this.get_interface_object().prototype; |
| var descriptor = Object.getOwnPropertyDescriptor(proto, Symbol.iterator); |
| |
| assert_true(descriptor.writable, "@@iterator property should be writable"); |
| assert_true(descriptor.configurable, "@@iterator property should be configurable"); |
| assert_false(descriptor.enumerable, "@@iterator property should not be enumerable"); |
| assert_equals(typeof descriptor.value, "function", "@@iterator property should be a function"); |
| assert_equals(descriptor.value.length, 0, "@@iterator function object length should be 0"); |
| assert_equals(descriptor.value.name, isPairIterator ? "entries" : "values", "@@iterator function object should have the right name"); |
| |
| if (isPairIterator) { |
| assert_equals(proto["entries"], proto[Symbol.iterator], "entries method should be the same as @@iterator method"); |
| } else { |
| assert_equals(proto[Symbol.iterator], Array.prototype[Symbol.iterator], "@@iterator method should be the same as Array prototype's"); |
| ["entries", "keys", "values", "forEach", Symbol.iterator].forEach(function(property) { |
| var propertyName = property === Symbol.iterator ? "@@iterator" : property; |
| assert_equals(proto[property], Array.prototype[property], propertyName + " method should be the same as Array prototype's"); |
| }.bind(this)); |
| } |
| }.bind(this), this.name + " interface: iterable<" + member.idlType.map(function(t) { return t.idlType; }).join(", ") + ">"); |
| }; |
| |
| IdlInterface.prototype.test_member_stringifier = function(member) |
| { |
| subsetTestByKey(this.name, test, function() |
| { |
| if (this.is_callback() && !this.has_constants()) { |
| return; |
| } |
| |
| this.assert_interface_object_exists(); |
| |
| if (this.is_callback()) { |
| assert_false("prototype" in this.get_interface_object(), |
| this.name + ' should not have a "prototype" property'); |
| return; |
| } |
| |
| assert_own_property(this.get_interface_object(), "prototype", |
| 'interface "' + this.name + '" does not have own property "prototype"'); |
| |
| // ". . . the property exists on the interface prototype object." |
| var interfacePrototypeObject = this.get_interface_object().prototype; |
| assert_own_property(interfacePrototypeObject, "toString", |
| "interface prototype object missing non-static operation"); |
| |
| var stringifierUnforgeable = member.isUnforgeable; |
| var desc = Object.getOwnPropertyDescriptor(interfacePrototypeObject, "toString"); |
| // "The property has attributes { [[Writable]]: B, |
| // [[Enumerable]]: true, [[Configurable]]: B }, where B is false if the |
| // stringifier is unforgeable on the interface, and true otherwise." |
| assert_false("get" in desc, "property should not have a getter"); |
| assert_false("set" in desc, "property should not have a setter"); |
| assert_equals(desc.writable, !stringifierUnforgeable, |
| "property should be writable if and only if not unforgeable"); |
| assert_true(desc.enumerable, "property should be enumerable"); |
| assert_equals(desc.configurable, !stringifierUnforgeable, |
| "property should be configurable if and only if not unforgeable"); |
| // "The value of the property is a Function object, which behaves as |
| // follows . . ." |
| assert_equals(typeof interfacePrototypeObject.toString, "function", |
| "property must be a function"); |
| // "The value of the Function object’s “length” property is the Number |
| // value 0." |
| assert_equals(interfacePrototypeObject.toString.length, 0, |
| "property has wrong .length"); |
| |
| // "Let O be the result of calling ToObject on the this value." |
| assert_throws_js(globalOf(interfacePrototypeObject.toString).TypeError, function() { |
| interfacePrototypeObject.toString.apply(null, []); |
| }, "calling stringifier with this = null didn't throw TypeError"); |
| |
| // "If O is not an object that implements the interface on which the |
| // stringifier was declared, then throw a TypeError." |
| // |
| // TODO: Test a platform object that implements some other |
| // interface. (Have to be sure to get inheritance right.) |
| assert_throws_js(globalOf(interfacePrototypeObject.toString).TypeError, function() { |
| interfacePrototypeObject.toString.apply({}, []); |
| }, "calling stringifier with this = {} didn't throw TypeError"); |
| }.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]; |
| if (member.untested) { |
| continue; |
| } |
| |
| if (!exposed_in(exposure_set(member, this.exposureSet))) { |
| subsetTestByKey(this.name, test, function() { |
| // It's not exposed, so we shouldn't find it anywhere. |
| assert_false(member.name in this.get_interface_object(), |
| "The interface object must not have a property " + |
| format_value(member.name)); |
| assert_false(member.name in this.get_interface_object().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) |
| { |
| this.test_member_attribute(member); |
| } |
| if (member.special === "stringifier") { |
| this.test_member_stringifier(member); |
| } |
| break; |
| |
| case "operation": |
| // TODO: Need to correctly handle multiple operations with the same |
| // identifier. |
| // For unforgeable operations, we do the checks in |
| // test_interface_of instead. |
| if (member.name) { |
| if (!member.isUnforgeable) |
| { |
| this.test_member_operation(member); |
| } |
| } else if (member.special === "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) |
| { |
| var obj, exception = null; |
| try |
| { |
| obj = eval(desc); |
| } |
| catch(e) |
| { |
| exception = e; |
| } |
| |
| var expected_typeof; |
| if (this.name == "HTMLAllCollection") |
| { |
| // Result of [[IsHTMLDDA]] slot |
| expected_typeof = "undefined"; |
| } else if (this.members.some(function(member) { return member.legacycaller; })) |
| { |
| expected_typeof = "function"; |
| } |
| else |
| { |
| expected_typeof = "object"; |
| } |
| |
| this.test_primary_interface_of(desc, obj, exception, expected_typeof); |
| |
| var current_interface = this; |
| while (current_interface) |
| { |
| if (!(current_interface.name in this.array.members)) |
| { |
| throw new IdlHarnessError("Interface " + current_interface.name + " not found (inherited by " + this.name + ")"); |
| } |
| if (current_interface.prevent_multiple_testing && current_interface.already_tested) |
| { |
| return; |
| } |
| current_interface.test_interface_of(desc, obj, exception, expected_typeof); |
| current_interface = this.array.members[current_interface.base]; |
| } |
| }; |
| |
| IdlInterface.prototype.test_primary_interface_of = function(desc, obj, exception, expected_typeof) |
| { |
| // Only the object itself, not its members, are tested here, so if the |
| // interface is untested, there is nothing to do. |
| if (this.untested) |
| { |
| return; |
| } |
| |
| // "The internal [[SetPrototypeOf]] method of every platform object that |
| // implements an interface with the [Global] extended |
| // attribute must execute the same algorithm as is defined for the |
| // [[SetPrototypeOf]] internal method of an immutable prototype exotic |
| // object." |
| // https://heycam.github.io/webidl/#platform-object-setprototypeof |
| if (this.is_global()) |
| { |
| this.test_immutable_prototype("global platform object", obj); |
| } |
| |
| |
| // We can't easily test that its prototype is correct if there's no |
| // interface object, or the object is from a different global environment |
| // (not instanceof Object). TODO: test in this case that its prototype at |
| // least looks correct, even if we can't test that it's actually correct. |
| if (!this.has_extended_attribute("NoInterfaceObject") |
| && (typeof obj != expected_typeof || obj instanceof Object)) |
| { |
| subsetTestByKey(this.name, test, function() |
| { |
| assert_equals(exception, null, "Unexpected exception when evaluating object"); |
| assert_equals(typeof obj, expected_typeof, "wrong typeof object"); |
| this.assert_interface_object_exists(); |
| assert_own_property(this.get_interface_object(), "prototype", |
| 'interface "' + this.name + '" does not have own property "prototype"'); |
| |
| // "The value of the internal [[Prototype]] property of the |
| // platform object is the interface prototype object of the primary |
| // interface from the platform object’s associated global |
| // environment." |
| assert_equals(Object.getPrototypeOf(obj), |
| this.get_interface_object().prototype, |
| desc + "'s prototype is not " + this.name + ".prototype"); |
| }.bind(this), this.name + " must be primary interface of " + desc); |
| } |
| |
| // "The class string of a platform object that implements one or more |
| // interfaces must be the qualified name of the primary interface of the |
| // platform object." |
| subsetTestByKey(this.name, test, function() |
| { |
| assert_equals(exception, null, "Unexpected exception when evaluating object"); |
| assert_equals(typeof obj, expected_typeof, "wrong typeof object"); |
| assert_class_string(obj, this.get_qualified_name(), "class string of " + desc); |
| if (!this.has_stringifier()) |
| { |
| assert_equals(String(obj), "[object " + this.get_qualified_name() + "]", "String(" + desc + ")"); |
| } |
| }.bind(this), "Stringification of " + desc); |
| }; |
| |
| 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; |
| if (!shouldRunSubTest(this.name)) { |
| return; |
| } |
| |
| 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))) { |
| subsetTestByKey(this.name, test, function() { |
| assert_equals(exception, null, "Unexpected exception when evaluating object"); |
| 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 = subsetTestByKey(this.name, 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)); |
| } |
| else if (member.type == "operation" && |
| member.name && |
| member.isUnforgeable) |
| { |
| var a_test = subsetTestByKey(this.name, 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, a_test); |
| }.bind(this)); |
| } |
| else if ((member.type == "const" |
| || member.type == "attribute" |
| || member.type == "operation") |
| && member.name) |
| { |
| subsetTestByKey(this.name, test, function() |
| { |
| assert_equals(exception, null, "Unexpected exception when evaluating object"); |
| assert_equals(typeof obj, expected_typeof, "wrong typeof object"); |
| if (member.special !== "static") { |
| if (!this.is_global()) { |
| assert_inherits(obj, member.name); |
| } else { |
| assert_own_property(obj, member.name); |
| } |
| |
| if (member.type == "const") |
| { |
| assert_equals(obj[member.name], constValue(member.value)); |
| } |
| if (member.type == "attribute") |
| { |
| // Attributes are accessor properties, so they might |
| // legitimately throw an exception rather than returning |
| // anything. |
| var property, thrown = false; |
| try |
| { |
| property = obj[member.name]; |
| } |
| catch (e) |
| { |
| thrown = true; |
| } |
| if (!thrown) |
| { |
| if (this.name == "Document" && member.name == "all") |
| { |
| // Result of [[IsHTMLDDA]] slot |
| assert_equals(typeof property, "undefined"); |
| } |
| else |
| { |
| this.array.assert_type_is(property, member.idlType); |
| } |
| } |
| } |
| if (member.type == "operation") |
| { |
| assert_equals(typeof obj[member.name], "function"); |
| } |
| } |
| }.bind(this), this.name + " interface: " + desc + ' must inherit property "' + member + '" with the proper type'); |
| } |
| // 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) |
| { |
| var description = |
| this.name + " interface: calling " + member + " on " + desc + |
| " with too few arguments must throw TypeError"; |
| var a_test = subsetTestByKey(this.name, async_test, description); |
| a_test.step(function() |
| { |
| assert_equals(exception, null, "Unexpected exception when evaluating object"); |
| assert_equals(typeof obj, expected_typeof, "wrong typeof object"); |
| var fn; |
| if (member.special !== "static") { |
| if (!this.is_global() && !member.isUnforgeable) { |
| assert_inherits(obj, member.name); |
| } else { |
| assert_own_property(obj, member.name); |
| } |
| fn = obj[member.name]; |
| } |
| else |
| { |
| assert_own_property(obj.constructor, member.name, "interface object must have static operation as own property"); |
| fn = obj.constructor[member.name]; |
| } |
| |
| 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++) { |
| throwOrReject(a_test, member, fn, obj, args, "Called with " + i + " arguments", cb); |
| |
| args.push(create_suitable_object(member.arguments[i].idlType)); |
| } |
| if (minLength === 0) { |
| cb(); |
| } |
| }.bind(this)); |
| } |
| |
| if (member.is_to_json_regular_operation()) { |
| this.test_to_json_operation(desc, obj, member); |
| } |
| } |
| }; |
| |
| IdlInterface.prototype.has_stringifier = function() |
| { |
| if (this.name === "DOMException") { |
| // toString is inherited from Error, so don't assume we have the |
| // default stringifer |
| return true; |
| } |
| if (this.members.some(function(member) { return member.special === "stringifier"; })) { |
| 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, 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: |
| // "configurable is false if the attribute was declared with the |
| // [LegacyUnforgeable] extended attribute and true otherwise; |
| // "G is the attribute getter, defined below; and |
| // "S is the attribute setter, also defined below." |
| var desc = Object.getOwnPropertyDescriptor(obj, member.name); |
| assert_false("value" in desc, 'property descriptor should not have a "value" field'); |
| assert_false("writable" in desc, 'property descriptor should not have a "writable" field'); |
| assert_true(desc.enumerable, "property should be enumerable"); |
| if (member.isUnforgeable) |
| { |
| assert_false(desc.configurable, "[LegacyUnforgeable] property must not be configurable"); |
| } |
| else |
| { |
| assert_true(desc.configurable, "property must be configurable"); |
| } |
| |
| |
| // "The attribute getter is a Function object whose behavior when invoked |
| // is as follows:" |
| assert_equals(typeof desc.get, "function", "getter must be Function"); |
| |
| // "If the attribute is a regular attribute, then:" |
| if (member.special !== "static") { |
| // "If O is not a platform object that implements I, then: |
| // "If the attribute was specified with the [LegacyLenientThis] extended |
| // attribute, then return undefined. |
| // "Otherwise, throw a TypeError." |
| if (!member.has_extended_attribute("LenientThis") && |
| !member.has_extended_attribute("LegacyLenientThis")) { |
| if (member.idlType.generic !== "Promise") { |
| assert_throws_js(globalOf(desc.get).TypeError, function() { |
| desc.get.call({}); |
| }.bind(this), "calling getter on wrong object type must throw TypeError"); |
| } else { |
| pendingPromises.push( |
| promise_rejects_js(a_test, 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"); |
| |
| // "Let name be the string "get " prepended to attribute’s identifier." |
| // "Perform ! SetFunctionName(F, name)." |
| assert_equals(desc.get.name, "get " + member.name, |
| "getter must have the name 'get " + member.name + "'"); |
| |
| |
| // TODO: Test calling setter on the interface prototype (should throw |
| // TypeError in most cases). |
| if (member.readonly |
| && !member.has_extended_attribute("LenientSetter") |
| && !member.has_extended_attribute("LegacyLenientSetter") |
| && !member.has_extended_attribute("PutForwards") |
| && !member.has_extended_attribute("Replaceable")) |
| { |
| // "The attribute setter is undefined if the attribute is declared |
| // readonly and has neither a [PutForwards] nor a [Replaceable] |
| // extended attribute declared on it." |
| assert_equals(desc.set, undefined, "setter must be undefined for readonly attributes"); |
| } |
| else |
| { |
| // "Otherwise, it is a Function object whose behavior when |
| // invoked is as follows:" |
| assert_equals(typeof desc.set, "function", "setter must be function for PutForwards, Replaceable, or non-readonly attributes"); |
| |
| // "If the attribute is a regular attribute, then:" |
| if (member.special !== "static") { |
| // "If /validThis/ is false and the attribute was not specified |
| // with the [LegacyLenientThis] extended attribute, then throw a |
| // TypeError." |
| // "If the attribute is declared with a [Replaceable] extended |
| // attribute, then: ..." |
| // "If validThis is false, then return." |
| if (!member.has_extended_attribute("LenientThis") && |
| !member.has_extended_attribute("LegacyLenientThis")) { |
| assert_throws_js(globalOf(desc.set).TypeError, function() { |
| desc.set.call({}); |
| }.bind(this), "calling setter on wrong object type must throw TypeError"); |
| } 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"); |
| |
| // "Let name be the string "set " prepended to id." |
| // "Perform ! SetFunctionName(F, name)." |
| assert_equals(desc.set.name, "set " + member.name, |
| "The attribute setter must have the name 'set " + member.name + "'"); |
| } |
| |
| 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, |
| * except for special extAttrs handling. |
| */ |
| for (var k in obj.toJSON()) |
| { |
| this[k] = obj[k]; |
| } |
| if (!("extAttrs" in this)) |
| { |
| this.extAttrs = []; |
| } |
| |
| this.isUnforgeable = this.has_extended_attribute("Unforgeable") || |
| this.has_extended_attribute("LegacyUnforgeable"); |
| this.isUnscopable = this.has_extended_attribute("Unscopable"); |
| } |
| |
| IdlInterfaceMember.prototype = Object.create(IdlObject.prototype); |
| |
| IdlInterfaceMember.prototype.toJSON = function() { |
| return this; |
| }; |
| |
| IdlInterfaceMember.prototype.is_to_json_regular_operation = function() { |
| return this.type == "operation" && this.special !== "static" && this.name == "toJSON"; |
| }; |
| |
| IdlInterfaceMember.prototype.toString = function() { |
| function formatType(type) { |
| var result; |
| if (type.generic) { |
| result = type.generic + "<" + type.idlType.map(formatType).join(", ") + ">"; |
| } else if (type.union) { |
| result = "(" + type.subtype.map(formatType).join(" or ") + ")"; |
| } else { |
| result = type.idlType; |
| } |
| if (type.nullable) { |
| result += "?" |
| } |
| return result; |
| } |
| |
| if (this.type === "operation") { |
| var args = this.arguments.map(function(m) { |
| return [ |
| m.optional ? "optional " : "", |
| formatType(m.idlType), |
| m.variadic ? "..." : "", |
| ].join(""); |
| }).join(", "); |
| return this.name + "(" + args + ")"; |
| } |
| |
| return this.name; |
| } |
| |
| /// Internal helper functions /// |
| function create_suitable_object(type) |
| { |
| /** |
| * type is an object produced by the WebIDLParser.js "type" production. We |
| * return a JavaScript value that matches the type, if we can figure out |
| * how. |
| */ |
| if (type.nullable) |
| { |
| return null; |
| } |
| switch (type.idlType) |
| { |
| case "any": |
| case "boolean": |
| return true; |
| |
| case "byte": case "octet": case "short": case "unsigned short": |
| case "long": case "unsigned long": case "long long": |
| case "unsigned long long": case "float": case "double": |
| case "unrestricted float": case "unrestricted double": |
| return 7; |
| |
| case "DOMString": |
| case "ByteString": |
| case "USVString": |
| return "foo"; |
| |
| case "object": |
| return {a: "b"}; |
| |
| case "Node": |
| return document.createTextNode("abc"); |
| } |
| return null; |
| } |
| |
| /// IdlEnum /// |
| // Used for IdlArray.prototype.assert_type_is |
| function IdlEnum(obj) |
| { |
| /** |
| * obj is an object produced by the WebIDLParser.js "dictionary" |
| * production. |
| */ |
| |
| /** Self-explanatory. */ |
| this.name = obj.name; |
| |
| /** An array of values produced by the "enum" production. */ |
| this.values = obj.values; |
| |
| } |
| |
| IdlEnum.prototype = Object.create(IdlObject.prototype); |
| |
| /// IdlCallback /// |
| // Used for IdlArray.prototype.assert_type_is |
| function IdlCallback(obj) |
| { |
| /** |
| * obj is an object produced by the WebIDLParser.js "callback" |
| * production. |
| */ |
| |
| /** Self-explanatory. */ |
| this.name = obj.name; |
| |
| /** Arguments for the callback. */ |
| this.arguments = obj.arguments; |
| } |
| |
| IdlCallback.prototype = Object.create(IdlObject.prototype); |
| |
| /// IdlTypedef /// |
| // Used for IdlArray.prototype.assert_type_is |
| function IdlTypedef(obj) |
| { |
| /** |
| * obj is an object produced by the WebIDLParser.js "typedef" |
| * production. |
| */ |
| |
| /** Self-explanatory. */ |
| this.name = obj.name; |
| |
| /** The idlType that we are supposed to be typedeffing to. */ |
| this.idlType = obj.idlType; |
| |
| } |
| |
| IdlTypedef.prototype = Object.create(IdlObject.prototype); |
| |
| /// IdlNamespace /// |
| function IdlNamespace(obj) |
| { |
| this.name = obj.name; |
| this.extAttrs = obj.extAttrs; |
| this.untested = obj.untested; |
| /** A back-reference to our IdlArray. */ |
| this.array = obj.array; |
| |
| /** An array of IdlInterfaceMembers. */ |
| this.members = obj.members.map(m => new IdlInterfaceMember(m)); |
| } |
| |
| IdlNamespace.prototype = Object.create(IdlObject.prototype); |
| |
| IdlNamespace.prototype.do_member_operation_asserts = function (memberHolderObject, member, a_test) |
| { |
| var desc = Object.getOwnPropertyDescriptor(memberHolderObject, member.name); |
| |
| assert_false("get" in desc, "property should not have a getter"); |
| assert_false("set" in desc, "property should not have a setter"); |
| assert_equals( |
| desc.writable, |
| !member.isUnforgeable, |
| "property should be writable if and only if not unforgeable"); |
| assert_true(desc.enumerable, "property should be enumerable"); |
| assert_equals( |
| desc.configurable, |
| !member.isUnforgeable, |
| "property should be configurable if and only if not unforgeable"); |
| |
| assert_equals( |
| typeof memberHolderObject[member.name], |
| "function", |
| "property must be a function"); |
| |
| assert_equals( |
| memberHolderObject[member.name].length, |
| minOverloadLength(this.members.filter(function(m) { |
| return m.type == "operation" && m.name == member.name; |
| })), |
| "operation has wrong .length"); |
| a_test.done(); |
| } |
| |
| IdlNamespace.prototype.test_member_operation = function(member) |
| { |
| if (!shouldRunSubTest(this.name)) { |
| return; |
| } |
| var a_test = subsetTestByKey( |
| this.name, |
| async_test, |
| this.name + ' namespace: operation ' + member); |
| a_test.step(function() { |
| assert_own_property( |
| self[this.name], |
| member.name, |
| 'namespace object missing operation ' + format_value(member.name)); |
| |
| this.do_member_operation_asserts(self[this.name], member, a_test); |
| }.bind(this)); |
| }; |
| |
| IdlNamespace.prototype.test_member_attribute = function (member) |
| { |
| if (!shouldRunSubTest(this.name)) { |
| return; |
| } |
| var a_test = subsetTestByKey( |
| this.name, |
| async_test, |
| this.name + ' namespace: attribute ' + member.name); |
| a_test.step(function() |
| { |
| assert_own_property( |
| self[this.name], |
| member.name, |
| this.name + ' does not have property ' + format_value(member.name)); |
| |
| var desc = Object.getOwnPropertyDescriptor(self[this.name], member.name); |
| assert_equals(desc.set, undefined, "setter must be undefined for namespace members"); |
| a_test.done(); |
| }.bind(this)); |
| }; |
| |
| IdlNamespace.prototype.test = function () |
| { |
| /** |
| * TODO(lukebjerring): Assert: |
| * - "Note that unlike interfaces or dictionaries, namespaces do not create types." |
| * - "Of the extended attributes defined in this specification, only the |
| * [Exposed] and [SecureContext] extended attributes are applicable to namespaces." |
| * - "Namespaces must be annotated with the [Exposed] extended attribute." |
| */ |
| |
| for (const v of Object.values(this.members)) { |
| switch (v.type) { |
| |
| case 'operation': |
| this.test_member_operation(v); |
| break; |
| |
| case 'attribute': |
| this.test_member_attribute(v); |
| break; |
| |
| default: |
| throw 'Invalid namespace member ' + v.name + ': ' + v.type + ' not supported'; |
| } |
| }; |
| }; |
| |
| }()); |
| |
| /** |
| * idl_test is a promise_test wrapper that handles the fetching of the IDL, |
| * avoiding repetitive boilerplate. |
| * |
| * @param {String|String[]} srcs Spec name(s) for source idl files (fetched from |
| * /interfaces/{name}.idl). |
| * @param {String|String[]} deps Spec name(s) for dependency idl files (fetched |
| * from /interfaces/{name}.idl). Order is important - dependencies from |
| * each source will only be included if they're already know to be a |
| * dependency (i.e. have already been seen). |
| * @param {Function} setup_func Function for extra setup of the idl_array, such |
| * as adding objects. Do not call idl_array.test() in the setup; it is |
| * called by this function (idl_test). |
| */ |
| function idl_test(srcs, deps, idl_setup_func) { |
| return promise_test(function (t) { |
| var idl_array = new IdlArray(); |
| srcs = (srcs instanceof Array) ? srcs : [srcs] || []; |
| deps = (deps instanceof Array) ? deps : [deps] || []; |
| var setup_error = null; |
| const validationIgnored = [ |
| "constructor-member", |
| "dict-arg-default", |
| "require-exposed" |
| ]; |
| return Promise.all( |
| srcs.concat(deps).map(fetch_spec)) |
| .then(function(results) { |
| const astArray = results.map(result => |
| WebIDL2.parse(result.idl, { sourceName: result.spec }) |
| ); |
| test(() => { |
| const validations = WebIDL2.validate(astArray) |
| .filter(v => !validationIgnored.includes(v.ruleName)); |
| if (validations.length) { |
| const message = validations.map(v => v.message).join("\n\n"); |
| throw new Error(message); |
| } |
| }, "idl_test validation"); |
| for (var i = 0; i < srcs.length; i++) { |
| idl_array.internal_add_idls(astArray[i]); |
| } |
| for (var i = srcs.length; i < srcs.length + deps.length; i++) { |
| idl_array.internal_add_dependency_idls(astArray[i]); |
| } |
| }) |
| .then(function() { |
| if (idl_setup_func) { |
| return idl_setup_func(idl_array, t); |
| } |
| }) |
| .catch(function(e) { setup_error = e || 'IDL setup failed.'; }) |
| .then(function () { |
| var error = setup_error; |
| try { |
| idl_array.test(); // Test what we can. |
| } catch (e) { |
| // If testing fails hard here, the original setup error |
| // is more likely to be the real cause. |
| error = error || e; |
| } |
| if (error) { |
| throw error; |
| } |
| }); |
| }, 'idl_test setup'); |
| } |
| |
| /** |
| * fetch_spec is a shorthand for a Promise that fetches the spec's content. |
| */ |
| function fetch_spec(spec) { |
| var url = '/interfaces/' + spec + '.idl'; |
| return fetch(url).then(function (r) { |
| if (!r.ok) { |
| throw new IdlHarnessError("Error fetching " + url + "."); |
| } |
| return r.text(); |
| }).then(idl => ({ spec, idl })); |
| } |
| // vim: set expandtab shiftwidth=4 tabstop=4 foldmarker=@{,@} foldmethod=marker: |