michael@0: /*
michael@0: Distributed under both the W3C Test Suite License [1] and the W3C
michael@0: 3-clause BSD License [2]. To contribute to a W3C Test Suite, see the
michael@0: policies and contribution forms [3].
michael@0: 
michael@0: [1] http://www.w3.org/Consortium/Legal/2008/04-testsuite-license
michael@0: [2] http://www.w3.org/Consortium/Legal/2008/03-bsd-license
michael@0: [3] http://www.w3.org/2004/10/27-testcases
michael@0: */
michael@0: 
michael@0: /*
michael@0:  * This file automatically generates browser tests for WebIDL interfaces, using
michael@0:  * the testharness.js framework.  To use, first include the following:
michael@0:  *
michael@0:  *   <script src=/resources/testharness.js></script>
michael@0:  *   <script src=/resources/testharnessreport.js></script>
michael@0:  *   <script src=/resources/WebIDLParser.js></script>
michael@0:  *   <script src=/resources/idlharness.js></script>
michael@0:  *
michael@0:  * Then you'll need some type of IDLs.  Here's some script that can be run on a
michael@0:  * spec written in HTML, which will grab all the elements with class="idl",
michael@0:  * concatenate them, and replace the body so you can copy-paste:
michael@0:  *
michael@0:      var s = "";
michael@0:      [].forEach.call(document.getElementsByClassName("idl"), function(idl) {
michael@0:        //https://www.w3.org/Bugs/Public/show_bug.cgi?id=14914
michael@0:        if (!idl.classList.contains("extract"))
michael@0:        {
michael@0:          s += idl.textContent + "\n\n";
michael@0:        }
michael@0:      });
michael@0:      document.body.innerHTML = '<pre></pre>';
michael@0:      document.body.firstChild.textContent = s;
michael@0:  *
michael@0:  * (TODO: write this in Python or something so that it can be done from the
michael@0:  * command line instead.)
michael@0:  *
michael@0:  * Once you have that, put it in your script somehow.  The easiest way is to
michael@0:  * embed it literally in an HTML file with <script type=text/plain> or similar,
michael@0:  * so that you don't have to do any escaping.  Another possibility is to put it
michael@0:  * in a separate .idl file that's fetched via XHR or similar.  Sample usage:
michael@0:  *
michael@0:  *   var idl_array = new IdlArray();
michael@0:  *   idl_array.add_untested_idls("interface Node { readonly attribute DOMString nodeName; };");
michael@0:  *   idl_array.add_idls("interface Document : Node { readonly attribute DOMString URL; };");
michael@0:  *   idl_array.add_objects({Document: ["document"]});
michael@0:  *   idl_array.test();
michael@0:  *
michael@0:  * This tests that window.Document exists and meets all the requirements of
michael@0:  * WebIDL.  It also tests that window.document (the result of evaluating the
michael@0:  * string "document") has URL and nodeName properties that behave as they
michael@0:  * should, and otherwise meets WebIDL's requirements for an object whose
michael@0:  * primary interface is Document.  It does not test that window.Node exists,
michael@0:  * which is what you want if the Node interface is already tested in some other
michael@0:  * specification's suite and your specification only extends or refers to it.
michael@0:  * Of course, each IDL string can define many different things, and calls to
michael@0:  * add_objects() can register many different objects for different interfaces:
michael@0:  * this is a very simple example.
michael@0:  *
michael@0:  * TODO: Write assert_writable, assert_enumerable, assert_configurable and
michael@0:  * their inverses, and use those instead of just checking
michael@0:  * getOwnPropertyDescriptor.
michael@0:  *
michael@0:  * == Public methods of IdlArray ==
michael@0:  *
michael@0:  * IdlArray objects can be obtained with new IdlArray().  Anything not
michael@0:  * documented in this section should be considered an implementation detail,
michael@0:  * and outside callers should not use it.
michael@0:  *
michael@0:  * add_idls(idl_string):
michael@0:  *   Parses idl_string (throwing on parse error) and adds the results to the
michael@0:  *   IdlArray.  All the definitions will be tested when you run test().  If
michael@0:  *   some of the definitions refer to other definitions, those must be present
michael@0:  *   too.  For instance, if idl_string says that Document inherits from Node,
michael@0:  *   the Node interface must also have been provided in some call to add_idls()
michael@0:  *   or add_untested_idls().
michael@0:  *
michael@0:  * add_untested_idls(idl_string):
michael@0:  *   Like add_idls(), but the definitions will not be tested.  If an untested
michael@0:  *   interface is added and then extended with a tested partial interface, the
michael@0:  *   members of the partial interface will still be tested.  Also, all the
michael@0:  *   members will still be tested for objects added with add_objects(), because
michael@0:  *   you probably want to test that (for instance) window.document has all the
michael@0:  *   properties from Node, not just Document, even if the Node interface itself
michael@0:  *   is tested in a different test suite.
michael@0:  *
michael@0:  * add_objects(dict):
michael@0:  *   dict should be an object whose keys are the names of interfaces or
michael@0:  *   exceptions, and whose values are arrays of strings.  When an interface or
michael@0:  *   exception is tested, every string registered for it with add_objects()
michael@0:  *   will be evaluated, and tests will be run on the result to verify that it
michael@0:  *   correctly implements that interface or exception.  This is the only way to
michael@0:  *   test anything about [NoInterfaceObject] interfaces, and there are many
michael@0:  *   tests that can't be run on any interface without an object to fiddle with.
michael@0:  *
michael@0:  *   The interface has to be the *primary* interface of all the objects
michael@0:  *   provided.  For example, don't pass {Node: ["document"]}, but rather
michael@0:  *   {Document: ["document"]}.  Assuming the Document interface was declared to
michael@0:  *   inherit from Node, this will automatically test that document implements
michael@0:  *   the Node interface too.
michael@0:  *
michael@0:  *   Warning: methods will be called on any provided objects, in a manner that
michael@0:  *   WebIDL requires be safe.  For instance, if a method has mandatory
michael@0:  *   arguments, the test suite will try calling it with too few arguments to
michael@0:  *   see if it throws an exception.  If an implementation incorrectly runs the
michael@0:  *   function instead of throwing, this might have side effects, possibly even
michael@0:  *   preventing the test suite from running correctly.
michael@0:  *
michael@0:  * prevent_multiple_testing(name):
michael@0:  *   This is a niche method for use in case you're testing many objects that
michael@0:  *   implement the same interfaces, and don't want to retest the same
michael@0:  *   interfaces every single time.  For instance, HTML defines many interfaces
michael@0:  *   that all inherit from HTMLElement, so the HTML test suite has something
michael@0:  *   like
michael@0:  *     .add_objects({
michael@0:  *         HTMLHtmlElement: ['document.documentElement'],
michael@0:  *         HTMLHeadElement: ['document.head'],
michael@0:  *         HTMLBodyElement: ['document.body'],
michael@0:  *         ...
michael@0:  *     })
michael@0:  *   and so on for dozens of element types.  This would mean that it would
michael@0:  *   retest that each and every one of those elements implements HTMLElement,
michael@0:  *   Element, and Node, which would be thousands of basically redundant tests.
michael@0:  *   The test suite therefore calls prevent_multiple_testing("HTMLElement").
michael@0:  *   This means that once one object has been tested to implement HTMLElement
michael@0:  *   and its ancestors, no other object will be.  Thus in the example code
michael@0:  *   above, the harness would test that document.documentElement correctly
michael@0:  *   implements HTMLHtmlElement, HTMLElement, Element, and Node; but
michael@0:  *   document.head would only be tested for HTMLHeadElement, and so on for
michael@0:  *   further objects.
michael@0:  *
michael@0:  * test():
michael@0:  *   Run all tests.  This should be called after you've called all other
michael@0:  *   methods to add IDLs and objects.
michael@0:  */
michael@0: 
michael@0: /**
michael@0:  * Notes for people who want to edit this file (not just use it as a library):
michael@0:  *
michael@0:  * Most of the interesting stuff happens in the derived classes of IdlObject,
michael@0:  * especially IdlInterface.  The entry point for all IdlObjects is .test(),
michael@0:  * which is called by IdlArray.test().  An IdlObject is conceptually just
michael@0:  * "thing we want to run tests on", and an IdlArray is an array of IdlObjects
michael@0:  * with some additional data thrown in.
michael@0:  *
michael@0:  * The object model is based on what WebIDLParser.js produces, which is in turn
michael@0:  * based on its pegjs grammar.  If you want to figure out what properties an
michael@0:  * object will have from WebIDLParser.js, the best way is to look at the
michael@0:  * grammar:
michael@0:  *
michael@0:  *   https://github.com/darobin/webidl.js/blob/master/lib/grammar.peg
michael@0:  *
michael@0:  * So for instance:
michael@0:  *
michael@0:  *   // interface definition
michael@0:  *   interface
michael@0:  *       =   extAttrs:extendedAttributeList? S? "interface" S name:identifier w herit:ifInheritance? w "{" w mem:ifMember* w "}" w ";" w
michael@0:  *           { return { type: "interface", name: name, inheritance: herit, members: mem, extAttrs: extAttrs }; }
michael@0:  *
michael@0:  * This means that an "interface" object will have a .type property equal to
michael@0:  * the string "interface", a .name property equal to the identifier that the
michael@0:  * parser found, an .inheritance property equal to either null or the result of
michael@0:  * the "ifInheritance" production found elsewhere in the grammar, and so on.
michael@0:  * After each grammatical production is a JavaScript function in curly braces
michael@0:  * that gets called with suitable arguments and returns some JavaScript value.
michael@0:  *
michael@0:  * (Note that the version of WebIDLParser.js we use might sometimes be
michael@0:  * out-of-date or forked.)
michael@0:  *
michael@0:  * The members and methods of the classes defined by this file are all at least
michael@0:  * briefly documented, hopefully.
michael@0:  */
michael@0: (function(){
michael@0: "use strict";
michael@0: /// Helpers ///
michael@0: function constValue (cnt) {
michael@0:     if (cnt.type === "null") return null;
michael@0:     if (cnt.type === "NaN") return NaN;
michael@0:     if (cnt.type === "Infinity") return cnt.negative ? -Infinity : Infinity;
michael@0:     return cnt.value;
michael@0: }
michael@0: 
michael@0: /// IdlArray ///
michael@0: // Entry point
michael@0: window.IdlArray = function()
michael@0: //@{
michael@0: {
michael@0:     /**
michael@0:      * A map from strings to the corresponding named IdlObject, such as
michael@0:      * IdlInterface or IdlException.  These are the things that test() will run
michael@0:      * tests on.
michael@0:      */
michael@0:     this.members = {};
michael@0: 
michael@0:     /**
michael@0:      * A map from strings to arrays of strings.  The keys are interface or
michael@0:      * exception names, and are expected to also exist as keys in this.members
michael@0:      * (otherwise they'll be ignored).  This is populated by add_objects() --
michael@0:      * see documentation at the start of the file.  The actual tests will be
michael@0:      * run by calling this.members[name].test_object(obj) for each obj in
michael@0:      * this.objects[name].  obj is a string that will be eval'd to produce a
michael@0:      * JavaScript value, which is supposed to be an object implementing the
michael@0:      * given IdlObject (interface, exception, etc.).
michael@0:      */
michael@0:     this.objects = {};
michael@0: 
michael@0:     /**
michael@0:      * When adding multiple collections of IDLs one at a time, an earlier one
michael@0:      * might contain a partial interface or implements statement that depends
michael@0:      * on a later one.  Save these up and handle them right before we run
michael@0:      * tests.
michael@0:      *
michael@0:      * .partials is simply an array of objects from WebIDLParser.js'
michael@0:      * "partialinterface" production.  .implements maps strings to arrays of
michael@0:      * strings, such that
michael@0:      *
michael@0:      *   A implements B;
michael@0:      *   A implements C;
michael@0:      *   D implements E;
michael@0:      *
michael@0:      * results in { A: ["B", "C"], D: ["E"] }.
michael@0:      */
michael@0:     this.partials = [];
michael@0:     this["implements"] = {};
michael@0: };
michael@0: 
michael@0: //@}
michael@0: IdlArray.prototype.add_idls = function(raw_idls)
michael@0: //@{
michael@0: {
michael@0:     /** Entry point.  See documentation at beginning of file. */
michael@0:     this.internal_add_idls(WebIDL2.parse(raw_idls));
michael@0: };
michael@0: 
michael@0: //@}
michael@0: IdlArray.prototype.add_untested_idls = function(raw_idls)
michael@0: //@{
michael@0: {
michael@0:     /** Entry point.  See documentation at beginning of file. */
michael@0:     var parsed_idls = WebIDL2.parse(raw_idls);
michael@0:     for (var i = 0; i < parsed_idls.length; i++)
michael@0:     {
michael@0:         parsed_idls[i].untested = true;
michael@0:         if ("members" in parsed_idls[i])
michael@0:         {
michael@0:             for (var j = 0; j < parsed_idls[i].members.length; j++)
michael@0:             {
michael@0:                 parsed_idls[i].members[j].untested = true;
michael@0:             }
michael@0:         }
michael@0:     }
michael@0:     this.internal_add_idls(parsed_idls);
michael@0: };
michael@0: 
michael@0: //@}
michael@0: IdlArray.prototype.internal_add_idls = function(parsed_idls)
michael@0: //@{
michael@0: {
michael@0:     /**
michael@0:      * Internal helper called by add_idls() and add_untested_idls().
michael@0:      * parsed_idls is an array of objects that come from WebIDLParser.js's
michael@0:      * "definitions" production.  The add_untested_idls() entry point
michael@0:      * additionally sets an .untested property on each object (and its
michael@0:      * .members) so that they'll be skipped by test() -- they'll only be
michael@0:      * used for base interfaces of tested interfaces, return types, etc.
michael@0:      */
michael@0:     parsed_idls.forEach(function(parsed_idl)
michael@0:     {
michael@0:         if (parsed_idl.type == "interface" && parsed_idl.partial)
michael@0:         {
michael@0:             this.partials.push(parsed_idl);
michael@0:             return;
michael@0:         }
michael@0: 
michael@0:         if (parsed_idl.type == "implements")
michael@0:         {
michael@0:             if (!(parsed_idl.target in this["implements"]))
michael@0:             {
michael@0:                 this["implements"][parsed_idl.target] = [];
michael@0:             }
michael@0:             this["implements"][parsed_idl.target].push(parsed_idl["implements"]);
michael@0:             return;
michael@0:         }
michael@0: 
michael@0:         parsed_idl.array = this;
michael@0:         if (parsed_idl.name in this.members)
michael@0:         {
michael@0:             throw "Duplicate identifier " + parsed_idl.name;
michael@0:         }
michael@0:         switch(parsed_idl.type)
michael@0:         {
michael@0:         case "interface":
michael@0:             this.members[parsed_idl.name] = new IdlInterface(parsed_idl);
michael@0:             break;
michael@0: 
michael@0:         case "exception":
michael@0:             this.members[parsed_idl.name] = new IdlException(parsed_idl);
michael@0:             break;
michael@0: 
michael@0:         case "dictionary":
michael@0:             // Nothing to test, but we need the dictionary info around for type
michael@0:             // checks
michael@0:             this.members[parsed_idl.name] = new IdlDictionary(parsed_idl);
michael@0:             break;
michael@0: 
michael@0:         case "typedef":
michael@0:             this.members[parsed_idl.name] = new IdlTypedef(parsed_idl);
michael@0:             break;
michael@0: 
michael@0:         case "callback":
michael@0:             // TODO
michael@0:             console.log("callback not yet supported");
michael@0:             break;
michael@0: 
michael@0:         case "enum":
michael@0:             this.members[parsed_idl.name] = new IdlEnum(parsed_idl);
michael@0:             break;
michael@0: 
michael@0:         case "callback interface":
michael@0:             // TODO
michael@0:             console.log("callback interface not yet supported");
michael@0:             break;
michael@0: 
michael@0:         default:
michael@0:             throw parsed_idl.name + ": " + parsed_idl.type + " not yet supported";
michael@0:         }
michael@0:     }.bind(this));
michael@0: };
michael@0: 
michael@0: //@}
michael@0: IdlArray.prototype.add_objects = function(dict)
michael@0: //@{
michael@0: {
michael@0:     /** Entry point.  See documentation at beginning of file. */
michael@0:     for (var k in dict)
michael@0:     {
michael@0:         if (k in this.objects)
michael@0:         {
michael@0:             this.objects[k] = this.objects[k].concat(dict[k]);
michael@0:         }
michael@0:         else
michael@0:         {
michael@0:             this.objects[k] = dict[k];
michael@0:         }
michael@0:     }
michael@0: };
michael@0: 
michael@0: //@}
michael@0: IdlArray.prototype.prevent_multiple_testing = function(name)
michael@0: //@{
michael@0: {
michael@0:     /** Entry point.  See documentation at beginning of file. */
michael@0:     this.members[name].prevent_multiple_testing = true;
michael@0: };
michael@0: 
michael@0: //@}
michael@0: IdlArray.prototype.recursively_get_implements = function(interface_name)
michael@0: //@{
michael@0: {
michael@0:     /**
michael@0:      * Helper function for test().  Returns an array of things that implement
michael@0:      * interface_name, so if the IDL contains
michael@0:      *
michael@0:      *   A implements B;
michael@0:      *   B implements C;
michael@0:      *   B implements D;
michael@0:      *
michael@0:      * then recursively_get_implements("A") should return ["B", "C", "D"].
michael@0:      */
michael@0:     var ret = this["implements"][interface_name];
michael@0:     if (ret === undefined)
michael@0:     {
michael@0:         return [];
michael@0:     }
michael@0:     for (var i = 0; i < this["implements"][interface_name].length; i++)
michael@0:     {
michael@0:         ret = ret.concat(this.recursively_get_implements(ret[i]));
michael@0:         if (ret.indexOf(ret[i]) != ret.lastIndexOf(ret[i]))
michael@0:         {
michael@0:             throw "Circular implements statements involving " + ret[i];
michael@0:         }
michael@0:     }
michael@0:     return ret;
michael@0: };
michael@0: 
michael@0: //@}
michael@0: IdlArray.prototype.test = function()
michael@0: //@{
michael@0: {
michael@0:     /** Entry point.  See documentation at beginning of file. */
michael@0: 
michael@0:     // First merge in all the partial interfaces and implements statements we
michael@0:     // encountered.
michael@0:     this.partials.forEach(function(parsed_idl)
michael@0:     {
michael@0:         if (!(parsed_idl.name in this.members)
michael@0:         || !(this.members[parsed_idl.name] instanceof IdlInterface))
michael@0:         {
michael@0:             throw "Partial interface " + parsed_idl.name + " with no original interface";
michael@0:         }
michael@0:         if (parsed_idl.extAttrs)
michael@0:         {
michael@0:             parsed_idl.extAttrs.forEach(function(extAttr)
michael@0:             {
michael@0:                 this.members[parsed_idl.name].extAttrs.push(extAttr);
michael@0:             }.bind(this));
michael@0:         }
michael@0:         parsed_idl.members.forEach(function(member)
michael@0:         {
michael@0:             this.members[parsed_idl.name].members.push(new IdlInterfaceMember(member));
michael@0:         }.bind(this));
michael@0:     }.bind(this));
michael@0:     this.partials = [];
michael@0: 
michael@0:     for (var lhs in this["implements"])
michael@0:     {
michael@0:         this.recursively_get_implements(lhs).forEach(function(rhs)
michael@0:         {
michael@0:             var errStr = lhs + " implements " + rhs + ", but ";
michael@0:             if (!(lhs in this.members)) throw errStr + lhs + " is undefined.";
michael@0:             if (!(this.members[lhs] instanceof IdlInterface)) throw errStr + lhs + " is not an interface.";
michael@0:             if (!(rhs in this.members)) throw errStr + rhs + " is undefined.";
michael@0:             if (!(this.members[rhs] instanceof IdlInterface)) throw errStr + rhs + " is not an interface.";
michael@0:             this.members[rhs].members.forEach(function(member)
michael@0:             {
michael@0:                 this.members[lhs].members.push(new IdlInterfaceMember(member));
michael@0:             }.bind(this));
michael@0:         }.bind(this));
michael@0:     }
michael@0:     this["implements"] = {};
michael@0: 
michael@0:     // Now run test() on every member, and test_object() for every object.
michael@0:     for (var name in this.members)
michael@0:     {
michael@0:         this.members[name].test();
michael@0:         if (name in this.objects)
michael@0:         {
michael@0:             this.objects[name].forEach(function(str)
michael@0:             {
michael@0:                 this.members[name].test_object(str);
michael@0:             }.bind(this));
michael@0:         }
michael@0:     }
michael@0: };
michael@0: 
michael@0: //@}
michael@0: IdlArray.prototype.assert_type_is = function(value, type)
michael@0: //@{
michael@0: {
michael@0:     /**
michael@0:      * Helper function that tests that value is an instance of type according
michael@0:      * to the rules of WebIDL.  value is any JavaScript value, and type is an
michael@0:      * object produced by WebIDLParser.js' "type" production.  That production
michael@0:      * is fairly elaborate due to the complexity of WebIDL's types, so it's
michael@0:      * best to look at the grammar to figure out what properties it might have.
michael@0:      */
michael@0:     if (type.idlType == "any")
michael@0:     {
michael@0:         // No assertions to make
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     if (type.nullable && value === null)
michael@0:     {
michael@0:         // This is fine
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     if (type.array)
michael@0:     {
michael@0:         // TODO: not supported yet
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     if (type.sequence)
michael@0:     {
michael@0:         assert_true(Array.isArray(value), "is not array");
michael@0:         if (!value.length)
michael@0:         {
michael@0:             // Nothing we can do.
michael@0:             return;
michael@0:         }
michael@0:         this.assert_type_is(value[0], type.idlType.idlType);
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     type = type.idlType;
michael@0: 
michael@0:     switch(type)
michael@0:     {
michael@0:         case "void":
michael@0:             assert_equals(value, undefined);
michael@0:             return;
michael@0: 
michael@0:         case "boolean":
michael@0:             assert_equals(typeof value, "boolean");
michael@0:             return;
michael@0: 
michael@0:         case "byte":
michael@0:             assert_equals(typeof value, "number");
michael@0:             assert_equals(value, Math.floor(value), "not an integer");
michael@0:             assert_true(-128 <= value && value <= 127, "byte " + value + " not in range [-128, 127]");
michael@0:             return;
michael@0: 
michael@0:         case "octet":
michael@0:             assert_equals(typeof value, "number");
michael@0:             assert_equals(value, Math.floor(value), "not an integer");
michael@0:             assert_true(0 <= value && value <= 255, "octet " + value + " not in range [0, 255]");
michael@0:             return;
michael@0: 
michael@0:         case "short":
michael@0:             assert_equals(typeof value, "number");
michael@0:             assert_equals(value, Math.floor(value), "not an integer");
michael@0:             assert_true(-32768 <= value && value <= 32767, "short " + value + " not in range [-32768, 32767]");
michael@0:             return;
michael@0: 
michael@0:         case "unsigned short":
michael@0:             assert_equals(typeof value, "number");
michael@0:             assert_equals(value, Math.floor(value), "not an integer");
michael@0:             assert_true(0 <= value && value <= 65535, "unsigned short " + value + " not in range [0, 65535]");
michael@0:             return;
michael@0: 
michael@0:         case "long":
michael@0:             assert_equals(typeof value, "number");
michael@0:             assert_equals(value, Math.floor(value), "not an integer");
michael@0:             assert_true(-2147483648 <= value && value <= 2147483647, "long " + value + " not in range [-2147483648, 2147483647]");
michael@0:             return;
michael@0: 
michael@0:         case "unsigned long":
michael@0:             assert_equals(typeof value, "number");
michael@0:             assert_equals(value, Math.floor(value), "not an integer");
michael@0:             assert_true(0 <= value && value <= 4294967295, "unsigned long " + value + " not in range [0, 4294967295]");
michael@0:             return;
michael@0: 
michael@0:         case "long long":
michael@0:             assert_equals(typeof value, "number");
michael@0:             return;
michael@0: 
michael@0:         case "unsigned long long":
michael@0:             assert_equals(typeof value, "number");
michael@0:             assert_true(0 <= value, "unsigned long long is negative");
michael@0:             return;
michael@0: 
michael@0:         case "float":
michael@0:         case "double":
michael@0:         case "unrestricted float":
michael@0:         case "unrestricted double":
michael@0:             // TODO: distinguish these cases
michael@0:             assert_equals(typeof value, "number");
michael@0:             return;
michael@0: 
michael@0:         case "DOMString":
michael@0:             assert_equals(typeof value, "string");
michael@0:             return;
michael@0: 
michael@0:         case "object":
michael@0:             assert_true(typeof value == "object" || typeof value == "function", "wrong type: not object or function");
michael@0:             return;
michael@0:     }
michael@0: 
michael@0:     if (!(type in this.members))
michael@0:     {
michael@0:         throw "Unrecognized type " + type;
michael@0:     }
michael@0: 
michael@0:     if (this.members[type] instanceof IdlInterface)
michael@0:     {
michael@0:         // We don't want to run the full
michael@0:         // IdlInterface.prototype.test_instance_of, because that could result
michael@0:         // in an infinite loop.  TODO: This means we don't have tests for
michael@0:         // NoInterfaceObject interfaces, and we also can't test objects that
michael@0:         // come from another window.
michael@0:         assert_true(typeof value == "object" || typeof value == "function", "wrong type: not object or function");
michael@0:         if (value instanceof Object
michael@0:         && !this.members[type].has_extended_attribute("NoInterfaceObject")
michael@0:         && type in window)
michael@0:         {
michael@0:             assert_true(value instanceof window[type], "not instanceof " + type);
michael@0:         }
michael@0:     }
michael@0:     else if (this.members[type] instanceof IdlEnum)
michael@0:     {
michael@0:         assert_equals(typeof value, "string");
michael@0:     }
michael@0:     else if (this.members[type] instanceof IdlDictionary)
michael@0:     {
michael@0:         // TODO: Test when we actually have something to test this on
michael@0:     }
michael@0:     else if (this.members[type] instanceof IdlTypedef)
michael@0:     {
michael@0:         // TODO: Test when we actually have something to test this on
michael@0:     }
michael@0:     else
michael@0:     {
michael@0:         throw "Type " + type + " isn't an interface or dictionary";
michael@0:     }
michael@0: };
michael@0: //@}
michael@0: 
michael@0: /// IdlObject ///
michael@0: function IdlObject() {}
michael@0: IdlObject.prototype.test = function()
michael@0: //@{
michael@0: {
michael@0:     /**
michael@0:      * By default, this does nothing, so no actual tests are run for IdlObjects
michael@0:      * that don't define any (e.g., IdlDictionary at the time of this writing).
michael@0:      */
michael@0: };
michael@0: 
michael@0: //@}
michael@0: IdlObject.prototype.has_extended_attribute = function(name)
michael@0: //@{
michael@0: {
michael@0:     /**
michael@0:      * This is only meaningful for things that support extended attributes,
michael@0:      * such as interfaces, exceptions, and members.
michael@0:      */
michael@0:     return this.extAttrs.some(function(o)
michael@0:     {
michael@0:         return o.name == name;
michael@0:     });
michael@0: };
michael@0: 
michael@0: //@}
michael@0: 
michael@0: /// IdlDictionary ///
michael@0: // Used for IdlArray.prototype.assert_type_is
michael@0: function IdlDictionary(obj)
michael@0: //@{
michael@0: {
michael@0:     /**
michael@0:      * obj is an object produced by the WebIDLParser.js "dictionary"
michael@0:      * production.
michael@0:      */
michael@0: 
michael@0:     /** Self-explanatory. */
michael@0:     this.name = obj.name;
michael@0: 
michael@0:     /** An array of objects produced by the "dictionaryMember" production. */
michael@0:     this.members = obj.members;
michael@0: 
michael@0:     /**
michael@0:      * The name (as a string) of the dictionary type we inherit from, or null
michael@0:      * if there is none.
michael@0:      */
michael@0:     this.base = obj.inheritance;
michael@0: }
michael@0: 
michael@0: //@}
michael@0: IdlDictionary.prototype = Object.create(IdlObject.prototype);
michael@0: 
michael@0: /// IdlExceptionOrInterface ///
michael@0: // Code sharing!
michael@0: function IdlExceptionOrInterface(obj)
michael@0: //@{
michael@0: {
michael@0:     /**
michael@0:      * obj is an object produced by the WebIDLParser.js "exception" or
michael@0:      * "interface" production, as appropriate.
michael@0:      */
michael@0: 
michael@0:     /** Self-explanatory. */
michael@0:     this.name = obj.name;
michael@0: 
michael@0:     /** A back-reference to our IdlArray. */
michael@0:     this.array = obj.array;
michael@0: 
michael@0:     /**
michael@0:      * An indicator of whether we should run tests on the (exception) interface
michael@0:      * object and (exception) interface prototype object.  Tests on members are
michael@0:      * controlled by .untested on each member, not this.
michael@0:      */
michael@0:     this.untested = obj.untested;
michael@0: 
michael@0:     /** An array of objects produced by the "ExtAttr" production. */
michael@0:     this.extAttrs = obj.extAttrs;
michael@0: 
michael@0:     /** An array of IdlInterfaceMembers. */
michael@0:     this.members = obj.members.map(function(m){return new IdlInterfaceMember(m); });
michael@0: 
michael@0:     /**
michael@0:      * The name (as a string) of the type we inherit from, or null if there is
michael@0:      * none.
michael@0:      */
michael@0:     this.base = obj.inheritance;
michael@0: }
michael@0:  
michael@0: //@}
michael@0: IdlExceptionOrInterface.prototype = Object.create(IdlObject.prototype);
michael@0: IdlExceptionOrInterface.prototype.test = function()
michael@0: //@{
michael@0: {
michael@0:     if (this.has_extended_attribute("NoInterfaceObject"))
michael@0:     {
michael@0:         // No tests to do without an instance.  TODO: We should still be able
michael@0:         // to run tests on the prototype object, if we obtain one through some
michael@0:         // other means.
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     if (!this.untested)
michael@0:     {
michael@0:         // First test things to do with the exception/interface object and
michael@0:         // exception/interface prototype object.
michael@0:         this.test_self();
michael@0:     }
michael@0:     // Then test things to do with its members (constants, fields, attributes,
michael@0:     // operations, . . .).  These are run even if .untested is true, because
michael@0:     // members might themselves be marked as .untested.  This might happen to
michael@0:     // interfaces if the interface itself is untested but a partial interface
michael@0:     // that extends it is tested -- then the interface itself and its initial
michael@0:     // members will be marked as untested, but the members added by the partial
michael@0:     // interface are still tested.
michael@0:     this.test_members();
michael@0: };
michael@0: 
michael@0: //@}
michael@0: 
michael@0: /// IdlException ///
michael@0: function IdlException(obj) { IdlExceptionOrInterface.call(this, obj); }
michael@0: IdlException.prototype = Object.create(IdlExceptionOrInterface.prototype);
michael@0: IdlException.prototype.test_self = function()
michael@0: //@{
michael@0: {
michael@0:     test(function()
michael@0:     {
michael@0:         // "For every exception that is not declared with the
michael@0:         // [NoInterfaceObject] extended attribute, a corresponding property
michael@0:         // must exist on the exception’s relevant namespace object. The name of
michael@0:         // the property is the identifier of the exception, and its value is an
michael@0:         // object called the exception interface object, which provides access
michael@0:         // to any constants that have been associated with the exception. The
michael@0:         // property has the attributes { [[Writable]]: true, [[Enumerable]]:
michael@0:         // false, [[Configurable]]: true }."
michael@0:         assert_own_property(window, this.name,
michael@0:                             "window does not have own property " + format_value(this.name));
michael@0:         var desc = Object.getOwnPropertyDescriptor(window, this.name);
michael@0:         assert_false("get" in desc, "window's property " + format_value(this.name) + " has getter");
michael@0:         assert_false("set" in desc, "window's property " + format_value(this.name) + " has setter");
michael@0:         assert_true(desc.writable, "window's property " + format_value(this.name) + " is not writable");
michael@0:         assert_false(desc.enumerable, "window's property " + format_value(this.name) + " is enumerable");
michael@0:         assert_true(desc.configurable, "window's property " + format_value(this.name) + " is not configurable");
michael@0: 
michael@0:         // "The exception interface object for a given exception must be a
michael@0:         // function object."
michael@0:         // "If an object is defined to be a function object, then it has
michael@0:         // characteristics as follows:"
michael@0:         // "Its [[Prototype]] internal property is the Function prototype
michael@0:         // object."
michael@0:         // Note: This doesn't match browsers as of December 2011, see
michael@0:         // http://www.w3.org/Bugs/Public/show_bug.cgi?id=14813
michael@0:         assert_equals(Object.getPrototypeOf(window[this.name]), Function.prototype,
michael@0:                       "prototype of window's property " + format_value(this.name) + " is not Function.prototype");
michael@0:         // "Its [[Get]] internal property is set as described in ECMA-262
michael@0:         // section 15.3.5.4."
michael@0:         // Not much to test for this.
michael@0:         // "Its [[Construct]] internal property is set as described in ECMA-262
michael@0:         // section 13.2.2."
michael@0:         // Tested below.
michael@0:         // "Its [[HasInstance]] internal property is set as described in
michael@0:         // ECMA-262 section 15.3.5.3, unless otherwise specified."
michael@0:         // TODO
michael@0:         // "Its [[Class]] internal property is “Function”."
michael@0:         // String() returns something implementation-dependent, because it
michael@0:         // calls Function#toString.
michael@0:         assert_class_string(window[this.name], "Function",
michael@0:                             "class string of " + this.name);
michael@0: 
michael@0:         // TODO: Test 4.9.1.1. Exception interface object [[Call]] method
michael@0:         // (which does not match browsers:
michael@0:         // http://www.w3.org/Bugs/Public/show_bug.cgi?id=14885)
michael@0:     }.bind(this), this.name + " exception: existence and properties of exception interface object");
michael@0: 
michael@0:     test(function()
michael@0:     {
michael@0:         assert_own_property(window, this.name,
michael@0:                             "window does not have own property " + format_value(this.name));
michael@0: 
michael@0:         // "The exception interface object must also have a property named
michael@0:         // “prototype” with attributes { [[Writable]]: false, [[Enumerable]]:
michael@0:         // false, [[Configurable]]: false } whose value is an object called the
michael@0:         // exception interface prototype object. This object also provides
michael@0:         // access to the constants that are declared on the exception."
michael@0:         assert_own_property(window[this.name], "prototype",
michael@0:                             'exception "' + this.name + '" does not have own property "prototype"');
michael@0:         var desc = Object.getOwnPropertyDescriptor(window[this.name], "prototype");
michael@0:         assert_false("get" in desc, this.name + ".prototype has getter");
michael@0:         assert_false("set" in desc, this.name + ".prototype has setter");
michael@0:         assert_false(desc.writable, this.name + ".prototype is writable");
michael@0:         assert_false(desc.enumerable, this.name + ".prototype is enumerable");
michael@0:         assert_false(desc.configurable, this.name + ".prototype is configurable");
michael@0: 
michael@0:         // "The exception interface prototype object for a given exception must
michael@0:         // have an internal [[Prototype]] property whose value is as follows:
michael@0:         //
michael@0:         // "If the exception is declared to inherit from another exception,
michael@0:         // then the value of the internal [[Prototype]] property is the
michael@0:         // exception interface prototype object for the inherited exception.
michael@0:         // "Otherwise, the exception is not declared to inherit from another
michael@0:         // exception. The value of the internal [[Prototype]] property is the
michael@0:         // Error prototype object ([ECMA-262], section 15.11.3.1)."
michael@0:         //
michael@0:         // Note: This doesn't match browsers as of December 2011, see
michael@0:         // https://www.w3.org/Bugs/Public/show_bug.cgi?id=14887.
michael@0:         var inherit_exception = this.base ? this.base : "Error";
michael@0:         assert_own_property(window, inherit_exception,
michael@0:                             'should inherit from ' + inherit_exception + ', but window has no such property');
michael@0:         assert_own_property(window[inherit_exception], "prototype",
michael@0:                             'should inherit from ' + inherit_exception + ', but that object has no "prototype" property');
michael@0:         assert_equals(Object.getPrototypeOf(window[this.name].prototype),
michael@0:                       window[inherit_exception].prototype,
michael@0:                       'prototype of ' + this.name + '.prototype is not ' + inherit_exception + '.prototype');
michael@0: 
michael@0:         // "The class string of an exception interface prototype object is the
michael@0:         // concatenation of the exception’s identifier and the string
michael@0:         // “Prototype”."
michael@0:         assert_class_string(window[this.name].prototype, this.name + "Prototype",
michael@0:                             "class string of " + this.name + ".prototype");
michael@0:         // TODO: Test String(), based on ES definition of
michael@0:         // Error.prototype.toString?
michael@0:     }.bind(this), this.name + " exception: existence and properties of exception interface prototype object");
michael@0: 
michael@0:     test(function()
michael@0:     {
michael@0:         assert_own_property(window, this.name,
michael@0:                             "window does not have own property " + format_value(this.name));
michael@0:         assert_own_property(window[this.name], "prototype",
michael@0:                             'interface "' + this.name + '" does not have own property "prototype"');
michael@0: 
michael@0:         // "There must be a property named “name” on the exception interface
michael@0:         // prototype object with attributes { [[Writable]]: true,
michael@0:         // [[Enumerable]]: false, [[Configurable]]: true } and whose value is
michael@0:         // the identifier of the exception."
michael@0:         assert_own_property(window[this.name].prototype, "name",
michael@0:                 'prototype object does not have own property "name"');
michael@0:         var desc = Object.getOwnPropertyDescriptor(window[this.name].prototype, "name");
michael@0:         assert_false("get" in desc, this.name + ".prototype.name has getter");
michael@0:         assert_false("set" in desc, this.name + ".prototype.name has setter");
michael@0:         assert_true(desc.writable, this.name + ".prototype.name is not writable");
michael@0:         assert_false(desc.enumerable, this.name + ".prototype.name is enumerable");
michael@0:         assert_true(desc.configurable, this.name + ".prototype.name is not configurable");
michael@0:         assert_equals(desc.value, this.name, this.name + ".prototype.name has incorrect value");
michael@0:     }.bind(this), this.name + " exception: existence and properties of exception interface prototype object's \"name\" property");
michael@0: 
michael@0:     test(function()
michael@0:     {
michael@0:         assert_own_property(window, this.name,
michael@0:                             "window does not have own property " + format_value(this.name));
michael@0:         assert_own_property(window[this.name], "prototype",
michael@0:                             'interface "' + this.name + '" does not have own property "prototype"');
michael@0: 
michael@0:         // "If the [NoInterfaceObject] extended attribute was not specified on
michael@0:         // the exception, then there must also be a property named
michael@0:         // “constructor” on the exception interface prototype object with
michael@0:         // attributes { [[Writable]]: true, [[Enumerable]]: false,
michael@0:         // [[Configurable]]: true } and whose value is a reference to the
michael@0:         // exception interface object for the exception."
michael@0:         assert_own_property(window[this.name].prototype, "constructor",
michael@0:                             this.name + '.prototype does not have own property "constructor"');
michael@0:         var desc = Object.getOwnPropertyDescriptor(window[this.name].prototype, "constructor");
michael@0:         assert_false("get" in desc, this.name + ".prototype.constructor has getter");
michael@0:         assert_false("set" in desc, this.name + ".prototype.constructor has setter");
michael@0:         assert_true(desc.writable, this.name + ".prototype.constructor is not writable");
michael@0:         assert_false(desc.enumerable, this.name + ".prototype.constructor is enumerable");
michael@0:         assert_true(desc.configurable, this.name + ".prototype.constructor in not configurable");
michael@0:         assert_equals(window[this.name].prototype.constructor, window[this.name],
michael@0:                       this.name + '.prototype.constructor is not the same object as ' + this.name);
michael@0:     }.bind(this), this.name + " exception: existence and properties of exception interface prototype object's \"constructor\" property");
michael@0: };
michael@0: 
michael@0: //@}
michael@0: IdlException.prototype.test_members = function()
michael@0: //@{
michael@0: {
michael@0:     for (var i = 0; i < this.members.length; i++)
michael@0:     {
michael@0:         var member = this.members[i];
michael@0:         if (member.untested)
michael@0:         {
michael@0:             continue;
michael@0:         }
michael@0:         if (member.type == "const" && member.name != "prototype")
michael@0:         {
michael@0:             test(function()
michael@0:             {
michael@0:                 assert_own_property(window, this.name,
michael@0:                                     "window does not have own property " + format_value(this.name));
michael@0: 
michael@0:                 // "For each constant defined on the exception, there must be a
michael@0:                 // corresponding property on the exception interface object, if
michael@0:                 // it exists, if the identifier of the constant is not
michael@0:                 // “prototype”."
michael@0:                 assert_own_property(window[this.name], member.name);
michael@0:                 // "The value of the property is the ECMAScript value that is
michael@0:                 // equivalent to the constant’s IDL value, according to the
michael@0:                 // rules in section 4.2 above."
michael@0:                 assert_equals(window[this.name][member.name], constValue(member.value),
michael@0:                               "property has wrong value");
michael@0:                 // "The property has attributes { [[Writable]]: false,
michael@0:                 // [[Enumerable]]: true, [[Configurable]]: false }."
michael@0:                 var desc = Object.getOwnPropertyDescriptor(window[this.name], member.name);
michael@0:                 assert_false("get" in desc, "property has getter");
michael@0:                 assert_false("set" in desc, "property has setter");
michael@0:                 assert_false(desc.writable, "property is writable");
michael@0:                 assert_true(desc.enumerable, "property is not enumerable");
michael@0:                 assert_false(desc.configurable, "property is configurable");
michael@0:             }.bind(this), this.name + " exception: constant " + member.name + " on exception interface object");
michael@0:             // "In addition, a property with the same characteristics must
michael@0:             // exist on the exception interface prototype object."
michael@0:             test(function()
michael@0:             {
michael@0:                 assert_own_property(window, this.name,
michael@0:                                     "window does not have own property " + format_value(this.name));
michael@0:                 assert_own_property(window[this.name], "prototype",
michael@0:                                     'exception "' + this.name + '" does not have own property "prototype"');
michael@0: 
michael@0:                 assert_own_property(window[this.name].prototype, member.name);
michael@0:                 assert_equals(window[this.name].prototype[member.name], constValue(member.value),
michael@0:                               "property has wrong value");
michael@0:                 var desc = Object.getOwnPropertyDescriptor(window[this.name].prototype, member.name);
michael@0:                 assert_false("get" in desc, "property has getter");
michael@0:                 assert_false("set" in desc, "property has setter");
michael@0:                 assert_false(desc.writable, "property is writable");
michael@0:                 assert_true(desc.enumerable, "property is not enumerable");
michael@0:                 assert_false(desc.configurable, "property is configurable");
michael@0:             }.bind(this), this.name + " exception: constant " + member.name + " on exception interface prototype object");
michael@0:         }
michael@0:         else if (member.type == "field")
michael@0:         {
michael@0:             test(function()
michael@0:             {
michael@0:                 assert_own_property(window, this.name,
michael@0:                                     "window does not have own property " + format_value(this.name));
michael@0:                 assert_own_property(window[this.name], "prototype",
michael@0:                                     'exception "' + this.name + '" does not have own property "prototype"');
michael@0: 
michael@0:                 // "For each exception field, there must be a corresponding
michael@0:                 // property on the exception interface prototype object, whose
michael@0:                 // characteristics are as follows:
michael@0:                 // "The name of the property is the identifier of the exception
michael@0:                 // field."
michael@0:                 assert_own_property(window[this.name].prototype, member.name);
michael@0:                 // "The property has attributes { [[Get]]: G, [[Enumerable]]:
michael@0:                 // true, [[Configurable]]: true }, where G is the exception
michael@0:                 // field getter, defined below."
michael@0:                 var desc = Object.getOwnPropertyDescriptor(window[this.name].prototype, member.name);
michael@0:                 assert_false("value" in desc, "property descriptor has value but is supposed to be accessor");
michael@0:                 assert_false("writable" in desc, 'property descriptor has "writable" field but is supposed to be accessor');
michael@0:                 // TODO: ES5 doesn't seem to say whether desc should have a
michael@0:                 // .set property.
michael@0:                 assert_true(desc.enumerable, "property is not enumerable");
michael@0:                 assert_true(desc.configurable, "property is not configurable");
michael@0:                 // "The exception field getter is a Function object whose
michael@0:                 // behavior when invoked is as follows:"
michael@0:                 assert_equals(typeof desc.get, "function", "typeof getter");
michael@0:                 // "The value of the Function object’s “length” property is the
michael@0:                 // Number value 0."
michael@0:                 // This test is before the TypeError tests so that it's easiest
michael@0:                 // to see that Firefox 11a1 only fails one assert in this test.
michael@0:                 assert_equals(desc.get.length, 0, "getter length");
michael@0:                 // "Let O be the result of calling ToObject on the this value.
michael@0:                 // "If O is not a platform object representing an exception for
michael@0:                 // the exception on which the exception field was declared,
michael@0:                 // then throw a TypeError."
michael@0:                 // TODO: Test on a platform object representing an exception.
michael@0:                 assert_throws(new TypeError(), function()
michael@0:                 {
michael@0:                     window[this.name].prototype[member.name];
michael@0:                 }.bind(this), "getting property on prototype object must throw TypeError");
michael@0:                 assert_throws(new TypeError(), function()
michael@0:                 {
michael@0:                     desc.get.call({});
michael@0:                 }.bind(this), "calling getter on wrong object type must throw TypeError");
michael@0:             }.bind(this), this.name + " exception: field " + member.name + " on exception interface prototype object");
michael@0:         }
michael@0:     }
michael@0: };
michael@0: 
michael@0: //@}
michael@0: IdlException.prototype.test_object = function(desc)
michael@0: //@{
michael@0: {
michael@0:     var obj, exception = null;
michael@0:     try
michael@0:     {
michael@0:         obj = eval(desc);
michael@0:     }
michael@0:     catch(e)
michael@0:     {
michael@0:         exception = e;
michael@0:     }
michael@0: 
michael@0:     test(function()
michael@0:     {
michael@0:         assert_equals(exception, null, "Unexpected exception when evaluating object");
michael@0:         assert_equals(typeof obj, "object", "wrong typeof object");
michael@0: 
michael@0:         // We can't easily test that its prototype is correct if there's no
michael@0:         // interface object, or the object is from a different global
michael@0:         // environment (not instanceof Object).  TODO: test in this case that
michael@0:         // its prototype at least looks correct, even if we can't test that
michael@0:         // it's actually correct.
michael@0:         if (!this.has_extended_attribute("NoInterfaceObject")
michael@0:         && (typeof obj != "object" || obj instanceof Object))
michael@0:         {
michael@0:             assert_own_property(window, this.name,
michael@0:                                 "window does not have own property " + format_value(this.name));
michael@0:             assert_own_property(window[this.name], "prototype",
michael@0:                                 'exception "' + this.name + '" does not have own property "prototype"');
michael@0: 
michael@0:             // "The value of the internal [[Prototype]] property of the
michael@0:             // exception object must be the exception interface prototype
michael@0:             // object from the global environment the exception object is
michael@0:             // associated with."
michael@0:             assert_equals(Object.getPrototypeOf(obj),
michael@0:                           window[this.name].prototype,
michael@0:                           desc + "'s prototype is not " + this.name + ".prototype");
michael@0:         }
michael@0: 
michael@0:         // "The class string of the exception object must be the identifier of
michael@0:         // the exception."
michael@0:         assert_class_string(obj, this.name, "class string of " + desc);
michael@0:         // Stringifier is not defined for DOMExceptions, because message isn't
michael@0:         // defined.
michael@0:     }.bind(this), this.name + " must be represented by " + desc);
michael@0: 
michael@0:     for (var i = 0; i < this.members.length; i++)
michael@0:     {
michael@0:         var member = this.members[i];
michael@0:         test(function()
michael@0:         {
michael@0:             assert_equals(exception, null, "Unexpected exception when evaluating object");
michael@0:             assert_equals(typeof obj, "object", "wrong typeof object");
michael@0:             assert_inherits(obj, member.name);
michael@0:             if (member.type == "const")
michael@0:             {
michael@0:                 assert_equals(obj[member.name], constValue(member.value));
michael@0:             }
michael@0:             if (member.type == "field")
michael@0:             {
michael@0:                 this.array.assert_type_is(obj[member.name], member.idlType);
michael@0:             }
michael@0:         }.bind(this), this.name + " exception: " + desc + ' must inherit property "' + member.name + '" with the proper type');
michael@0:     }
michael@0: };
michael@0: //@}
michael@0: 
michael@0: /// IdlInterface ///
michael@0: function IdlInterface(obj) { IdlExceptionOrInterface.call(this, obj); }
michael@0: IdlInterface.prototype = Object.create(IdlExceptionOrInterface.prototype);
michael@0: IdlInterface.prototype.is_callback = function()
michael@0: //@{
michael@0: {
michael@0:     return this.has_extended_attribute("Callback");
michael@0: };
michael@0: //@}
michael@0: 
michael@0: IdlInterface.prototype.has_constants = function()
michael@0: //@{
michael@0: {
michael@0:     return this.members.some(function(member) {
michael@0:         return member.type === "const";
michael@0:     });
michael@0: };
michael@0: //@}
michael@0: 
michael@0: IdlInterface.prototype.test_self = function()
michael@0: //@{
michael@0: {
michael@0:     test(function()
michael@0:     {
michael@0:         // This function tests WebIDL as of 2012-11-28.
michael@0: 
michael@0:         // "For every interface that:
michael@0:         // * is a callback interface that has constants declared on it, or
michael@0:         // * is a non-callback interface that is not declared with the
michael@0:         //   [NoInterfaceObject] extended attribute,
michael@0:         // a corresponding property MUST exist on the ECMAScript global object.
michael@0:         // The name of the property is the identifier of the interface, and its
michael@0:         // value is an object called the interface object.
michael@0:         // The property has the attributes { [[Writable]]: true,
michael@0:         // [[Enumerable]]: false, [[Configurable]]: true }."
michael@0:         if (this.is_callback() && !this.has_constants()) {
michael@0:             return;
michael@0:         }
michael@0: 
michael@0:         // TODO: Should we test here that the property is actually writable
michael@0:         // etc., or trust getOwnPropertyDescriptor?
michael@0:         assert_own_property(window, this.name,
michael@0:                             "window does not have own property " + format_value(this.name));
michael@0:         var desc = Object.getOwnPropertyDescriptor(window, this.name);
michael@0:         assert_false("get" in desc, "window's property " + format_value(this.name) + " has getter");
michael@0:         assert_false("set" in desc, "window's property " + format_value(this.name) + " has setter");
michael@0:         assert_true(desc.writable, "window's property " + format_value(this.name) + " is not writable");
michael@0:         assert_false(desc.enumerable, "window's property " + format_value(this.name) + " is enumerable");
michael@0:         assert_true(desc.configurable, "window's property " + format_value(this.name) + " is not configurable");
michael@0: 
michael@0:         if (this.is_callback()) {
michael@0:             // "The internal [[Prototype]] property of an interface object for
michael@0:             // a callback interface MUST be the Object.prototype object."
michael@0:             assert_equals(Object.getPrototypeOf(window[this.name]), Object.prototype,
michael@0:                           "prototype of window's property " + format_value(this.name) + " is not Object.prototype");
michael@0: 
michael@0:             return;
michael@0:         }
michael@0: 
michael@0:         // "The interface object for a given non-callback interface is a
michael@0:         // function object."
michael@0:         // "If an object is defined to be a function object, then it has
michael@0:         // characteristics as follows:"
michael@0: 
michael@0:         // "* Its [[Prototype]] internal property is the Function prototype
michael@0:         //    object."
michael@0:         assert_equals(Object.getPrototypeOf(window[this.name]), Function.prototype,
michael@0:                       "prototype of window's property " + format_value(this.name) + " is not Function.prototype");
michael@0: 
michael@0:         // "* Its [[Get]] internal property is set as described in ECMA-262
michael@0:         //    section 15.3.5.4."
michael@0:         // Not much to test for this.
michael@0: 
michael@0:         // "* Its [[Construct]] internal property is set as described in
michael@0:         //    ECMA-262 section 13.2.2."
michael@0:         // Tested below if no constructor is defined.  TODO: test constructors
michael@0:         // if defined.
michael@0: 
michael@0:         // "* Its [[HasInstance]] internal property is set as described in
michael@0:         //    ECMA-262 section 15.3.5.3, unless otherwise specified."
michael@0:         // TODO
michael@0: 
michael@0:         // "* Its [[NativeBrand]] internal property is “Function”."
michael@0:         // String() returns something implementation-dependent, because it calls
michael@0:         // Function#toString.
michael@0:         assert_class_string(window[this.name], "Function", "class string of " + this.name);
michael@0: 
michael@0:         if (!this.has_extended_attribute("Constructor")) {
michael@0:             // "The internal [[Call]] method of the interface object behaves as
michael@0:             // follows . . .
michael@0:             //
michael@0:             // "If I was not declared with a [Constructor] extended attribute,
michael@0:             // then throw a TypeError."
michael@0:             assert_throws(new TypeError(), function() {
michael@0:                 window[this.name]();
michael@0:             }.bind(this), "interface object didn't throw TypeError when called as a function");
michael@0:             assert_throws(new TypeError(), function() {
michael@0:                 new window[this.name]();
michael@0:             }.bind(this), "interface object didn't throw TypeError when called as a constructor");
michael@0:         }
michael@0:     }.bind(this), this.name + " interface: existence and properties of interface object");
michael@0: 
michael@0:     if (!this.is_callback()) {
michael@0:         test(function() {
michael@0:             // This function tests WebIDL as of 2013-08-25.
michael@0:             // http://dev.w3.org/2006/webapi/WebIDL/#es-interface-call
michael@0: 
michael@0:             assert_own_property(window, this.name,
michael@0:                                 "window does not have own property " + format_value(this.name));
michael@0: 
michael@0:             // "Interface objects for non-callback interfaces MUST have a
michael@0:             // property named “length” with attributes { [[Writable]]: false,
michael@0:             // [[Enumerable]]: false, [[Configurable]]: false } whose value is
michael@0:             // a Number."
michael@0:             assert_own_property(window[this.name], "length");
michael@0:             var desc = Object.getOwnPropertyDescriptor(window[this.name], "length");
michael@0:             assert_false("get" in desc, this.name + ".length has getter");
michael@0:             assert_false("set" in desc, this.name + ".length has setter");
michael@0:             assert_false(desc.writable, this.name + ".length is writable");
michael@0:             assert_false(desc.enumerable, this.name + ".length is enumerable");
michael@0:             assert_false(desc.configurable, this.name + ".length is configurable");
michael@0: 
michael@0:             var constructors = this.extAttrs
michael@0:                 .filter(function(attr) { return attr.name == "Constructor"; });
michael@0:             var expected_length;
michael@0:             if (!constructors.length) {
michael@0:                 // "If the [Constructor] extended attribute, does not appear on
michael@0:                 // the interface definition, then the value is 0."
michael@0:                 expected_length = 0;
michael@0:             } else {
michael@0:                 // "Otherwise, the value is determined as follows: . . .
michael@0:                 // "Return the length of the shortest argument list of the
michael@0:                 // entries in S."
michael@0:                 expected_length = constructors.map(function(attr) {
michael@0:                     return attr.arguments ? attr.arguments.filter(function(arg) {
michael@0:                         return !arg.optional;
michael@0:                     }).length : 0;
michael@0:                 })
michael@0:                 .reduce(function(m, n) { return Math.min(m, n); });
michael@0:             }
michael@0:             assert_equals(window[this.name].length, expected_length, "wrong value for " + this.name + ".length");
michael@0:         }.bind(this), this.name + " interface object length");
michael@0:     }
michael@0: 
michael@0:     // TODO: Test named constructors if I find any interfaces that have them.
michael@0: 
michael@0:     test(function()
michael@0:     {
michael@0:         assert_own_property(window, this.name,
michael@0:                             "window does not have own property " + format_value(this.name));
michael@0: 
michael@0:         if (this.has_extended_attribute("Callback")) {
michael@0:             assert_false("prototype" in window[this.name],
michael@0:                          this.name + ' should not have a "prototype" property');
michael@0:             return;
michael@0:         }
michael@0: 
michael@0:         // "The interface object must also have a property named “prototype”
michael@0:         // with attributes { [[Writable]]: false, [[Enumerable]]: false,
michael@0:         // [[Configurable]]: false } whose value is an object called the
michael@0:         // interface prototype object. This object has properties that
michael@0:         // correspond to the attributes and operations defined on the
michael@0:         // interface, and is described in more detail in section 4.5.3 below."
michael@0:         assert_own_property(window[this.name], "prototype",
michael@0:                             'interface "' + this.name + '" does not have own property "prototype"');
michael@0:         var desc = Object.getOwnPropertyDescriptor(window[this.name], "prototype");
michael@0:         assert_false("get" in desc, this.name + ".prototype has getter");
michael@0:         assert_false("set" in desc, this.name + ".prototype has setter");
michael@0:         assert_false(desc.writable, this.name + ".prototype is writable");
michael@0:         assert_false(desc.enumerable, this.name + ".prototype is enumerable");
michael@0:         assert_false(desc.configurable, this.name + ".prototype is configurable");
michael@0: 
michael@0:         // Next, test that the [[Prototype]] of the interface prototype object
michael@0:         // is correct. (This is made somewhat difficult by the existence of
michael@0:         // [NoInterfaceObject].)
michael@0:         // TODO: Aryeh thinks there's at least other place in this file where
michael@0:         //       we try to figure out if an interface prototype object is
michael@0:         //       correct. Consolidate that code.
michael@0: 
michael@0:         // "The interface prototype object for a given interface A must have an
michael@0:         // internal [[Prototype]] property whose value is as follows:
michael@0:         // "If A is not declared to inherit from another interface, then the
michael@0:         // value of the internal [[Prototype]] property of A is the Array
michael@0:         // prototype object ([ECMA-262], section 15.4.4) if the interface was
michael@0:         // declared with ArrayClass, or the Object prototype object otherwise
michael@0:         // ([ECMA-262], section 15.2.4).
michael@0:         // "Otherwise, A does inherit from another interface. The value of the
michael@0:         // internal [[Prototype]] property of A is the interface prototype
michael@0:         // object for the inherited interface."
michael@0:         var inherit_interface, inherit_interface_has_interface_object;
michael@0:         if (this.base) {
michael@0:             inherit_interface = this.base;
michael@0:             inherit_interface_has_interface_object =
michael@0:                 !this.array
michael@0:                      .members[inherit_interface]
michael@0:                      .has_extended_attribute("NoInterfaceObject");
michael@0:         } else if (this.has_extended_attribute('ArrayClass')) {
michael@0:             inherit_interface = 'Array';
michael@0:             inherit_interface_has_interface_object = true;
michael@0:         } else {
michael@0:             inherit_interface = 'Object';
michael@0:             inherit_interface_has_interface_object = true;
michael@0:         }
michael@0:         if (inherit_interface_has_interface_object) {
michael@0:             assert_own_property(window, inherit_interface,
michael@0:                                 'should inherit from ' + inherit_interface + ', but window has no such property');
michael@0:             assert_own_property(window[inherit_interface], 'prototype',
michael@0:                                 'should inherit from ' + inherit_interface + ', but that object has no "prototype" property');
michael@0:             assert_equals(Object.getPrototypeOf(window[this.name].prototype),
michael@0:                           window[inherit_interface].prototype,
michael@0:                           'prototype of ' + this.name + '.prototype is not ' + inherit_interface + '.prototype');
michael@0:         } else {
michael@0:             // We can't test that we get the correct object, because this is the
michael@0:             // only way to get our hands on it. We only test that its class
michael@0:             // string, at least, is correct.
michael@0:             assert_class_string(Object.getPrototypeOf(window[this.name].prototype),
michael@0:                                 inherit_interface + 'Prototype',
michael@0:                                 'Class name for prototype of ' + this.name +
michael@0:                                 '.prototype is not "' + inherit_interface + 'Prototype"');
michael@0:         }
michael@0: 
michael@0:         // "The class string of an interface prototype object is the
michael@0:         // concatenation of the interface’s identifier and the string
michael@0:         // “Prototype”."
michael@0:         assert_class_string(window[this.name].prototype, this.name + "Prototype",
michael@0:                             "class string of " + this.name + ".prototype");
michael@0:         // String() should end up calling {}.toString if nothing defines a
michael@0:         // stringifier.
michael@0:         if (!this.has_stringifier()) {
michael@0:             assert_equals(String(window[this.name].prototype), "[object " + this.name + "Prototype]",
michael@0:                     "String(" + this.name + ".prototype)");
michael@0:         }
michael@0:     }.bind(this), this.name + " interface: existence and properties of interface prototype object");
michael@0: 
michael@0:     test(function()
michael@0:     {
michael@0:         assert_own_property(window, this.name,
michael@0:                             "window does not have own property " + format_value(this.name));
michael@0: 
michael@0:         if (this.has_extended_attribute("Callback")) {
michael@0:             assert_false("prototype" in window[this.name],
michael@0:                          this.name + ' should not have a "prototype" property');
michael@0:             return;
michael@0:         }
michael@0: 
michael@0:         assert_own_property(window[this.name], "prototype",
michael@0:                             'interface "' + this.name + '" does not have own property "prototype"');
michael@0: 
michael@0:         // "If the [NoInterfaceObject] extended attribute was not specified on
michael@0:         // the interface, then the interface prototype object must also have a
michael@0:         // property named “constructor” with attributes { [[Writable]]: true,
michael@0:         // [[Enumerable]]: false, [[Configurable]]: true } whose value is a
michael@0:         // reference to the interface object for the interface."
michael@0:         assert_own_property(window[this.name].prototype, "constructor",
michael@0:                             this.name + '.prototype does not have own property "constructor"');
michael@0:         var desc = Object.getOwnPropertyDescriptor(window[this.name].prototype, "constructor");
michael@0:         assert_false("get" in desc, this.name + ".prototype.constructor has getter");
michael@0:         assert_false("set" in desc, this.name + ".prototype.constructor has setter");
michael@0:         assert_true(desc.writable, this.name + ".prototype.constructor is not writable");
michael@0:         assert_false(desc.enumerable, this.name + ".prototype.constructor is enumerable");
michael@0:         assert_true(desc.configurable, this.name + ".prototype.constructor in not configurable");
michael@0:         assert_equals(window[this.name].prototype.constructor, window[this.name],
michael@0:                       this.name + '.prototype.constructor is not the same object as ' + this.name);
michael@0:     }.bind(this), this.name + ' interface: existence and properties of interface prototype object\'s "constructor" property');
michael@0: };
michael@0: 
michael@0: //@}
michael@0: IdlInterface.prototype.test_members = function()
michael@0: //@{
michael@0: {
michael@0:     for (var i = 0; i < this.members.length; i++)
michael@0:     {
michael@0:         var member = this.members[i];
michael@0:         if (member.untested)
michael@0:         {
michael@0:             continue;
michael@0:         }
michael@0:         if (member.type == "const")
michael@0:         {
michael@0:             test(function()
michael@0:             {
michael@0:                 assert_own_property(window, this.name,
michael@0:                                     "window does not have own property " + format_value(this.name));
michael@0: 
michael@0:                 // "For each constant defined on an interface A, there must be
michael@0:                 // a corresponding property on the interface object, if it
michael@0:                 // exists."
michael@0:                 assert_own_property(window[this.name], member.name);
michael@0:                 // "The value of the property is that which is obtained by
michael@0:                 // converting the constant’s IDL value to an ECMAScript
michael@0:                 // value."
michael@0:                 assert_equals(window[this.name][member.name], constValue(member.value),
michael@0:                               "property has wrong value");
michael@0:                 // "The property has attributes { [[Writable]]: false,
michael@0:                 // [[Enumerable]]: true, [[Configurable]]: false }."
michael@0:                 var desc = Object.getOwnPropertyDescriptor(window[this.name], member.name);
michael@0:                 assert_false("get" in desc, "property has getter");
michael@0:                 assert_false("set" in desc, "property has setter");
michael@0:                 assert_false(desc.writable, "property is writable");
michael@0:                 assert_true(desc.enumerable, "property is not enumerable");
michael@0:                 assert_false(desc.configurable, "property is configurable");
michael@0:             }.bind(this), this.name + " interface: constant " + member.name + " on interface object");
michael@0:             // "In addition, a property with the same characteristics must
michael@0:             // exist on the interface prototype object."
michael@0:             test(function()
michael@0:             {
michael@0:                 assert_own_property(window, this.name,
michael@0:                                     "window does not have own property " + format_value(this.name));
michael@0: 
michael@0:                 if (this.has_extended_attribute("Callback")) {
michael@0:                     assert_false("prototype" in window[this.name],
michael@0:                                  this.name + ' should not have a "prototype" property');
michael@0:                     return;
michael@0:                 }
michael@0: 
michael@0:                 assert_own_property(window[this.name], "prototype",
michael@0:                                     'interface "' + this.name + '" does not have own property "prototype"');
michael@0: 
michael@0:                 assert_own_property(window[this.name].prototype, member.name);
michael@0:                 assert_equals(window[this.name].prototype[member.name], constValue(member.value),
michael@0:                               "property has wrong value");
michael@0:                 var desc = Object.getOwnPropertyDescriptor(window[this.name], member.name);
michael@0:                 assert_false("get" in desc, "property has getter");
michael@0:                 assert_false("set" in desc, "property has setter");
michael@0:                 assert_false(desc.writable, "property is writable");
michael@0:                 assert_true(desc.enumerable, "property is not enumerable");
michael@0:                 assert_false(desc.configurable, "property is configurable");
michael@0:             }.bind(this), this.name + " interface: constant " + member.name + " on interface prototype object");
michael@0:         }
michael@0:         else if (member.type == "attribute")
michael@0:         {
michael@0:             if (member.has_extended_attribute("Unforgeable"))
michael@0:             {
michael@0:                 // We do the checks in test_interface_of instead
michael@0:                 continue;
michael@0:             }
michael@0:             test(function()
michael@0:             {
michael@0:                 assert_own_property(window, this.name,
michael@0:                                     "window does not have own property " + format_value(this.name));
michael@0:                 assert_own_property(window[this.name], "prototype",
michael@0:                                     'interface "' + this.name + '" does not have own property "prototype"');
michael@0: 
michael@0:                 if (member["static"]) {
michael@0:                     assert_own_property(window[this.name], member.name,
michael@0:                         "The interface object must have a property " +
michael@0:                         format_value(member.name));
michael@0:                 }
michael@0:                 else
michael@0:                 {
michael@0:                     assert_true(member.name in window[this.name].prototype,
michael@0:                         "The prototype object must have a property " +
michael@0:                         format_value(member.name));
michael@0: 
michael@0:                     // TODO: Needs to test for LenientThis.
michael@0:                     assert_throws(new TypeError(), function() {
michael@0:                         window[this.name].prototype[member.name];
michael@0:                     }.bind(this), "getting property on prototype object must throw TypeError");
michael@0:                     do_interface_attribute_asserts(window[this.name].prototype, member);
michael@0:                 }
michael@0:             }.bind(this), this.name + " interface: attribute " + member.name);
michael@0:         }
michael@0:         else if (member.type == "operation")
michael@0:         {
michael@0:             // TODO: Need to correctly handle multiple operations with the same
michael@0:             // identifier.
michael@0:             if (!member.name)
michael@0:             {
michael@0:                 // Unnamed getter or such
michael@0:                 continue;
michael@0:             }
michael@0:             test(function()
michael@0:             {
michael@0:                 assert_own_property(window, this.name,
michael@0:                                     "window does not have own property " + format_value(this.name));
michael@0: 
michael@0:                 if (this.has_extended_attribute("Callback")) {
michael@0:                     assert_false("prototype" in window[this.name],
michael@0:                                  this.name + ' should not have a "prototype" property');
michael@0:                     return;
michael@0:                 }
michael@0: 
michael@0:                 assert_own_property(window[this.name], "prototype",
michael@0:                                     'interface "' + this.name + '" does not have own property "prototype"');
michael@0: 
michael@0:                 // "For each unique identifier of an operation defined on the
michael@0:                 // interface, there must be a corresponding property on the
michael@0:                 // interface prototype object (if it is a regular operation) or
michael@0:                 // the interface object (if it is a static operation), unless
michael@0:                 // the effective overload set for that identifier and operation
michael@0:                 // and with an argument count of 0 (for the ECMAScript language
michael@0:                 // binding) has no entries."
michael@0:                 //
michael@0:                 var prototypeOrInterfaceObject;
michael@0:                 if (member["static"]) {
michael@0:                     assert_own_property(window[this.name], member.name,
michael@0:                             "interface prototype object missing static operation");
michael@0:                     prototypeOrInterfaceObject = window[this.name];
michael@0:                 }
michael@0:                 else
michael@0:                 {
michael@0:                     assert_own_property(window[this.name].prototype, member.name,
michael@0:                             "interface prototype object missing non-static operation");
michael@0:                     prototypeOrInterfaceObject = window[this.name].prototype;
michael@0:                 }
michael@0: 
michael@0:                 var desc = Object.getOwnPropertyDescriptor(prototypeOrInterfaceObject, member.name);
michael@0:                 // "The property has attributes { [[Writable]]: true,
michael@0:                 // [[Enumerable]]: true, [[Configurable]]: true }."
michael@0:                 assert_false("get" in desc, "property has getter");
michael@0:                 assert_false("set" in desc, "property has setter");
michael@0:                 assert_true(desc.writable, "property is not writable");
michael@0:                 assert_true(desc.enumerable, "property is not enumerable");
michael@0:                 assert_true(desc.configurable, "property is not configurable");
michael@0:                 // "The value of the property is a Function object whose
michael@0:                 // behavior is as follows . . ."
michael@0:                 assert_equals(typeof prototypeOrInterfaceObject[member.name], "function",
michael@0:                               "property must be a function");
michael@0:                 // "The value of the Function object’s “length” property is
michael@0:                 // a Number determined as follows:
michael@0:                 // ". . .
michael@0:                 // "Return the length of the shortest argument list of the
michael@0:                 // entries in S."
michael@0:                 //
michael@0:                 // TODO: Doesn't handle overloading or variadic arguments.
michael@0:                 assert_equals(prototypeOrInterfaceObject[member.name].length,
michael@0:                     member.arguments.filter(function(arg) {
michael@0:                         return !arg.optional;
michael@0:                     }).length,
michael@0:                     "property has wrong .length");
michael@0: 
michael@0:                 // Make some suitable arguments
michael@0:                 var args = member.arguments.map(function(arg) {
michael@0:                     return create_suitable_object(arg.idlType);
michael@0:                 });
michael@0: 
michael@0:                 // "Let O be a value determined as follows:
michael@0:                 // ". . .
michael@0:                 // "Otherwise, throw a TypeError."
michael@0:                 // This should be hit if the operation is not static, there is
michael@0:                 // no [ImplicitThis] attribute, and the this value is null.
michael@0:                 //
michael@0:                 // TODO: We currently ignore the [ImplicitThis] case.
michael@0:                 if (!member["static"]) {
michael@0:                     assert_throws(new TypeError(), function() {
michael@0:                         window[this.name].prototype[member.name].apply(null, args);
michael@0:                     }, "calling operation with this = null didn't throw TypeError");
michael@0:                 }
michael@0: 
michael@0:                 // ". . . If O is not null and is also not a platform object
michael@0:                 // that implements interface I, throw a TypeError."
michael@0:                 //
michael@0:                 // TODO: Test a platform object that implements some other
michael@0:                 // interface.  (Have to be sure to get inheritance right.)
michael@0:                 assert_throws(new TypeError(), function() {
michael@0:                     window[this.name].prototype[member.name].apply({}, args);
michael@0:                 }, "calling operation with this = {} didn't throw TypeError");
michael@0:             }.bind(this), this.name + " interface: operation " + member.name +
michael@0:             "(" + member.arguments.map(function(m) { return m.idlType.idlType; }) +
michael@0:             ")");
michael@0:         }
michael@0:         // TODO: check more member types, like stringifier
michael@0:     }
michael@0: };
michael@0: 
michael@0: //@}
michael@0: IdlInterface.prototype.test_object = function(desc)
michael@0: //@{
michael@0: {
michael@0:     var obj, exception = null;
michael@0:     try
michael@0:     {
michael@0:         obj = eval(desc);
michael@0:     }
michael@0:     catch(e)
michael@0:     {
michael@0:         exception = e;
michael@0:     }
michael@0: 
michael@0:     // TODO: WebIDLParser doesn't currently support named legacycallers, so I'm
michael@0:     // not sure what those would look like in the AST
michael@0:     var expected_typeof = this.members.some(function(member)
michael@0:     {
michael@0:         return member.legacycaller
michael@0:             || ("idlType" in member && member.idlType.legacycaller)
michael@0:             || ("idlType" in member && typeof member.idlType == "object"
michael@0:             && "idlType" in member.idlType && member.idlType.idlType == "legacycaller");
michael@0:     }) ? "function" : "object";
michael@0: 
michael@0:     this.test_primary_interface_of(desc, obj, exception, expected_typeof);
michael@0:     var current_interface = this;
michael@0:     while (current_interface)
michael@0:     {
michael@0:         if (!(current_interface.name in this.array.members))
michael@0:         {
michael@0:             throw "Interface " + current_interface.name + " not found (inherited by " + this.name + ")";
michael@0:         }
michael@0:         if (current_interface.prevent_multiple_testing && current_interface.already_tested)
michael@0:         {
michael@0:             return;
michael@0:         }
michael@0:         current_interface.test_interface_of(desc, obj, exception, expected_typeof);
michael@0:         current_interface = this.array.members[current_interface.base];
michael@0:     }
michael@0: };
michael@0: 
michael@0: //@}
michael@0: IdlInterface.prototype.test_primary_interface_of = function(desc, obj, exception, expected_typeof)
michael@0: //@{
michael@0: {
michael@0:     // We can't easily test that its prototype is correct if there's no
michael@0:     // interface object, or the object is from a different global environment
michael@0:     // (not instanceof Object).  TODO: test in this case that its prototype at
michael@0:     // least looks correct, even if we can't test that it's actually correct.
michael@0:     if (!this.has_extended_attribute("NoInterfaceObject")
michael@0:     && (typeof obj != expected_typeof || obj instanceof Object))
michael@0:     {
michael@0:         test(function()
michael@0:         {
michael@0:             assert_equals(exception, null, "Unexpected exception when evaluating object");
michael@0:             assert_equals(typeof obj, expected_typeof, "wrong typeof object");
michael@0:             assert_own_property(window, this.name,
michael@0:                                 "window does not have own property " + format_value(this.name));
michael@0:             assert_own_property(window[this.name], "prototype",
michael@0:                                 'interface "' + this.name + '" does not have own property "prototype"');
michael@0: 
michael@0:             // "The value of the internal [[Prototype]] property of the
michael@0:             // platform object is the interface prototype object of the primary
michael@0:             // interface from the platform object’s associated global
michael@0:             // environment."
michael@0:             assert_equals(Object.getPrototypeOf(obj),
michael@0:                           window[this.name].prototype,
michael@0:                           desc + "'s prototype is not " + this.name + ".prototype");
michael@0:         }.bind(this), this.name + " must be primary interface of " + desc);
michael@0:     }
michael@0: 
michael@0:     // "The class string of a platform object that implements one or more
michael@0:     // interfaces must be the identifier of the primary interface of the
michael@0:     // platform object."
michael@0:     test(function()
michael@0:     {
michael@0:         assert_equals(exception, null, "Unexpected exception when evaluating object");
michael@0:         assert_equals(typeof obj, expected_typeof, "wrong typeof object");
michael@0:         assert_class_string(obj, this.name, "class string of " + desc);
michael@0:         if (!this.has_stringifier())
michael@0:         {
michael@0:             assert_equals(String(obj), "[object " + this.name + "]", "String(" + desc + ")");
michael@0:         }
michael@0:     }.bind(this), "Stringification of " + desc);
michael@0: };
michael@0: 
michael@0: //@}
michael@0: IdlInterface.prototype.test_interface_of = function(desc, obj, exception, expected_typeof)
michael@0: //@{
michael@0: {
michael@0:     // TODO: Indexed and named properties, more checks on interface members
michael@0:     this.already_tested = true;
michael@0: 
michael@0:     for (var i = 0; i < this.members.length; i++)
michael@0:     {
michael@0:         var member = this.members[i];
michael@0:         if (member.has_extended_attribute("Unforgeable"))
michael@0:         {
michael@0:             test(function()
michael@0:             {
michael@0:                 assert_equals(exception, null, "Unexpected exception when evaluating object");
michael@0:                 assert_equals(typeof obj, expected_typeof, "wrong typeof object");
michael@0:                 do_interface_attribute_asserts(obj, member);
michael@0:             }.bind(this), this.name + " interface: " + desc + ' must have own property "' + member.name + '"');
michael@0:         }
michael@0:         else if ((member.type == "const"
michael@0:         || member.type == "attribute"
michael@0:         || member.type == "operation")
michael@0:         && member.name)
michael@0:         {
michael@0:             test(function()
michael@0:             {
michael@0:                 assert_equals(exception, null, "Unexpected exception when evaluating object");
michael@0:                 assert_equals(typeof obj, expected_typeof, "wrong typeof object");
michael@0:                 if (!member["static"]) {
michael@0:                     assert_inherits(obj, member.name);
michael@0:                     if (member.type == "const")
michael@0:                     {
michael@0:                         assert_equals(obj[member.name], constValue(member.value));
michael@0:                     }
michael@0:                     if (member.type == "attribute")
michael@0:                     {
michael@0:                         // Attributes are accessor properties, so they might
michael@0:                         // legitimately throw an exception rather than returning
michael@0:                         // anything.
michael@0:                         var property, thrown = false;
michael@0:                         try
michael@0:                         {
michael@0:                             property = obj[member.name];
michael@0:                         }
michael@0:                         catch (e)
michael@0:                         {
michael@0:                             thrown = true;
michael@0:                         }
michael@0:                         if (!thrown)
michael@0:                         {
michael@0:                             this.array.assert_type_is(property, member.idlType);
michael@0:                         }
michael@0:                     }
michael@0:                     if (member.type == "operation")
michael@0:                     {
michael@0:                         assert_equals(typeof obj[member.name], "function");
michael@0:                     }
michael@0:                 }
michael@0:             }.bind(this), this.name + " interface: " + desc + ' must inherit property "' + member.name + '" with the proper type (' + i + ')');
michael@0:         }
michael@0:         // TODO: This is wrong if there are multiple operations with the same
michael@0:         // identifier.
michael@0:         // TODO: Test passing arguments of the wrong type.
michael@0:         if (member.type == "operation" && member.name && member.arguments.length)
michael@0:         {
michael@0:             test(function()
michael@0:             {
michael@0:                 assert_equals(exception, null, "Unexpected exception when evaluating object");
michael@0:                 assert_equals(typeof obj, expected_typeof, "wrong typeof object");
michael@0:                 if (!member["static"]) {
michael@0:                     assert_inherits(obj, member.name);
michael@0:                 }
michael@0:                 else
michael@0:                 {
michael@0:                     assert_false(member.name in obj);
michael@0:                 }
michael@0:                 var args = [];
michael@0:                 for (var i = 0; i < member.arguments.length; i++)
michael@0:                 {
michael@0:                     if (member.arguments[i].optional)
michael@0:                     {
michael@0:                         break;
michael@0:                     }
michael@0:                     assert_throws(new TypeError(), function()
michael@0:                     {
michael@0:                         obj[member.name].apply(obj, args);
michael@0:                     }.bind(this), "Called with " + i + " arguments");
michael@0: 
michael@0:                     args.push(create_suitable_object(member.arguments[i].idlType));
michael@0:                 }
michael@0:             }.bind(this), this.name + " interface: calling " + member.name +
michael@0:             "(" + member.arguments.map(function(m) { return m.idlType.idlType; }) +
michael@0:             ") on " + desc + " with too few arguments must throw TypeError");
michael@0:         }
michael@0:     }
michael@0: };
michael@0: 
michael@0: //@}
michael@0: IdlInterface.prototype.has_stringifier = function()
michael@0: //@{
michael@0: {
michael@0:     if (this.members.some(function(member) { return member.stringifier; })) {
michael@0:         return true;
michael@0:     }
michael@0:     if (this.base &&
michael@0:         this.array.members[this.base].has_stringifier()) {
michael@0:         return true;
michael@0:     }
michael@0:     return false;
michael@0: };
michael@0: 
michael@0: //@}
michael@0: function do_interface_attribute_asserts(obj, member)
michael@0: //@{
michael@0: {
michael@0:     // "For each attribute defined on the interface, there must exist a
michael@0:     // corresponding property. If the attribute was declared with the
michael@0:     // [Unforgeable] extended attribute, then the property exists on every
michael@0:     // object that implements the interface.  Otherwise, it exists on the
michael@0:     // interface’s interface prototype object."
michael@0:     //
michael@0:     // This is called by test_self() with the prototype as obj, and by
michael@0:     // test_interface_of() with the object as obj.
michael@0:     assert_own_property(obj, member.name);
michael@0: 
michael@0:     // "The property has attributes { [[Get]]: G, [[Set]]: S, [[Enumerable]]:
michael@0:     // true, [[Configurable]]: configurable }, where:
michael@0:     // "configurable is false if the attribute was declared with the
michael@0:     // [Unforgeable] extended attribute and true otherwise;
michael@0:     // "G is the attribute getter, defined below; and
michael@0:     // "S is the attribute setter, also defined below."
michael@0:     var desc = Object.getOwnPropertyDescriptor(obj, member.name);
michael@0:     assert_false("value" in desc, 'property descriptor has value but is supposed to be accessor');
michael@0:     assert_false("writable" in desc, 'property descriptor has "writable" field but is supposed to be accessor');
michael@0:     assert_true(desc.enumerable, "property is not enumerable");
michael@0:     if (member.has_extended_attribute("Unforgeable"))
michael@0:     {
michael@0:         assert_false(desc.configurable, "[Unforgeable] property must not be configurable");
michael@0:     }
michael@0:     else
michael@0:     {
michael@0:         assert_true(desc.configurable, "property must be configurable");
michael@0:     }
michael@0: 
michael@0:     // "The attribute getter is a Function object whose behavior when invoked
michael@0:     // is as follows:
michael@0:     // "...
michael@0:     // "The value of the Function object’s “length” property is the Number
michael@0:     // value 0."
michael@0:     assert_equals(typeof desc.get, "function", "getter must be Function");
michael@0:     assert_equals(desc.get.length, 0, "getter length must be 0");
michael@0:     // TODO: Account for LenientThis
michael@0:     assert_throws(new TypeError(), function()
michael@0:     {
michael@0:         desc.get.call({});
michael@0:     }.bind(this), "calling getter on wrong object type must throw TypeError");
michael@0: 
michael@0:     // TODO: Test calling setter on the interface prototype (should throw
michael@0:     // TypeError in most cases).
michael@0:     //
michael@0:     // "The attribute setter is undefined if the attribute is declared readonly
michael@0:     // and has neither a [PutForwards] nor a [Replaceable] extended attribute
michael@0:     // declared on it.  Otherwise, it is a Function object whose behavior when
michael@0:     // invoked is as follows:
michael@0:     // "...
michael@0:     // "The value of the Function object’s “length” property is the Number
michael@0:     // value 1."
michael@0:     if (member.readonly
michael@0:     && !member.has_extended_attribute("PutForwards")
michael@0:     && !member.has_extended_attribute("Replaceable"))
michael@0:     {
michael@0:         assert_equals(desc.set, undefined, "setter must be undefined for readonly attributes");
michael@0:     }
michael@0:     else
michael@0:     {
michael@0:         assert_equals(typeof desc.set, "function", "setter must be function for PutForwards, Replaceable, or non-readonly attributes");
michael@0:         assert_equals(desc.set.length, 1, "setter length must be 1");
michael@0:     }
michael@0: }
michael@0: //@}
michael@0: 
michael@0: /// IdlInterfaceMember ///
michael@0: function IdlInterfaceMember(obj)
michael@0: //@{
michael@0: {
michael@0:     /**
michael@0:      * obj is an object produced by the WebIDLParser.js "ifMember" production.
michael@0:      * We just forward all properties to this object without modification,
michael@0:      * except for special extAttrs handling.
michael@0:      */
michael@0:     for (var k in obj)
michael@0:     {
michael@0:         this[k] = obj[k];
michael@0:     }
michael@0:     if (!("extAttrs" in this))
michael@0:     {
michael@0:         this.extAttrs = [];
michael@0:     }
michael@0: }
michael@0: 
michael@0: //@}
michael@0: IdlInterfaceMember.prototype = Object.create(IdlObject.prototype);
michael@0: 
michael@0: /// Internal helper functions ///
michael@0: function create_suitable_object(type)
michael@0: //@{
michael@0: {
michael@0:     /**
michael@0:      * type is an object produced by the WebIDLParser.js "type" production.  We
michael@0:      * return a JavaScript value that matches the type, if we can figure out
michael@0:      * how.
michael@0:      */
michael@0:     if (type.nullable)
michael@0:     {
michael@0:         return null;
michael@0:     }
michael@0:     switch (type.idlType)
michael@0:     {
michael@0:         case "any":
michael@0:         case "boolean":
michael@0:             return true;
michael@0: 
michael@0:         case "byte": case "octet": case "short": case "unsigned short":
michael@0:         case "long": case "unsigned long": case "long long":
michael@0:         case "unsigned long long": case "float": case "double":
michael@0:         case "unrestricted float": case "unrestricted double":
michael@0:             return 7;
michael@0: 
michael@0:         case "DOMString":
michael@0:             return "foo";
michael@0: 
michael@0:         case "object":
michael@0:             return {a: "b"};
michael@0: 
michael@0:         case "Node":
michael@0:             return document.createTextNode("abc");
michael@0:     }
michael@0:     return null;
michael@0: }
michael@0: //@}
michael@0: 
michael@0: /// IdlEnum ///
michael@0: // Used for IdlArray.prototype.assert_type_is
michael@0: function IdlEnum(obj)
michael@0: //@{
michael@0: {
michael@0:     /**
michael@0:      * obj is an object produced by the WebIDLParser.js "dictionary"
michael@0:      * production.
michael@0:      */
michael@0: 
michael@0:     /** Self-explanatory. */
michael@0:     this.name = obj.name;
michael@0: 
michael@0:     /** An array of values produced by the "enum" production. */
michael@0:     this.values = obj.values;
michael@0: 
michael@0: }
michael@0: //@}
michael@0: 
michael@0: IdlEnum.prototype = Object.create(IdlObject.prototype);
michael@0: 
michael@0: /// IdlTypedef ///
michael@0: // Used for IdlArray.prototype.assert_type_is
michael@0: function IdlTypedef(obj)
michael@0: //@{
michael@0: {
michael@0:     /**
michael@0:      * obj is an object produced by the WebIDLParser.js "typedef"
michael@0:      * production.
michael@0:      */
michael@0: 
michael@0:     /** Self-explanatory. */
michael@0:     this.name = obj.name;
michael@0: 
michael@0:     /** An array of values produced by the "typedef" production. */
michael@0:     this.values = obj.values;
michael@0: 
michael@0: }
michael@0: //@}
michael@0: 
michael@0: IdlTypedef.prototype = Object.create(IdlObject.prototype);
michael@0: 
michael@0: }());
michael@0: // vim: set expandtab shiftwidth=4 tabstop=4 foldmarker=@{,@} foldmethod=marker: