| /* |
| 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 |
| */ |
| |
| /* |
| * This file automatically generates browser tests for WebIDL interfaces, using |
| * the testharness.js framework. To use, first include the following: |
| * |
| * <script src=/resources/testharness.js></script> |
| * <script src=/resources/testharnessreport.js></script> |
| * <script src=/resources/WebIDLParser.js></script> |
| * <script src=/resources/idlharness.js></script> |
| * |
| * Then you'll need some type of IDLs. Here's some script that can be run on a |
| * spec written in HTML, which will grab all the elements with class="idl", |
| * concatenate them, and replace the body so you can copy-paste: |
| * |
| var s = ""; |
| [].forEach.call(document.getElementsByClassName("idl"), function(idl) { |
| //https://www.w3.org/Bugs/Public/show_bug.cgi?id=14914 |
| if (!idl.classList.contains("extract")) |
| { |
| s += idl.textContent + "\n\n"; |
| } |
| }); |
| document.body.innerHTML = '<pre></pre>'; |
| document.body.firstChild.textContent = s; |
| * |
| * (TODO: write this in Python or something so that it can be done from the |
| * command line instead.) |
| * |
| * Once you have that, put it in your script somehow. The easiest way is to |
| * embed it literally in an HTML file with <script type=text/plain> or similar, |
| * so that you don't have to do any escaping. Another possibility is to put it |
| * in a separate .idl file that's fetched via XHR or similar. Sample usage: |
| * |
| * var idl_array = new IdlArray(); |
| * idl_array.add_untested_idls("interface Node { readonly attribute DOMString nodeName; };"); |
| * idl_array.add_idls("interface Document : Node { readonly attribute DOMString URL; };"); |
| * idl_array.add_objects({Document: ["document"]}); |
| * idl_array.test(); |
| * |
| * This tests that window.Document exists and meets all the requirements of |
| * WebIDL. It also tests that window.document (the result of evaluating the |
| * string "document") has URL and nodeName properties that behave as they |
| * should, and otherwise meets WebIDL's requirements for an object whose |
| * primary interface is Document. It does not test that window.Node exists, |
| * which is what you want if the Node interface is already tested in some other |
| * specification's suite and your specification only extends or refers to it. |
| * Of course, each IDL string can define many different things, and calls to |
| * add_objects() can register many different objects for different interfaces: |
| * this is a very simple example. |
| * |
| * TODO: Write assert_writable, assert_enumerable, assert_configurable and |
| * their inverses, and use those instead of just checking |
| * getOwnPropertyDescriptor. |
| * |
| * == Public methods of IdlArray == |
| * |
| * IdlArray objects can be obtained with new IdlArray(). Anything not |
| * documented in this section should be considered an implementation detail, |
| * and outside callers should not use it. |
| * |
| * add_idls(idl_string): |
| * Parses idl_string (throwing on parse error) and adds the results to the |
| * IdlArray. All the definitions will be tested when you run test(). If |
| * some of the definitions refer to other definitions, those must be present |
| * too. For instance, if idl_string says that Document inherits from Node, |
| * the Node interface must also have been provided in some call to add_idls() |
| * or add_untested_idls(). |
| * |
| * add_untested_idls(idl_string): |
| * Like add_idls(), but the definitions will not be tested. If an untested |
| * interface is added and then extended with a tested partial interface, the |
| * members of the partial interface will still be tested. Also, all the |
| * members will still be tested for objects added with add_objects(), because |
| * you probably want to test that (for instance) window.document has all the |
| * properties from Node, not just Document, even if the Node interface itself |
| * is tested in a different test suite. |
| * |
| * add_objects(dict): |
| * dict should be an object whose keys are the names of interfaces or |
| * exceptions, and whose values are arrays of strings. When an interface or |
| * exception is tested, every string registered for it with add_objects() |
| * will be evaluated, and tests will be run on the result to verify that it |
| * correctly implements that interface or exception. This is the only way to |
| * test anything about [NoInterfaceObject] interfaces, and there are many |
| * tests that can't be run on any interface without an object to fiddle with. |
| * |
| * The interface has to be the *primary* interface of all the objects |
| * provided. For example, don't pass {Node: ["document"]}, but rather |
| * {Document: ["document"]}. Assuming the Document interface was declared to |
| * inherit from Node, this will automatically test that document implements |
| * the Node interface too. |
| * |
| * Warning: methods will be called on any provided objects, in a manner that |
| * WebIDL requires be safe. For instance, if a method has mandatory |
| * arguments, the test suite will try calling it with too few arguments to |
| * see if it throws an exception. If an implementation incorrectly runs the |
| * function instead of throwing, this might have side effects, possibly even |
| * preventing the test suite from running correctly. |
| * |
| * prevent_multiple_testing(name): |
| * This is a niche method for use in case you're testing many objects that |
| * implement the same interfaces, and don't want to retest the same |
| * interfaces every single time. For instance, HTML defines many interfaces |
| * that all inherit from HTMLElement, so the HTML test suite has something |
| * like |
| * .add_objects({ |
| * HTMLHtmlElement: ['document.documentElement'], |
| * HTMLHeadElement: ['document.head'], |
| * HTMLBodyElement: ['document.body'], |
| * ... |
| * }) |
| * and so on for dozens of element types. This would mean that it would |
| * retest that each and every one of those elements implements HTMLElement, |
| * Element, and Node, which would be thousands of basically redundant tests. |
| * The test suite therefore calls prevent_multiple_testing("HTMLElement"). |
| * This means that once one object has been tested to implement HTMLElement |
| * and its ancestors, no other object will be. Thus in the example code |
| * above, the harness would test that document.documentElement correctly |
| * implements HTMLHtmlElement, HTMLElement, Element, and Node; but |
| * document.head would only be tested for HTMLHeadElement, and so on for |
| * further objects. |
| * |
| * test(): |
| * Run all tests. This should be called after you've called all other |
| * methods to add IDLs and objects. |
| */ |
| |
| /** |
| * 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"; |
| /// 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; |
| return cnt.value; |
| } |
| |
| /// IdlArray /// |
| // Entry point |
| window.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 { A: ["B", "C"], D: ["E"] }. |
| */ |
| this.partials = []; |
| this["implements"] = {}; |
| }; |
| |
| //@} |
| IdlArray.prototype.add_idls = function(raw_idls) |
| //@{ |
| { |
| /** Entry point. See documentation at beginning of file. */ |
| this.internal_add_idls(WebIDL2.parse(raw_idls)); |
| }; |
| |
| //@} |
| IdlArray.prototype.add_untested_idls = function(raw_idls) |
| //@{ |
| { |
| /** Entry point. See documentation at beginning of file. */ |
| var parsed_idls = WebIDL2.parse(raw_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; |
| } |
| } |
| } |
| this.internal_add_idls(parsed_idls); |
| }; |
| |
| //@} |
| IdlArray.prototype.internal_add_idls = function(parsed_idls) |
| //@{ |
| { |
| /** |
| * 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. |
| */ |
| parsed_idls.forEach(function(parsed_idl) |
| { |
| if (parsed_idl.type == "interface" && parsed_idl.partial) |
| { |
| this.partials.push(parsed_idl); |
| return; |
| } |
| |
| if (parsed_idl.type == "implements") |
| { |
| if (!(parsed_idl.target in this["implements"])) |
| { |
| this["implements"][parsed_idl.target] = []; |
| } |
| this["implements"][parsed_idl.target].push(parsed_idl["implements"]); |
| return; |
| } |
| |
| parsed_idl.array = this; |
| if (parsed_idl.name in this.members) |
| { |
| throw "Duplicate identifier " + parsed_idl.name; |
| } |
| switch(parsed_idl.type) |
| { |
| case "interface": |
| this.members[parsed_idl.name] = new IdlInterface(parsed_idl); |
| break; |
| |
| case "exception": |
| this.members[parsed_idl.name] = new IdlException(parsed_idl); |
| 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": |
| // TODO |
| console.log("callback not yet supported"); |
| break; |
| |
| case "enum": |
| this.members[parsed_idl.name] = new IdlEnum(parsed_idl); |
| break; |
| |
| case "callback interface": |
| // TODO |
| console.log("callback interface not yet supported"); |
| 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 "Circular implements statements involving " + ret[i]; |
| } |
| } |
| return ret; |
| }; |
| |
| //@} |
| IdlArray.prototype.test = function() |
| //@{ |
| { |
| /** Entry point. See documentation at beginning of file. */ |
| |
| // First merge in all the partial interfaces and implements statements we |
| // encountered. |
| this.partials.forEach(function(parsed_idl) |
| { |
| if (!(parsed_idl.name in this.members) |
| || !(this.members[parsed_idl.name] instanceof IdlInterface)) |
| { |
| throw "Partial interface " + parsed_idl.name + " with no original interface"; |
| } |
| if (parsed_idl.extAttrs) |
| { |
| parsed_idl.extAttrs.forEach(function(extAttr) |
| { |
| this.members[parsed_idl.name].extAttrs.push(extAttr); |
| }.bind(this)); |
| } |
| parsed_idl.members.forEach(function(member) |
| { |
| this.members[parsed_idl.name].members.push(new IdlInterfaceMember(member)); |
| }.bind(this)); |
| }.bind(this)); |
| this.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."; |
| this.members[rhs].members.forEach(function(member) |
| { |
| this.members[lhs].members.push(new IdlInterfaceMember(member)); |
| }.bind(this)); |
| }.bind(this)); |
| } |
| this["implements"] = {}; |
| |
| // Now run test() on every member, and test_object() for every object. |
| for (var name in this.members) |
| { |
| this.members[name].test(); |
| if (name in this.objects) |
| { |
| this.objects[name].forEach(function(str) |
| { |
| this.members[name].test_object(str); |
| }.bind(this)); |
| } |
| } |
| }; |
| |
| //@} |
| IdlArray.prototype.assert_type_is = function(value, type) |
| //@{ |
| { |
| /** |
| * 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.nullable && value === null) |
| { |
| // This is fine |
| return; |
| } |
| |
| if (type.array) |
| { |
| // TODO: not supported yet |
| return; |
| } |
| |
| if (type.sequence) |
| { |
| assert_true(Array.isArray(value), "is not array"); |
| if (!value.length) |
| { |
| // Nothing we can do. |
| return; |
| } |
| this.assert_type_is(value[0], type.idlType.idlType); |
| return; |
| } |
| |
| type = 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), "not an integer"); |
| assert_true(-128 <= value && value <= 127, "byte " + value + " not in range [-128, 127]"); |
| return; |
| |
| case "octet": |
| assert_equals(typeof value, "number"); |
| assert_equals(value, Math.floor(value), "not an integer"); |
| assert_true(0 <= value && value <= 255, "octet " + value + " not in range [0, 255]"); |
| return; |
| |
| case "short": |
| assert_equals(typeof value, "number"); |
| assert_equals(value, Math.floor(value), "not an integer"); |
| assert_true(-32768 <= value && value <= 32767, "short " + value + " not in range [-32768, 32767]"); |
| return; |
| |
| case "unsigned short": |
| assert_equals(typeof value, "number"); |
| assert_equals(value, Math.floor(value), "not an integer"); |
| assert_true(0 <= value && value <= 65535, "unsigned short " + value + " not in range [0, 65535]"); |
| return; |
| |
| case "long": |
| assert_equals(typeof value, "number"); |
| assert_equals(value, Math.floor(value), "not an integer"); |
| assert_true(-2147483648 <= value && value <= 2147483647, "long " + value + " not in range [-2147483648, 2147483647]"); |
| return; |
| |
| case "unsigned long": |
| assert_equals(typeof value, "number"); |
| assert_equals(value, Math.floor(value), "not an integer"); |
| assert_true(0 <= value && value <= 4294967295, "unsigned long " + value + " not in range [0, 4294967295]"); |
| return; |
| |
| case "long long": |
| assert_equals(typeof value, "number"); |
| return; |
| |
| case "unsigned long long": |
| assert_equals(typeof value, "number"); |
| assert_true(0 <= value, "unsigned long long is negative"); |
| return; |
| |
| case "float": |
| case "double": |
| case "unrestricted float": |
| case "unrestricted double": |
| // TODO: distinguish these cases |
| assert_equals(typeof value, "number"); |
| return; |
| |
| case "DOMString": |
| assert_equals(typeof value, "string"); |
| return; |
| |
| case "object": |
| assert_true(typeof value == "object" || typeof value == "function", "wrong type: not object or function"); |
| return; |
| } |
| |
| if (!(type in this.members)) |
| { |
| throw "Unrecognized type " + type; |
| } |
| |
| 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 window. |
| assert_true(typeof value == "object" || typeof value == "function", "wrong type: not object or function"); |
| if (value instanceof Object |
| && !this.members[type].has_extended_attribute("NoInterfaceObject") |
| && type in window) |
| { |
| assert_true(value instanceof window[type], "not 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 IdlTypedef) |
| { |
| // TODO: Test when we actually have something to test this on |
| } |
| else |
| { |
| throw "Type " + type + " isn't an interface 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; |
| |
| /** 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); |
| |
| /// IdlExceptionOrInterface /// |
| // Code sharing! |
| function IdlExceptionOrInterface(obj) |
| //@{ |
| { |
| /** |
| * obj is an object produced by the WebIDLParser.js "exception" or |
| * "interface" production, as appropriate. |
| */ |
| |
| /** Self-explanatory. */ |
| this.name = obj.name; |
| |
| /** A back-reference to our IdlArray. */ |
| this.array = obj.array; |
| |
| /** |
| * An indicator of whether we should run tests on the (exception) interface |
| * object and (exception) interface prototype object. Tests on members are |
| * controlled by .untested on each member, not this. |
| */ |
| 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); }); |
| |
| /** |
| * The name (as a string) of the type we inherit from, or null if there is |
| * none. |
| */ |
| this.base = obj.inheritance; |
| } |
| |
| //@} |
| IdlExceptionOrInterface.prototype = Object.create(IdlObject.prototype); |
| IdlExceptionOrInterface.prototype.test = function() |
| //@{ |
| { |
| if (this.has_extended_attribute("NoInterfaceObject")) |
| { |
| // No tests to do without an instance. TODO: We should still be able |
| // to run tests on the prototype object, if we obtain one through some |
| // other means. |
| return; |
| } |
| |
| if (!this.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(); |
| }; |
| |
| //@} |
| |
| /// IdlException /// |
| function IdlException(obj) { IdlExceptionOrInterface.call(this, obj); } |
| IdlException.prototype = Object.create(IdlExceptionOrInterface.prototype); |
| IdlException.prototype.test_self = function() |
| //@{ |
| { |
| test(function() |
| { |
| // "For every exception that is not declared with the |
| // [NoInterfaceObject] extended attribute, a corresponding property |
| // must exist on the exception’s relevant namespace object. The name of |
| // the property is the identifier of the exception, and its value is an |
| // object called the exception interface object, which provides access |
| // to any constants that have been associated with the exception. The |
| // property has the attributes { [[Writable]]: true, [[Enumerable]]: |
| // false, [[Configurable]]: true }." |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| var desc = Object.getOwnPropertyDescriptor(window, this.name); |
| assert_false("get" in desc, "window's property " + format_value(this.name) + " has getter"); |
| assert_false("set" in desc, "window's property " + format_value(this.name) + " has setter"); |
| assert_true(desc.writable, "window's property " + format_value(this.name) + " is not writable"); |
| assert_false(desc.enumerable, "window's property " + format_value(this.name) + " is enumerable"); |
| assert_true(desc.configurable, "window's property " + format_value(this.name) + " is not configurable"); |
| |
| // "The exception interface object for a given exception must be a |
| // function object." |
| // "If an object is defined to be a function object, then it has |
| // characteristics as follows:" |
| // "Its [[Prototype]] internal property is the Function prototype |
| // object." |
| // Note: This doesn't match browsers as of December 2011, see |
| // http://www.w3.org/Bugs/Public/show_bug.cgi?id=14813 |
| assert_equals(Object.getPrototypeOf(window[this.name]), Function.prototype, |
| "prototype of window's property " + format_value(this.name) + " is not Function.prototype"); |
| // "Its [[Get]] internal property is set as described in ECMA-262 |
| // section 15.3.5.4." |
| // Not much to test for this. |
| // "Its [[Construct]] internal property is set as described in ECMA-262 |
| // section 13.2.2." |
| // Tested below. |
| // "Its [[HasInstance]] internal property is set as described in |
| // ECMA-262 section 15.3.5.3, unless otherwise specified." |
| // TODO |
| // "Its [[Class]] internal property is “Function”." |
| // String() returns something implementation-dependent, because it |
| // calls Function#toString. |
| assert_class_string(window[this.name], "Function", |
| "class string of " + this.name); |
| |
| // TODO: Test 4.9.1.1. Exception interface object [[Call]] method |
| // (which does not match browsers: |
| // http://www.w3.org/Bugs/Public/show_bug.cgi?id=14885) |
| }.bind(this), this.name + " exception: existence and properties of exception interface object"); |
| |
| test(function() |
| { |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| |
| // "The exception interface object must also have a property named |
| // “prototype” with attributes { [[Writable]]: false, [[Enumerable]]: |
| // false, [[Configurable]]: false } whose value is an object called the |
| // exception interface prototype object. This object also provides |
| // access to the constants that are declared on the exception." |
| assert_own_property(window[this.name], "prototype", |
| 'exception "' + this.name + '" does not have own property "prototype"'); |
| var desc = Object.getOwnPropertyDescriptor(window[this.name], "prototype"); |
| assert_false("get" in desc, this.name + ".prototype has getter"); |
| assert_false("set" in desc, this.name + ".prototype has setter"); |
| assert_false(desc.writable, this.name + ".prototype is writable"); |
| assert_false(desc.enumerable, this.name + ".prototype is enumerable"); |
| assert_false(desc.configurable, this.name + ".prototype is configurable"); |
| |
| // "The exception interface prototype object for a given exception must |
| // have an internal [[Prototype]] property whose value is as follows: |
| // |
| // "If the exception is declared to inherit from another exception, |
| // then the value of the internal [[Prototype]] property is the |
| // exception interface prototype object for the inherited exception. |
| // "Otherwise, the exception is not declared to inherit from another |
| // exception. The value of the internal [[Prototype]] property is the |
| // Error prototype object ([ECMA-262], section 15.11.3.1)." |
| // |
| // Note: This doesn't match browsers as of December 2011, see |
| // https://www.w3.org/Bugs/Public/show_bug.cgi?id=14887. |
| var inherit_exception = this.base ? this.base : "Error"; |
| assert_own_property(window, inherit_exception, |
| 'should inherit from ' + inherit_exception + ', but window has no such property'); |
| assert_own_property(window[inherit_exception], "prototype", |
| 'should inherit from ' + inherit_exception + ', but that object has no "prototype" property'); |
| assert_equals(Object.getPrototypeOf(window[this.name].prototype), |
| window[inherit_exception].prototype, |
| 'prototype of ' + this.name + '.prototype is not ' + inherit_exception + '.prototype'); |
| |
| // "The class string of an exception interface prototype object is the |
| // concatenation of the exception’s identifier and the string |
| // “Prototype”." |
| assert_class_string(window[this.name].prototype, this.name + "Prototype", |
| "class string of " + this.name + ".prototype"); |
| // TODO: Test String(), based on ES definition of |
| // Error.prototype.toString? |
| }.bind(this), this.name + " exception: existence and properties of exception interface prototype object"); |
| |
| test(function() |
| { |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| assert_own_property(window[this.name], "prototype", |
| 'interface "' + this.name + '" does not have own property "prototype"'); |
| |
| // "There must be a property named “name” on the exception interface |
| // prototype object with attributes { [[Writable]]: true, |
| // [[Enumerable]]: false, [[Configurable]]: true } and whose value is |
| // the identifier of the exception." |
| assert_own_property(window[this.name].prototype, "name", |
| 'prototype object does not have own property "name"'); |
| var desc = Object.getOwnPropertyDescriptor(window[this.name].prototype, "name"); |
| assert_false("get" in desc, this.name + ".prototype.name has getter"); |
| assert_false("set" in desc, this.name + ".prototype.name has setter"); |
| assert_true(desc.writable, this.name + ".prototype.name is not writable"); |
| assert_false(desc.enumerable, this.name + ".prototype.name is enumerable"); |
| assert_true(desc.configurable, this.name + ".prototype.name is not configurable"); |
| assert_equals(desc.value, this.name, this.name + ".prototype.name has incorrect value"); |
| }.bind(this), this.name + " exception: existence and properties of exception interface prototype object's \"name\" property"); |
| |
| test(function() |
| { |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| assert_own_property(window[this.name], "prototype", |
| 'interface "' + this.name + '" does not have own property "prototype"'); |
| |
| // "If the [NoInterfaceObject] extended attribute was not specified on |
| // the exception, then there must also be a property named |
| // “constructor” on the exception interface prototype object with |
| // attributes { [[Writable]]: true, [[Enumerable]]: false, |
| // [[Configurable]]: true } and whose value is a reference to the |
| // exception interface object for the exception." |
| assert_own_property(window[this.name].prototype, "constructor", |
| this.name + '.prototype does not have own property "constructor"'); |
| var desc = Object.getOwnPropertyDescriptor(window[this.name].prototype, "constructor"); |
| assert_false("get" in desc, this.name + ".prototype.constructor has getter"); |
| assert_false("set" in desc, this.name + ".prototype.constructor has setter"); |
| assert_true(desc.writable, this.name + ".prototype.constructor is not writable"); |
| assert_false(desc.enumerable, this.name + ".prototype.constructor is enumerable"); |
| assert_true(desc.configurable, this.name + ".prototype.constructor in not configurable"); |
| assert_equals(window[this.name].prototype.constructor, window[this.name], |
| this.name + '.prototype.constructor is not the same object as ' + this.name); |
| }.bind(this), this.name + " exception: existence and properties of exception interface prototype object's \"constructor\" property"); |
| }; |
| |
| //@} |
| IdlException.prototype.test_members = function() |
| //@{ |
| { |
| for (var i = 0; i < this.members.length; i++) |
| { |
| var member = this.members[i]; |
| if (member.untested) |
| { |
| continue; |
| } |
| if (member.type == "const" && member.name != "prototype") |
| { |
| test(function() |
| { |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| |
| // "For each constant defined on the exception, there must be a |
| // corresponding property on the exception interface object, if |
| // it exists, if the identifier of the constant is not |
| // “prototype”." |
| assert_own_property(window[this.name], member.name); |
| // "The value of the property is the ECMAScript value that is |
| // equivalent to the constant’s IDL value, according to the |
| // rules in section 4.2 above." |
| assert_equals(window[this.name][member.name], constValue(member.value), |
| "property has wrong value"); |
| // "The property has attributes { [[Writable]]: false, |
| // [[Enumerable]]: true, [[Configurable]]: false }." |
| var desc = Object.getOwnPropertyDescriptor(window[this.name], member.name); |
| assert_false("get" in desc, "property has getter"); |
| assert_false("set" in desc, "property has setter"); |
| assert_false(desc.writable, "property is writable"); |
| assert_true(desc.enumerable, "property is not enumerable"); |
| assert_false(desc.configurable, "property is configurable"); |
| }.bind(this), this.name + " exception: constant " + member.name + " on exception interface object"); |
| // "In addition, a property with the same characteristics must |
| // exist on the exception interface prototype object." |
| test(function() |
| { |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| assert_own_property(window[this.name], "prototype", |
| 'exception "' + this.name + '" does not have own property "prototype"'); |
| |
| assert_own_property(window[this.name].prototype, member.name); |
| assert_equals(window[this.name].prototype[member.name], constValue(member.value), |
| "property has wrong value"); |
| var desc = Object.getOwnPropertyDescriptor(window[this.name].prototype, member.name); |
| assert_false("get" in desc, "property has getter"); |
| assert_false("set" in desc, "property has setter"); |
| assert_false(desc.writable, "property is writable"); |
| assert_true(desc.enumerable, "property is not enumerable"); |
| assert_false(desc.configurable, "property is configurable"); |
| }.bind(this), this.name + " exception: constant " + member.name + " on exception interface prototype object"); |
| } |
| else if (member.type == "field") |
| { |
| test(function() |
| { |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| assert_own_property(window[this.name], "prototype", |
| 'exception "' + this.name + '" does not have own property "prototype"'); |
| |
| // "For each exception field, there must be a corresponding |
| // property on the exception interface prototype object, whose |
| // characteristics are as follows: |
| // "The name of the property is the identifier of the exception |
| // field." |
| assert_own_property(window[this.name].prototype, member.name); |
| // "The property has attributes { [[Get]]: G, [[Enumerable]]: |
| // true, [[Configurable]]: true }, where G is the exception |
| // field getter, defined below." |
| var desc = Object.getOwnPropertyDescriptor(window[this.name].prototype, member.name); |
| assert_false("value" in desc, "property descriptor has value but is supposed to be accessor"); |
| assert_false("writable" in desc, 'property descriptor has "writable" field but is supposed to be accessor'); |
| // TODO: ES5 doesn't seem to say whether desc should have a |
| // .set property. |
| assert_true(desc.enumerable, "property is not enumerable"); |
| assert_true(desc.configurable, "property is not configurable"); |
| // "The exception field getter is a Function object whose |
| // behavior when invoked is as follows:" |
| assert_equals(typeof desc.get, "function", "typeof getter"); |
| // "The value of the Function object’s “length” property is the |
| // Number value 0." |
| // This test is before the TypeError tests so that it's easiest |
| // to see that Firefox 11a1 only fails one assert in this test. |
| assert_equals(desc.get.length, 0, "getter length"); |
| // "Let O be the result of calling ToObject on the this value. |
| // "If O is not a platform object representing an exception for |
| // the exception on which the exception field was declared, |
| // then throw a TypeError." |
| // TODO: Test on a platform object representing an exception. |
| assert_throws(new TypeError(), function() |
| { |
| window[this.name].prototype[member.name]; |
| }.bind(this), "getting property on prototype object must throw TypeError"); |
| assert_throws(new TypeError(), function() |
| { |
| desc.get.call({}); |
| }.bind(this), "calling getter on wrong object type must throw TypeError"); |
| }.bind(this), this.name + " exception: field " + member.name + " on exception interface prototype object"); |
| } |
| } |
| }; |
| |
| //@} |
| IdlException.prototype.test_object = function(desc) |
| //@{ |
| { |
| var obj, exception = null; |
| try |
| { |
| obj = eval(desc); |
| } |
| catch(e) |
| { |
| exception = e; |
| } |
| |
| test(function() |
| { |
| assert_equals(exception, null, "Unexpected exception when evaluating object"); |
| assert_equals(typeof obj, "object", "wrong typeof object"); |
| |
| // 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 != "object" || obj instanceof Object)) |
| { |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| assert_own_property(window[this.name], "prototype", |
| 'exception "' + this.name + '" does not have own property "prototype"'); |
| |
| // "The value of the internal [[Prototype]] property of the |
| // exception object must be the exception interface prototype |
| // object from the global environment the exception object is |
| // associated with." |
| assert_equals(Object.getPrototypeOf(obj), |
| window[this.name].prototype, |
| desc + "'s prototype is not " + this.name + ".prototype"); |
| } |
| |
| // "The class string of the exception object must be the identifier of |
| // the exception." |
| assert_class_string(obj, this.name, "class string of " + desc); |
| // Stringifier is not defined for DOMExceptions, because message isn't |
| // defined. |
| }.bind(this), this.name + " must be represented by " + desc); |
| |
| for (var i = 0; i < this.members.length; i++) |
| { |
| var member = this.members[i]; |
| test(function() |
| { |
| assert_equals(exception, null, "Unexpected exception when evaluating object"); |
| assert_equals(typeof obj, "object", "wrong typeof object"); |
| assert_inherits(obj, member.name); |
| if (member.type == "const") |
| { |
| assert_equals(obj[member.name], constValue(member.value)); |
| } |
| if (member.type == "field") |
| { |
| this.array.assert_type_is(obj[member.name], member.idlType); |
| } |
| }.bind(this), this.name + " exception: " + desc + ' must inherit property "' + member.name + '" with the proper type'); |
| } |
| }; |
| //@} |
| |
| /// IdlInterface /// |
| function IdlInterface(obj) { IdlExceptionOrInterface.call(this, obj); } |
| IdlInterface.prototype = Object.create(IdlExceptionOrInterface.prototype); |
| IdlInterface.prototype.is_callback = function() |
| //@{ |
| { |
| return this.has_extended_attribute("Callback"); |
| }; |
| //@} |
| |
| IdlInterface.prototype.has_constants = function() |
| //@{ |
| { |
| return this.members.some(function(member) { |
| return member.type === "const"; |
| }); |
| }; |
| //@} |
| |
| IdlInterface.prototype.test_self = function() |
| //@{ |
| { |
| test(function() |
| { |
| // This function tests WebIDL as of 2012-11-28. |
| |
| // "For every interface that: |
| // * 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? |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| var desc = Object.getOwnPropertyDescriptor(window, this.name); |
| assert_false("get" in desc, "window's property " + format_value(this.name) + " has getter"); |
| assert_false("set" in desc, "window's property " + format_value(this.name) + " has setter"); |
| assert_true(desc.writable, "window's property " + format_value(this.name) + " is not writable"); |
| assert_false(desc.enumerable, "window's property " + format_value(this.name) + " is enumerable"); |
| assert_true(desc.configurable, "window's property " + format_value(this.name) + " is not configurable"); |
| |
| if (this.is_callback()) { |
| // "The internal [[Prototype]] property of an interface object for |
| // a callback interface MUST be the Object.prototype object." |
| assert_equals(Object.getPrototypeOf(window[this.name]), Object.prototype, |
| "prototype of window'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 the Function prototype |
| // object." |
| assert_equals(Object.getPrototypeOf(window[this.name]), Function.prototype, |
| "prototype of window's property " + format_value(this.name) + " is not Function.prototype"); |
| |
| // "* Its [[Get]] internal property is set as described in ECMA-262 |
| // section 15.3.5.4." |
| // Not much to test for this. |
| |
| // "* Its [[Construct]] internal property is set as described in |
| // ECMA-262 section 13.2.2." |
| // Tested below if no constructor is defined. TODO: test constructors |
| // if defined. |
| |
| // "* Its [[HasInstance]] internal property is set as described in |
| // ECMA-262 section 15.3.5.3, unless otherwise specified." |
| // TODO |
| |
| // "* Its [[NativeBrand]] internal property is “Function”." |
| // String() returns something implementation-dependent, because it calls |
| // Function#toString. |
| assert_class_string(window[this.name], "Function", "class string of " + this.name); |
| |
| if (!this.has_extended_attribute("Constructor")) { |
| // "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." |
| assert_throws(new TypeError(), function() { |
| window[this.name](); |
| }.bind(this), "interface object didn't throw TypeError when called as a function"); |
| assert_throws(new TypeError(), function() { |
| new window[this.name](); |
| }.bind(this), "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()) { |
| test(function() { |
| // This function tests WebIDL as of 2013-08-25. |
| // http://dev.w3.org/2006/webapi/WebIDL/#es-interface-call |
| |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| |
| // "Interface objects for non-callback interfaces MUST have a |
| // property named “length” with attributes { [[Writable]]: false, |
| // [[Enumerable]]: false, [[Configurable]]: false } whose value is |
| // a Number." |
| assert_own_property(window[this.name], "length"); |
| var desc = Object.getOwnPropertyDescriptor(window[this.name], "length"); |
| assert_false("get" in desc, this.name + ".length has getter"); |
| assert_false("set" in desc, this.name + ".length has setter"); |
| assert_false(desc.writable, this.name + ".length is writable"); |
| assert_false(desc.enumerable, this.name + ".length is enumerable"); |
| assert_false(desc.configurable, this.name + ".length is configurable"); |
| |
| var constructors = this.extAttrs |
| .filter(function(attr) { return attr.name == "Constructor"; }); |
| var expected_length; |
| if (!constructors.length) { |
| // "If the [Constructor] extended attribute, does not appear on |
| // the interface definition, then the value is 0." |
| expected_length = 0; |
| } else { |
| // "Otherwise, the value is determined as follows: . . . |
| // "Return the length of the shortest argument list of the |
| // entries in S." |
| expected_length = constructors.map(function(attr) { |
| return attr.arguments ? attr.arguments.filter(function(arg) { |
| return !arg.optional; |
| }).length : 0; |
| }) |
| .reduce(function(m, n) { return Math.min(m, n); }); |
| } |
| assert_equals(window[this.name].length, expected_length, "wrong value for " + this.name + ".length"); |
| }.bind(this), this.name + " interface object length"); |
| } |
| |
| // TODO: Test named constructors if I find any interfaces that have them. |
| |
| test(function() |
| { |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| |
| if (this.has_extended_attribute("Callback")) { |
| assert_false("prototype" in window[this.name], |
| this.name + ' should not have a "prototype" property'); |
| return; |
| } |
| |
| // "The interface object must also 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 attributes and operations defined on the |
| // interface, and is described in more detail in section 4.5.3 below." |
| assert_own_property(window[this.name], "prototype", |
| 'interface "' + this.name + '" does not have own property "prototype"'); |
| var desc = Object.getOwnPropertyDescriptor(window[this.name], "prototype"); |
| assert_false("get" in desc, this.name + ".prototype has getter"); |
| assert_false("set" in desc, this.name + ".prototype has setter"); |
| assert_false(desc.writable, this.name + ".prototype is writable"); |
| assert_false(desc.enumerable, this.name + ".prototype is enumerable"); |
| assert_false(desc.configurable, this.name + ".prototype is 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 as follows: |
| // "If A is not declared to inherit from another interface, then the |
| // value of the internal [[Prototype]] property of A is the Array |
| // prototype object ([ECMA-262], section 15.4.4) if the interface was |
| // declared with ArrayClass, or the Object prototype object otherwise |
| // ([ECMA-262], section 15.2.4). |
| // "Otherwise, A does inherit from another interface. The value of the |
| // internal [[Prototype]] property of A is the interface prototype |
| // object for the inherited interface." |
| var inherit_interface, inherit_interface_has_interface_object; |
| if (this.base) { |
| inherit_interface = this.base; |
| inherit_interface_has_interface_object = |
| !this.array |
| .members[inherit_interface] |
| .has_extended_attribute("NoInterfaceObject"); |
| } else if (this.has_extended_attribute('ArrayClass')) { |
| inherit_interface = 'Array'; |
| inherit_interface_has_interface_object = true; |
| } else { |
| inherit_interface = 'Object'; |
| inherit_interface_has_interface_object = true; |
| } |
| if (inherit_interface_has_interface_object) { |
| assert_own_property(window, inherit_interface, |
| 'should inherit from ' + inherit_interface + ', but window has no such property'); |
| assert_own_property(window[inherit_interface], 'prototype', |
| 'should inherit from ' + inherit_interface + ', but that object has no "prototype" property'); |
| assert_equals(Object.getPrototypeOf(window[this.name].prototype), |
| window[inherit_interface].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(window[this.name].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 identifier and the string |
| // “Prototype”." |
| assert_class_string(window[this.name].prototype, this.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(window[this.name].prototype), "[object " + this.name + "Prototype]", |
| "String(" + this.name + ".prototype)"); |
| } |
| }.bind(this), this.name + " interface: existence and properties of interface prototype object"); |
| |
| test(function() |
| { |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| |
| if (this.has_extended_attribute("Callback")) { |
| assert_false("prototype" in window[this.name], |
| this.name + ' should not have a "prototype" property'); |
| return; |
| } |
| |
| assert_own_property(window[this.name], "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(window[this.name].prototype, "constructor", |
| this.name + '.prototype does not have own property "constructor"'); |
| var desc = Object.getOwnPropertyDescriptor(window[this.name].prototype, "constructor"); |
| assert_false("get" in desc, this.name + ".prototype.constructor has getter"); |
| assert_false("set" in desc, this.name + ".prototype.constructor has setter"); |
| assert_true(desc.writable, this.name + ".prototype.constructor is not writable"); |
| assert_false(desc.enumerable, this.name + ".prototype.constructor is enumerable"); |
| assert_true(desc.configurable, this.name + ".prototype.constructor in not configurable"); |
| assert_equals(window[this.name].prototype.constructor, window[this.name], |
| this.name + '.prototype.constructor is not the same object as ' + this.name); |
| }.bind(this), this.name + ' interface: existence and properties of interface prototype object\'s "constructor" property'); |
| }; |
| |
| //@} |
| IdlInterface.prototype.test_members = function() |
| //@{ |
| { |
| for (var i = 0; i < this.members.length; i++) |
| { |
| var member = this.members[i]; |
| if (member.untested) |
| { |
| continue; |
| } |
| if (member.type == "const") |
| { |
| test(function() |
| { |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| |
| // "For each constant defined on an interface A, there must be |
| // a corresponding property on the interface object, if it |
| // exists." |
| assert_own_property(window[this.name], member.name); |
| // "The value of the property is that which is obtained by |
| // converting the constant’s IDL value to an ECMAScript |
| // value." |
| assert_equals(window[this.name][member.name], constValue(member.value), |
| "property has wrong value"); |
| // "The property has attributes { [[Writable]]: false, |
| // [[Enumerable]]: true, [[Configurable]]: false }." |
| var desc = Object.getOwnPropertyDescriptor(window[this.name], member.name); |
| assert_false("get" in desc, "property has getter"); |
| assert_false("set" in desc, "property has setter"); |
| assert_false(desc.writable, "property is writable"); |
| assert_true(desc.enumerable, "property is not enumerable"); |
| assert_false(desc.configurable, "property is configurable"); |
| }.bind(this), this.name + " interface: constant " + member.name + " on interface object"); |
| // "In addition, a property with the same characteristics must |
| // exist on the interface prototype object." |
| test(function() |
| { |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| |
| if (this.has_extended_attribute("Callback")) { |
| assert_false("prototype" in window[this.name], |
| this.name + ' should not have a "prototype" property'); |
| return; |
| } |
| |
| assert_own_property(window[this.name], "prototype", |
| 'interface "' + this.name + '" does not have own property "prototype"'); |
| |
| assert_own_property(window[this.name].prototype, member.name); |
| assert_equals(window[this.name].prototype[member.name], constValue(member.value), |
| "property has wrong value"); |
| var desc = Object.getOwnPropertyDescriptor(window[this.name], member.name); |
| assert_false("get" in desc, "property has getter"); |
| assert_false("set" in desc, "property has setter"); |
| assert_false(desc.writable, "property is writable"); |
| assert_true(desc.enumerable, "property is not enumerable"); |
| assert_false(desc.configurable, "property is configurable"); |
| }.bind(this), this.name + " interface: constant " + member.name + " on interface prototype object"); |
| } |
| else if (member.type == "attribute") |
| { |
| if (member.has_extended_attribute("Unforgeable")) |
| { |
| // We do the checks in test_interface_of instead |
| continue; |
| } |
| test(function() |
| { |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| assert_own_property(window[this.name], "prototype", |
| 'interface "' + this.name + '" does not have own property "prototype"'); |
| |
| if (member["static"]) { |
| assert_own_property(window[this.name], member.name, |
| "The interface object must have a property " + |
| format_value(member.name)); |
| } |
| else |
| { |
| assert_true(member.name in window[this.name].prototype, |
| "The prototype object must have a property " + |
| format_value(member.name)); |
| |
| // TODO: Needs to test for LenientThis. |
| assert_throws(new TypeError(), function() { |
| window[this.name].prototype[member.name]; |
| }.bind(this), "getting property on prototype object must throw TypeError"); |
| do_interface_attribute_asserts(window[this.name].prototype, member); |
| } |
| }.bind(this), this.name + " interface: attribute " + member.name); |
| } |
| else if (member.type == "operation") |
| { |
| // TODO: Need to correctly handle multiple operations with the same |
| // identifier. |
| if (!member.name) |
| { |
| // Unnamed getter or such |
| continue; |
| } |
| test(function() |
| { |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| |
| if (this.has_extended_attribute("Callback")) { |
| assert_false("prototype" in window[this.name], |
| this.name + ' should not have a "prototype" property'); |
| return; |
| } |
| |
| assert_own_property(window[this.name], "prototype", |
| 'interface "' + this.name + '" does not have own property "prototype"'); |
| |
| // "For each unique identifier of an operation defined on the |
| // interface, there must be a corresponding property on the |
| // interface prototype object (if it is a regular operation) or |
| // the interface object (if it is a static operation), unless |
| // the effective overload set for that identifier and operation |
| // and with an argument count of 0 (for the ECMAScript language |
| // binding) has no entries." |
| // |
| var prototypeOrInterfaceObject; |
| if (member["static"]) { |
| assert_own_property(window[this.name], member.name, |
| "interface prototype object missing static operation"); |
| prototypeOrInterfaceObject = window[this.name]; |
| } |
| else |
| { |
| assert_own_property(window[this.name].prototype, member.name, |
| "interface prototype object missing non-static operation"); |
| prototypeOrInterfaceObject = window[this.name].prototype; |
| } |
| |
| var desc = Object.getOwnPropertyDescriptor(prototypeOrInterfaceObject, member.name); |
| // "The property has attributes { [[Writable]]: true, |
| // [[Enumerable]]: true, [[Configurable]]: true }." |
| assert_false("get" in desc, "property has getter"); |
| assert_false("set" in desc, "property has setter"); |
| assert_true(desc.writable, "property is not writable"); |
| assert_true(desc.enumerable, "property is not enumerable"); |
| assert_true(desc.configurable, "property is not configurable"); |
| // "The value of the property is a Function object whose |
| // behavior is as follows . . ." |
| assert_equals(typeof prototypeOrInterfaceObject[member.name], "function", |
| "property must be a function"); |
| // "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." |
| // |
| // TODO: Doesn't handle overloading or variadic arguments. |
| assert_equals(prototypeOrInterfaceObject[member.name].length, |
| member.arguments.filter(function(arg) { |
| return !arg.optional; |
| }).length, |
| "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. |
| if (!member["static"]) { |
| assert_throws(new TypeError(), function() { |
| window[this.name].prototype[member.name].apply(null, args); |
| }, "calling operation with this = null didn't throw TypeError"); |
| } |
| |
| // ". . . If O is not null and is also not a platform object |
| // that implements interface I, throw a TypeError." |
| // |
| // TODO: Test a platform object that implements some other |
| // interface. (Have to be sure to get inheritance right.) |
| assert_throws(new TypeError(), function() { |
| window[this.name].prototype[member.name].apply({}, args); |
| }, "calling operation with this = {} didn't throw TypeError"); |
| }.bind(this), this.name + " interface: operation " + member.name + |
| "(" + member.arguments.map(function(m) { return m.idlType.idlType; }) + |
| ")"); |
| } |
| // TODO: check more member types, like stringifier |
| } |
| }; |
| |
| //@} |
| IdlInterface.prototype.test_object = function(desc) |
| //@{ |
| { |
| var obj, exception = null; |
| try |
| { |
| obj = eval(desc); |
| } |
| catch(e) |
| { |
| exception = e; |
| } |
| |
| // TODO: WebIDLParser doesn't currently support named legacycallers, so I'm |
| // not sure what those would look like in the AST |
| var expected_typeof = this.members.some(function(member) |
| { |
| return member.legacycaller |
| || ("idlType" in member && member.idlType.legacycaller) |
| || ("idlType" in member && typeof member.idlType == "object" |
| && "idlType" in member.idlType && member.idlType.idlType == "legacycaller"); |
| }) ? "function" : "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 "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) |
| //@{ |
| { |
| // 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)) |
| { |
| test(function() |
| { |
| assert_equals(exception, null, "Unexpected exception when evaluating object"); |
| assert_equals(typeof obj, expected_typeof, "wrong typeof object"); |
| assert_own_property(window, this.name, |
| "window does not have own property " + format_value(this.name)); |
| assert_own_property(window[this.name], "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), |
| window[this.name].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 identifier of the primary interface of the |
| // platform object." |
| 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.name, "class string of " + desc); |
| if (!this.has_stringifier()) |
| { |
| assert_equals(String(obj), "[object " + this.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; |
| |
| for (var i = 0; i < this.members.length; i++) |
| { |
| var member = this.members[i]; |
| if (member.has_extended_attribute("Unforgeable")) |
| { |
| test(function() |
| { |
| assert_equals(exception, null, "Unexpected exception when evaluating object"); |
| assert_equals(typeof obj, expected_typeof, "wrong typeof object"); |
| do_interface_attribute_asserts(obj, member); |
| }.bind(this), this.name + " interface: " + desc + ' must have own property "' + member.name + '"'); |
| } |
| else if ((member.type == "const" |
| || member.type == "attribute" |
| || member.type == "operation") |
| && member.name) |
| { |
| test(function() |
| { |
| assert_equals(exception, null, "Unexpected exception when evaluating object"); |
| assert_equals(typeof obj, expected_typeof, "wrong typeof object"); |
| if (!member["static"]) { |
| assert_inherits(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) |
| { |
| 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.name + '" with the proper type (' + i + ')'); |
| } |
| // TODO: This is wrong if there are multiple operations with the same |
| // identifier. |
| // TODO: Test passing arguments of the wrong type. |
| if (member.type == "operation" && member.name && member.arguments.length) |
| { |
| test(function() |
| { |
| assert_equals(exception, null, "Unexpected exception when evaluating object"); |
| assert_equals(typeof obj, expected_typeof, "wrong typeof object"); |
| if (!member["static"]) { |
| assert_inherits(obj, member.name); |
| } |
| else |
| { |
| assert_false(member.name in obj); |
| } |
| var args = []; |
| for (var i = 0; i < member.arguments.length; i++) |
| { |
| if (member.arguments[i].optional) |
| { |
| break; |
| } |
| assert_throws(new TypeError(), function() |
| { |
| obj[member.name].apply(obj, args); |
| }.bind(this), "Called with " + i + " arguments"); |
| |
| args.push(create_suitable_object(member.arguments[i].idlType)); |
| } |
| }.bind(this), this.name + " interface: calling " + member.name + |
| "(" + member.arguments.map(function(m) { return m.idlType.idlType; }) + |
| ") on " + desc + " with too few arguments must throw TypeError"); |
| } |
| } |
| }; |
| |
| //@} |
| IdlInterface.prototype.has_stringifier = function() |
| //@{ |
| { |
| if (this.members.some(function(member) { return member.stringifier; })) { |
| return true; |
| } |
| if (this.base && |
| this.array.members[this.base].has_stringifier()) { |
| return true; |
| } |
| return false; |
| }; |
| |
| //@} |
| function do_interface_attribute_asserts(obj, member) |
| //@{ |
| { |
| // "For each attribute defined on the interface, there must exist a |
| // corresponding property. If the attribute was declared with the |
| // [Unforgeable] extended attribute, then the property exists on every |
| // object that implements the interface. Otherwise, it exists on the |
| // interface’s interface prototype object." |
| // |
| // This is called by test_self() with the prototype as obj, and by |
| // test_interface_of() with the object as obj. |
| 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 |
| // [Unforgeable] 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 has value but is supposed to be accessor'); |
| assert_false("writable" in desc, 'property descriptor has "writable" field but is supposed to be accessor'); |
| assert_true(desc.enumerable, "property is not enumerable"); |
| if (member.has_extended_attribute("Unforgeable")) |
| { |
| assert_false(desc.configurable, "[Unforgeable] 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: |
| // "... |
| // "The value of the Function object’s “length” property is the Number |
| // value 0." |
| assert_equals(typeof desc.get, "function", "getter must be Function"); |
| assert_equals(desc.get.length, 0, "getter length must be 0"); |
| // TODO: Account for LenientThis |
| assert_throws(new TypeError(), function() |
| { |
| desc.get.call({}); |
| }.bind(this), "calling getter on wrong object type must throw TypeError"); |
| |
| // TODO: Test calling setter on the interface prototype (should throw |
| // TypeError in most cases). |
| // |
| // "The attribute setter is undefined if the attribute is declared readonly |
| // and has neither a [PutForwards] nor a [Replaceable] extended attribute |
| // declared on it. Otherwise, it is a Function object whose behavior when |
| // invoked is as follows: |
| // "... |
| // "The value of the Function object’s “length” property is the Number |
| // value 1." |
| if (member.readonly |
| && !member.has_extended_attribute("PutForwards") |
| && !member.has_extended_attribute("Replaceable")) |
| { |
| assert_equals(desc.set, undefined, "setter must be undefined for readonly attributes"); |
| } |
| else |
| { |
| assert_equals(typeof desc.set, "function", "setter must be function for PutForwards, Replaceable, or non-readonly attributes"); |
| assert_equals(desc.set.length, 1, "setter length must be 1"); |
| } |
| } |
| //@} |
| |
| /// 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) |
| { |
| this[k] = obj[k]; |
| } |
| if (!("extAttrs" in this)) |
| { |
| this.extAttrs = []; |
| } |
| } |
| |
| //@} |
| IdlInterfaceMember.prototype = Object.create(IdlObject.prototype); |
| |
| /// 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": |
| 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); |
| |
| /// 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; |
| |
| /** An array of values produced by the "typedef" production. */ |
| this.values = obj.values; |
| |
| } |
| //@} |
| |
| IdlTypedef.prototype = Object.create(IdlObject.prototype); |
| |
| }()); |
| // vim: set expandtab shiftwidth=4 tabstop=4 foldmarker=@{,@} foldmethod=marker: |
