The Tor Browser / file revision

 /*

 Distributed under both the W3C Test Suite License [1] and the W3C

 3-clause BSD License [2]. To contribute to a W3C Test Suite, see the

 policies and contribution forms [3].

 [1] http://www.w3.org/Consortium/Legal/2008/04-testsuite-license

 [2] http://www.w3.org/Consortium/Legal/2008/03-bsd-license

 [3] http://www.w3.org/2004/10/27-testcases

 */

 /*

  * This file automatically generates browser tests for WebIDL interfaces, using

  * the testharness.js framework.  To use, first include the following:

  *

  *   <script src=/resources/testharness.js></script>

  *   <script src=/resources/testharnessreport.js></script>

  *   <script src=/resources/WebIDLParser.js></script>

  *   <script src=/resources/idlharness.js></script>

  *

  * Then you'll need some type of IDLs.  Here's some script that can be run on a

  * spec written in HTML, which will grab all the elements with class="idl",

  * concatenate them, and replace the body so you can copy-paste:

  *

      var s = "";

      [].forEach.call(document.getElementsByClassName("idl"), function(idl) {

        //https://www.w3.org/Bugs/Public/show_bug.cgi?id=14914

        if (!idl.classList.contains("extract"))

        {

          s += idl.textContent + "\n\n";

        }

      });

      document.body.innerHTML = '<pre></pre>';

      document.body.firstChild.textContent = s;

  *

  * (TODO: write this in Python or something so that it can be done from the

  * command line instead.)

  *

  * Once you have that, put it in your script somehow.  The easiest way is to

  * embed it literally in an HTML file with <script type=text/plain> or similar,

  * so that you don't have to do any escaping.  Another possibility is to put it

  * in a separate .idl file that's fetched via XHR or similar.  Sample usage:

  *

  *   var idl_array = new IdlArray();

  *   idl_array.add_untested_idls("interface Node { readonly attribute DOMString nodeName; };");

  *   idl_array.add_idls("interface Document : Node { readonly attribute DOMString URL; };");

  *   idl_array.add_objects({Document: ["document"]});

  *   idl_array.test();

  *

  * This tests that window.Document exists and meets all the requirements of

  * WebIDL.  It also tests that window.document (the result of evaluating the

  * string "document") has URL and nodeName properties that behave as they

  * should, and otherwise meets WebIDL's requirements for an object whose

  * primary interface is Document.  It does not test that window.Node exists,

  * which is what you want if the Node interface is already tested in some other

  * specification's suite and your specification only extends or refers to it.

  * Of course, each IDL string can define many different things, and calls to

  * add_objects() can register many different objects for different interfaces:

  * this is a very simple example.

  *

  * TODO: Write assert_writable, assert_enumerable, assert_configurable and

  * their inverses, and use those instead of just checking

  * getOwnPropertyDescriptor.

  *

  * == Public methods of IdlArray ==

  *

  * IdlArray objects can be obtained with new IdlArray().  Anything not

  * documented in this section should be considered an implementation detail,

  * and outside callers should not use it.

  *

  * add_idls(idl_string):

  *   Parses idl_string (throwing on parse error) and adds the results to the

  *   IdlArray.  All the definitions will be tested when you run test().  If

  *   some of the definitions refer to other definitions, those must be present

  *   too.  For instance, if idl_string says that Document inherits from Node,

  *   the Node interface must also have been provided in some call to add_idls()

  *   or add_untested_idls().

  *

  * add_untested_idls(idl_string):

  *   Like add_idls(), but the definitions will not be tested.  If an untested

  *   interface is added and then extended with a tested partial interface, the

  *   members of the partial interface will still be tested.  Also, all the

  *   members will still be tested for objects added with add_objects(), because

  *   you probably want to test that (for instance) window.document has all the

  *   properties from Node, not just Document, even if the Node interface itself

  *   is tested in a different test suite.

  *

  * add_objects(dict):

  *   dict should be an object whose keys are the names of interfaces or

  *   exceptions, and whose values are arrays of strings.  When an interface or

  *   exception is tested, every string registered for it with add_objects()

  *   will be evaluated, and tests will be run on the result to verify that it

  *   correctly implements that interface or exception.  This is the only way to

  *   test anything about [NoInterfaceObject] interfaces, and there are many

  *   tests that can't be run on any interface without an object to fiddle with.

  *

  *   The interface has to be the *primary* interface of all the objects

  *   provided.  For example, don't pass {Node: ["document"]}, but rather

  *   {Document: ["document"]}.  Assuming the Document interface was declared to

  *   inherit from Node, this will automatically test that document implements

  *   the Node interface too.

  *

  *   Warning: methods will be called on any provided objects, in a manner that

  *   WebIDL requires be safe.  For instance, if a method has mandatory

  *   arguments, the test suite will try calling it with too few arguments to

  *   see if it throws an exception.  If an implementation incorrectly runs the

  *   function instead of throwing, this might have side effects, possibly even

  *   preventing the test suite from running correctly.

  *

  * prevent_multiple_testing(name):

  *   This is a niche method for use in case you're testing many objects that

  *   implement the same interfaces, and don't want to retest the same

  *   interfaces every single time.  For instance, HTML defines many interfaces

  *   that all inherit from HTMLElement, so the HTML test suite has something

  *   like

  *     .add_objects({

  *         HTMLHtmlElement: ['document.documentElement'],

  *         HTMLHeadElement: ['document.head'],

  *         HTMLBodyElement: ['document.body'],

  *         ...

  *     })

  *   and so on for dozens of element types.  This would mean that it would

  *   retest that each and every one of those elements implements HTMLElement,

  *   Element, and Node, which would be thousands of basically redundant tests.

  *   The test suite therefore calls prevent_multiple_testing("HTMLElement").

  *   This means that once one object has been tested to implement HTMLElement

  *   and its ancestors, no other object will be.  Thus in the example code

  *   above, the harness would test that document.documentElement correctly

  *   implements HTMLHtmlElement, HTMLElement, Element, and Node; but

  *   document.head would only be tested for HTMLHeadElement, and so on for

  *   further objects.

  *

  * test():

  *   Run all tests.  This should be called after you've called all other

  *   methods to add IDLs and objects.

  */

 /**

  * Notes for people who want to edit this file (not just use it as a library):

  *

  * Most of the interesting stuff happens in the derived classes of IdlObject,

  * especially IdlInterface.  The entry point for all IdlObjects is .test(),

  * which is called by IdlArray.test().  An IdlObject is conceptually just

  * "thing we want to run tests on", and an IdlArray is an array of IdlObjects

  * with some additional data thrown in.

  *

  * The object model is based on what WebIDLParser.js produces, which is in turn

  * based on its pegjs grammar.  If you want to figure out what properties an

  * object will have from WebIDLParser.js, the best way is to look at the

  * grammar:

  *

  *   https://github.com/darobin/webidl.js/blob/master/lib/grammar.peg

  *

  * So for instance:

  *

  *   // interface definition

  *   interface

  *       =   extAttrs:extendedAttributeList? S? "interface" S name:identifier w herit:ifInheritance? w "{" w mem:ifMember* w "}" w ";" w

  *           { return { type: "interface", name: name, inheritance: herit, members: mem, extAttrs: extAttrs }; }

  *

  * This means that an "interface" object will have a .type property equal to

  * the string "interface", a .name property equal to the identifier that the

  * parser found, an .inheritance property equal to either null or the result of

  * the "ifInheritance" production found elsewhere in the grammar, and so on.

  * After each grammatical production is a JavaScript function in curly braces

  * that gets called with suitable arguments and returns some JavaScript value.

  *

  * (Note that the version of WebIDLParser.js we use might sometimes be

  * out-of-date or forked.)

  *

  * The members and methods of the classes defined by this file are all at least

  * briefly documented, hopefully.

  */

 (function(){

 "use strict";

 /// Helpers ///

 function constValue (cnt) {

     if (cnt.type === "null") return null;

     if (cnt.type === "NaN") return NaN;

     if (cnt.type === "Infinity") return cnt.negative ? -Infinity : Infinity;

     return cnt.value;

 }

 /// IdlArray ///

 // Entry point

 window.IdlArray = function()

 //@{

 {

     /**

      * A map from strings to the corresponding named IdlObject, such as

      * IdlInterface or IdlException.  These are the things that test() will run

      * tests on.

      */

     this.members = {};

     /**

      * A map from strings to arrays of strings.  The keys are interface or

      * exception names, and are expected to also exist as keys in this.members

      * (otherwise they'll be ignored).  This is populated by add_objects() --

      * see documentation at the start of the file.  The actual tests will be

      * run by calling this.members[name].test_object(obj) for each obj in

      * this.objects[name].  obj is a string that will be eval'd to produce a

      * JavaScript value, which is supposed to be an object implementing the

      * given IdlObject (interface, exception, etc.).

      */

     this.objects = {};

     /**

      * When adding multiple collections of IDLs one at a time, an earlier one

      * might contain a partial interface or implements statement that depends

      * on a later one.  Save these up and handle them right before we run

      * tests.

      *

      * .partials is simply an array of objects from WebIDLParser.js'

      * "partialinterface" production.  .implements maps strings to arrays of

      * strings, such that

      *

      *   A implements B;

      *   A implements C;

      *   D implements E;

      *

      * results in { A: ["B", "C"], D: ["E"] }.

      */

     this.partials = [];

     this["implements"] = {};

 };

 //@}

 IdlArray.prototype.add_idls = function(raw_idls)

 //@{

 {

     /** Entry point.  See documentation at beginning of file. */

     this.internal_add_idls(WebIDL2.parse(raw_idls));

 };

 //@}

 IdlArray.prototype.add_untested_idls = function(raw_idls)

 //@{

 {

     /** Entry point.  See documentation at beginning of file. */

     var parsed_idls = WebIDL2.parse(raw_idls);

     for (var i = 0; i < parsed_idls.length; i++)

     {

         parsed_idls[i].untested = true;

         if ("members" in parsed_idls[i])

         {

             for (var j = 0; j < parsed_idls[i].members.length; j++)

             {

                 parsed_idls[i].members[j].untested = true;

             }

         }

     }

     this.internal_add_idls(parsed_idls);

 };

 //@}

 IdlArray.prototype.internal_add_idls = function(parsed_idls)

 //@{

 {

     /**

      * Internal helper called by add_idls() and add_untested_idls().

      * parsed_idls is an array of objects that come from WebIDLParser.js's

      * "definitions" production.  The add_untested_idls() entry point

      * additionally sets an .untested property on each object (and its

      * .members) so that they'll be skipped by test() -- they'll only be

      * used for base interfaces of tested interfaces, return types, etc.

      */

     parsed_idls.forEach(function(parsed_idl)

     {

         if (parsed_idl.type == "interface" && parsed_idl.partial)

         {

             this.partials.push(parsed_idl);

             return;

         }

         if (parsed_idl.type == "implements")

         {

             if (!(parsed_idl.target in this["implements"]))

             {

                 this["implements"][parsed_idl.target] = [];

             }

             this["implements"][parsed_idl.target].push(parsed_idl["implements"]);

             return;

         }

         parsed_idl.array = this;

         if (parsed_idl.name in this.members)

         {

             throw "Duplicate identifier " + parsed_idl.name;

         }

         switch(parsed_idl.type)

         {

         case "interface":

             this.members[parsed_idl.name] = new IdlInterface(parsed_idl);

             break;

         case "exception":

             this.members[parsed_idl.name] = new IdlException(parsed_idl);

             break;

         case "dictionary":

             // Nothing to test, but we need the dictionary info around for type

             // checks

             this.members[parsed_idl.name] = new IdlDictionary(parsed_idl);

             break;

         case "typedef":

             this.members[parsed_idl.name] = new IdlTypedef(parsed_idl);

             break;

         case "callback":

             // TODO

             console.log("callback not yet supported");

             break;

         case "enum":

             this.members[parsed_idl.name] = new IdlEnum(parsed_idl);

             break;

         case "callback interface":

             // TODO

             console.log("callback interface not yet supported");

             break;

         default:

             throw parsed_idl.name + ": " + parsed_idl.type + " not yet supported";

         }

     }.bind(this));

 };

 //@}

 IdlArray.prototype.add_objects = function(dict)

 //@{

 {

     /** Entry point.  See documentation at beginning of file. */

     for (var k in dict)

     {

         if (k in this.objects)

         {

             this.objects[k] = this.objects[k].concat(dict[k]);

         }

         else

         {

             this.objects[k] = dict[k];

         }

     }

 };

 //@}

 IdlArray.prototype.prevent_multiple_testing = function(name)

 //@{

 {

     /** Entry point.  See documentation at beginning of file. */

     this.members[name].prevent_multiple_testing = true;

 };

 //@}

 IdlArray.prototype.recursively_get_implements = function(interface_name)

 //@{

 {

     /**

      * Helper function for test().  Returns an array of things that implement

      * interface_name, so if the IDL contains

      *

      *   A implements B;

      *   B implements C;

      *   B implements D;

      *

      * then recursively_get_implements("A") should return ["B", "C", "D"].

      */

     var ret = this["implements"][interface_name];

     if (ret === undefined)

     {

         return [];

     }

     for (var i = 0; i < this["implements"][interface_name].length; i++)

     {

         ret = ret.concat(this.recursively_get_implements(ret[i]));

         if (ret.indexOf(ret[i]) != ret.lastIndexOf(ret[i]))

         {

             throw "Circular implements statements involving " + ret[i];

         }

     }

     return ret;

 };

 //@}

 IdlArray.prototype.test = function()

 //@{

 {

     /** Entry point.  See documentation at beginning of file. */

     // First merge in all the partial interfaces and implements statements we

     // encountered.

     this.partials.forEach(function(parsed_idl)

     {

         if (!(parsed_idl.name in this.members)

         || !(this.members[parsed_idl.name] instanceof IdlInterface))

         {

             throw "Partial interface " + parsed_idl.name + " with no original interface";

         }

         if (parsed_idl.extAttrs)

         {

             parsed_idl.extAttrs.forEach(function(extAttr)

             {

                 this.members[parsed_idl.name].extAttrs.push(extAttr);

             }.bind(this));

         }

         parsed_idl.members.forEach(function(member)

         {

             this.members[parsed_idl.name].members.push(new IdlInterfaceMember(member));

         }.bind(this));

     }.bind(this));

     this.partials = [];

     for (var lhs in this["implements"])

     {

         this.recursively_get_implements(lhs).forEach(function(rhs)

         {

             var errStr = lhs + " implements " + rhs + ", but ";

             if (!(lhs in this.members)) throw errStr + lhs + " is undefined.";

             if (!(this.members[lhs] instanceof IdlInterface)) throw errStr + lhs + " is not an interface.";

             if (!(rhs in this.members)) throw errStr + rhs + " is undefined.";

             if (!(this.members[rhs] instanceof IdlInterface)) throw errStr + rhs + " is not an interface.";

             this.members[rhs].members.forEach(function(member)

             {

                 this.members[lhs].members.push(new IdlInterfaceMember(member));

             }.bind(this));

         }.bind(this));

     }

     this["implements"] = {};

     // Now run test() on every member, and test_object() for every object.

     for (var name in this.members)

     {

         this.members[name].test();

         if (name in this.objects)

         {

             this.objects[name].forEach(function(str)

             {

                 this.members[name].test_object(str);

             }.bind(this));

         }

     }

 };

 //@}

 IdlArray.prototype.assert_type_is = function(value, type)

 //@{

 {

     /**

      * Helper function that tests that value is an instance of type according

      * to the rules of WebIDL.  value is any JavaScript value, and type is an

      * object produced by WebIDLParser.js' "type" production.  That production

      * is fairly elaborate due to the complexity of WebIDL's types, so it's

      * best to look at the grammar to figure out what properties it might have.

      */

     if (type.idlType == "any")

     {

         // No assertions to make

         return;

     }

     if (type.nullable && value === null)

     {

         // This is fine

         return;

     }

     if (type.array)

     {

         // TODO: not supported yet

         return;

     }

     if (type.sequence)

     {

         assert_true(Array.isArray(value), "is not array");

         if (!value.length)

         {

             // Nothing we can do.

             return;

         }

         this.assert_type_is(value[0], type.idlType.idlType);

         return;

     }

     type = type.idlType;

     switch(type)

     {

         case "void":

             assert_equals(value, undefined);

             return;

         case "boolean":

             assert_equals(typeof value, "boolean");

             return;

         case "byte":

             assert_equals(typeof value, "number");

             assert_equals(value, Math.floor(value), "not an integer");

             assert_true(-128 <= value && value <= 127, "byte " + value + " not in range [-128, 127]");

             return;

         case "octet":

             assert_equals(typeof value, "number");

             assert_equals(value, Math.floor(value), "not an integer");

             assert_true(0 <= value && value <= 255, "octet " + value + " not in range [0, 255]");

             return;

         case "short":

             assert_equals(typeof value, "number");

             assert_equals(value, Math.floor(value), "not an integer");

             assert_true(-32768 <= value && value <= 32767, "short " + value + " not in range [-32768, 32767]");

             return;

         case "unsigned short":

             assert_equals(typeof value, "number");

             assert_equals(value, Math.floor(value), "not an integer");

             assert_true(0 <= value && value <= 65535, "unsigned short " + value + " not in range [0, 65535]");

             return;

         case "long":

             assert_equals(typeof value, "number");

             assert_equals(value, Math.floor(value), "not an integer");

             assert_true(-2147483648 <= value && value <= 2147483647, "long " + value + " not in range [-2147483648, 2147483647]");

             return;

         case "unsigned long":

             assert_equals(typeof value, "number");

             assert_equals(value, Math.floor(value), "not an integer");

             assert_true(0 <= value && value <= 4294967295, "unsigned long " + value + " not in range [0, 4294967295]");

             return;

         case "long long":

             assert_equals(typeof value, "number");

             return;

         case "unsigned long long":

             assert_equals(typeof value, "number");

             assert_true(0 <= value, "unsigned long long is negative");

             return;

         case "float":

         case "double":

         case "unrestricted float":

         case "unrestricted double":

             // TODO: distinguish these cases

             assert_equals(typeof value, "number");

             return;

         case "DOMString":

             assert_equals(typeof value, "string");

             return;

         case "object":

             assert_true(typeof value == "object" || typeof value == "function", "wrong type: not object or function");

             return;

     }

     if (!(type in this.members))

     {

         throw "Unrecognized type " + type;

     }

     if (this.members[type] instanceof IdlInterface)

     {

         // We don't want to run the full

         // IdlInterface.prototype.test_instance_of, because that could result

         // in an infinite loop.  TODO: This means we don't have tests for

         // NoInterfaceObject interfaces, and we also can't test objects that

         // come from another window.

         assert_true(typeof value == "object" || typeof value == "function", "wrong type: not object or function");

         if (value instanceof Object

         && !this.members[type].has_extended_attribute("NoInterfaceObject")

         && type in window)

         {

             assert_true(value instanceof window[type], "not instanceof " + type);

         }

     }

     else if (this.members[type] instanceof IdlEnum)

     {

         assert_equals(typeof value, "string");

     }

     else if (this.members[type] instanceof IdlDictionary)

     {

         // TODO: Test when we actually have something to test this on

     }

     else if (this.members[type] instanceof IdlTypedef)

     {

         // TODO: Test when we actually have something to test this on

     }

     else

     {

         throw "Type " + type + " isn't an interface or dictionary";

     }

 };

 //@}

 /// IdlObject ///

 function IdlObject() {}

 IdlObject.prototype.test = function()

 //@{

 {

     /**

      * By default, this does nothing, so no actual tests are run for IdlObjects

      * that don't define any (e.g., IdlDictionary at the time of this writing).

      */

 };

 //@}

 IdlObject.prototype.has_extended_attribute = function(name)

 //@{

 {

     /**

      * This is only meaningful for things that support extended attributes,

      * such as interfaces, exceptions, and members.

      */

     return this.extAttrs.some(function(o)

     {

         return o.name == name;

     });

 };

 //@}

 /// IdlDictionary ///

 // Used for IdlArray.prototype.assert_type_is

 function IdlDictionary(obj)

 //@{

 {

     /**

      * obj is an object produced by the WebIDLParser.js "dictionary"

      * production.

      */

     /** Self-explanatory. */

     this.name = obj.name;

     /** An array of objects produced by the "dictionaryMember" production. */

     this.members = obj.members;

     /**

      * The name (as a string) of the dictionary type we inherit from, or null

      * if there is none.

      */

     this.base = obj.inheritance;

 }

 //@}

 IdlDictionary.prototype = Object.create(IdlObject.prototype);

 /// IdlExceptionOrInterface ///

 // Code sharing!

 function IdlExceptionOrInterface(obj)

 //@{

 {

     /**

      * obj is an object produced by the WebIDLParser.js "exception" or

      * "interface" production, as appropriate.

      */

     /** Self-explanatory. */

     this.name = obj.name;

     /** A back-reference to our IdlArray. */

     this.array = obj.array;

     /**

      * An indicator of whether we should run tests on the (exception) interface

      * object and (exception) interface prototype object.  Tests on members are

      * controlled by .untested on each member, not this.

      */

     this.untested = obj.untested;

     /** An array of objects produced by the "ExtAttr" production. */

     this.extAttrs = obj.extAttrs;

     /** An array of IdlInterfaceMembers. */

     this.members = obj.members.map(function(m){return new IdlInterfaceMember(m); });

     /**

      * The name (as a string) of the type we inherit from, or null if there is

      * none.

      */

     this.base = obj.inheritance;

 }

 //@}

 IdlExceptionOrInterface.prototype = Object.create(IdlObject.prototype);

 IdlExceptionOrInterface.prototype.test = function()

 //@{

 {

     if (this.has_extended_attribute("NoInterfaceObject"))

     {

         // No tests to do without an instance.  TODO: We should still be able

         // to run tests on the prototype object, if we obtain one through some

         // other means.

         return;

     }

     if (!this.untested)

     {

         // First test things to do with the exception/interface object and

         // exception/interface prototype object.

         this.test_self();

     }

     // Then test things to do with its members (constants, fields, attributes,

     // operations, . . .).  These are run even if .untested is true, because

     // members might themselves be marked as .untested.  This might happen to

     // interfaces if the interface itself is untested but a partial interface

     // that extends it is tested -- then the interface itself and its initial

     // members will be marked as untested, but the members added by the partial

     // interface are still tested.

     this.test_members();

 };

 //@}

 /// IdlException ///

 function IdlException(obj) { IdlExceptionOrInterface.call(this, obj); }

 IdlException.prototype = Object.create(IdlExceptionOrInterface.prototype);

 IdlException.prototype.test_self = function()

 //@{

 {

     test(function()

     {

         // "For every exception that is not declared with the

         // [NoInterfaceObject] extended attribute, a corresponding property

         // must exist on the exception’s relevant namespace object. The name of

         // the property is the identifier of the exception, and its value is an

         // object called the exception interface object, which provides access

         // to any constants that have been associated with the exception. The

         // property has the attributes { [[Writable]]: true, [[Enumerable]]:

         // false, [[Configurable]]: true }."

         assert_own_property(window, this.name,

                             "window does not have own property " + format_value(this.name));

         var desc = Object.getOwnPropertyDescriptor(window, this.name);

         assert_false("get" in desc, "window's property " + format_value(this.name) + " has getter");

         assert_false("set" in desc, "window's property " + format_value(this.name) + " has setter");

         assert_true(desc.writable, "window's property " + format_value(this.name) + " is not writable");

         assert_false(desc.enumerable, "window's property " + format_value(this.name) + " is enumerable");

         assert_true(desc.configurable, "window's property " + format_value(this.name) + " is not configurable");

         // "The exception interface object for a given exception must be a

         // function object."

         // "If an object is defined to be a function object, then it has

         // characteristics as follows:"

         // "Its [[Prototype]] internal property is the Function prototype

         // object."

         // Note: This doesn't match browsers as of December 2011, see

         // http://www.w3.org/Bugs/Public/show_bug.cgi?id=14813

         assert_equals(Object.getPrototypeOf(window[this.name]), Function.prototype,

                       "prototype of window's property " + format_value(this.name) + " is not Function.prototype");

         // "Its [[Get]] internal property is set as described in ECMA-262

         // section 15.3.5.4."

         // Not much to test for this.

         // "Its [[Construct]] internal property is set as described in ECMA-262

         // section 13.2.2."

         // Tested below.

         // "Its [[HasInstance]] internal property is set as described in

         // ECMA-262 section 15.3.5.3, unless otherwise specified."

         // TODO

         // "Its [[Class]] internal property is “Function”."

         // String() returns something implementation-dependent, because it

         // calls Function#toString.

         assert_class_string(window[this.name], "Function",

                             "class string of " + this.name);

         // TODO: Test 4.9.1.1. Exception interface object [[Call]] method

         // (which does not match browsers:

         // http://www.w3.org/Bugs/Public/show_bug.cgi?id=14885)

     }.bind(this), this.name + " exception: existence and properties of exception interface object");

     test(function()

     {

         assert_own_property(window, this.name,

                             "window does not have own property " + format_value(this.name));

         // "The exception interface object must also have a property named

         // “prototype” with attributes { [[Writable]]: false, [[Enumerable]]:

         // false, [[Configurable]]: false } whose value is an object called the

         // exception interface prototype object. This object also provides

         // access to the constants that are declared on the exception."

         assert_own_property(window[this.name], "prototype",

                             'exception "' + this.name + '" does not have own property "prototype"');

         var desc = Object.getOwnPropertyDescriptor(window[this.name], "prototype");

         assert_false("get" in desc, this.name + ".prototype has getter");

         assert_false("set" in desc, this.name + ".prototype has setter");

         assert_false(desc.writable, this.name + ".prototype is writable");

         assert_false(desc.enumerable, this.name + ".prototype is enumerable");

         assert_false(desc.configurable, this.name + ".prototype is configurable");

         // "The exception interface prototype object for a given exception must

         // have an internal [[Prototype]] property whose value is as follows:

         //

         // "If the exception is declared to inherit from another exception,

         // then the value of the internal [[Prototype]] property is the

         // exception interface prototype object for the inherited exception.

         // "Otherwise, the exception is not declared to inherit from another

         // exception. The value of the internal [[Prototype]] property is the

         // Error prototype object ([ECMA-262], section 15.11.3.1)."

         //

         // Note: This doesn't match browsers as of December 2011, see

         // https://www.w3.org/Bugs/Public/show_bug.cgi?id=14887.

         var inherit_exception = this.base ? this.base : "Error";

         assert_own_property(window, inherit_exception,

                             'should inherit from ' + inherit_exception + ', but window has no such property');

         assert_own_property(window[inherit_exception], "prototype",

                             'should inherit from ' + inherit_exception + ', but that object has no "prototype" property');

         assert_equals(Object.getPrototypeOf(window[this.name].prototype),

                       window[inherit_exception].prototype,

                       'prototype of ' + this.name + '.prototype is not ' + inherit_exception + '.prototype');

         // "The class string of an exception interface prototype object is the

         // concatenation of the exception’s identifier and the string

         // “Prototype”."

         assert_class_string(window[this.name].prototype, this.name + "Prototype",

                             "class string of " + this.name + ".prototype");

         // TODO: Test String(), based on ES definition of

         // Error.prototype.toString?

     }.bind(this), this.name + " exception: existence and properties of exception interface prototype object");

     test(function()

     {

         assert_own_property(window, this.name,

                             "window does not have own property " + format_value(this.name));

         assert_own_property(window[this.name], "prototype",

                             'interface "' + this.name + '" does not have own property "prototype"');

         // "There must be a property named “name” on the exception interface

         // prototype object with attributes { [[Writable]]: true,

         // [[Enumerable]]: false, [[Configurable]]: true } and whose value is

         // the identifier of the exception."

         assert_own_property(window[this.name].prototype, "name",

                 'prototype object does not have own property "name"');

         var desc = Object.getOwnPropertyDescriptor(window[this.name].prototype, "name");

         assert_false("get" in desc, this.name + ".prototype.name has getter");

         assert_false("set" in desc, this.name + ".prototype.name has setter");

         assert_true(desc.writable, this.name + ".prototype.name is not writable");

         assert_false(desc.enumerable, this.name + ".prototype.name is enumerable");

         assert_true(desc.configurable, this.name + ".prototype.name is not configurable");

         assert_equals(desc.value, this.name, this.name + ".prototype.name has incorrect value");

     }.bind(this), this.name + " exception: existence and properties of exception interface prototype object's \"name\" property");

     test(function()

     {

         assert_own_property(window, this.name,

                             "window does not have own property " + format_value(this.name));

         assert_own_property(window[this.name], "prototype",

                             'interface "' + this.name + '" does not have own property "prototype"');

         // "If the [NoInterfaceObject] extended attribute was not specified on

         // the exception, then there must also be a property named

         // “constructor” on the exception interface prototype object with

         // attributes { [[Writable]]: true, [[Enumerable]]: false,

         // [[Configurable]]: true } and whose value is a reference to the

         // exception interface object for the exception."

         assert_own_property(window[this.name].prototype, "constructor",

                             this.name + '.prototype does not have own property "constructor"');

         var desc = Object.getOwnPropertyDescriptor(window[this.name].prototype, "constructor");

         assert_false("get" in desc, this.name + ".prototype.constructor has getter");

         assert_false("set" in desc, this.name + ".prototype.constructor has setter");

         assert_true(desc.writable, this.name + ".prototype.constructor is not writable");

         assert_false(desc.enumerable, this.name + ".prototype.constructor is enumerable");

         assert_true(desc.configurable, this.name + ".prototype.constructor in not configurable");

         assert_equals(window[this.name].prototype.constructor, window[this.name],

                       this.name + '.prototype.constructor is not the same object as ' + this.name);

     }.bind(this), this.name + " exception: existence and properties of exception interface prototype object's \"constructor\" property");

 };

 //@}

 IdlException.prototype.test_members = function()

 //@{

 {

     for (var i = 0; i < this.members.length; i++)

     {

         var member = this.members[i];

         if (member.untested)

         {

             continue;

         }

         if (member.type == "const" && member.name != "prototype")

         {

             test(function()

             {

                 assert_own_property(window, this.name,

                                     "window does not have own property " + format_value(this.name));

                 // "For each constant defined on the exception, there must be a

                 // corresponding property on the exception interface object, if

                 // it exists, if the identifier of the constant is not

                 // “prototype”."

                 assert_own_property(window[this.name], member.name);

                 // "The value of the property is the ECMAScript value that is

                 // equivalent to the constant’s IDL value, according to the

                 // rules in section 4.2 above."

                 assert_equals(window[this.name][member.name], constValue(member.value),

                               "property has wrong value");

                 // "The property has attributes { [[Writable]]: false,

                 // [[Enumerable]]: true, [[Configurable]]: false }."

                 var desc = Object.getOwnPropertyDescriptor(window[this.name], member.name);

                 assert_false("get" in desc, "property has getter");

                 assert_false("set" in desc, "property has setter");

                 assert_false(desc.writable, "property is writable");

                 assert_true(desc.enumerable, "property is not enumerable");

                 assert_false(desc.configurable, "property is configurable");

             }.bind(this), this.name + " exception: constant " + member.name + " on exception interface object");

             // "In addition, a property with the same characteristics must

             // exist on the exception interface prototype object."

             test(function()

             {

                 assert_own_property(window, this.name,

                                     "window does not have own property " + format_value(this.name));

                 assert_own_property(window[this.name], "prototype",

                                     'exception "' + this.name + '" does not have own property "prototype"');

                 assert_own_property(window[this.name].prototype, member.name);

                 assert_equals(window[this.name].prototype[member.name], constValue(member.value),

                               "property has wrong value");

                 var desc = Object.getOwnPropertyDescriptor(window[this.name].prototype, member.name);

                 assert_false("get" in desc, "property has getter");

                 assert_false("set" in desc, "property has setter");

                 assert_false(desc.writable, "property is writable");

                 assert_true(desc.enumerable, "property is not enumerable");

                 assert_false(desc.configurable, "property is configurable");

             }.bind(this), this.name + " exception: constant " + member.name + " on exception interface prototype object");

         }

         else if (member.type == "field")

         {

             test(function()

             {

                 assert_own_property(window, this.name,

                                     "window does not have own property " + format_value(this.name));

                 assert_own_property(window[this.name], "prototype",

                                     'exception "' + this.name + '" does not have own property "prototype"');

                 // "For each exception field, there must be a corresponding

                 // property on the exception interface prototype object, whose

                 // characteristics are as follows:

                 // "The name of the property is the identifier of the exception

                 // field."

                 assert_own_property(window[this.name].prototype, member.name);

                 // "The property has attributes { [[Get]]: G, [[Enumerable]]:

                 // true, [[Configurable]]: true }, where G is the exception

                 // field getter, defined below."

                 var desc = Object.getOwnPropertyDescriptor(window[this.name].prototype, member.name);

                 assert_false("value" in desc, "property descriptor has value but is supposed to be accessor");

                 assert_false("writable" in desc, 'property descriptor has "writable" field but is supposed to be accessor');

                 // TODO: ES5 doesn't seem to say whether desc should have a

                 // .set property.

                 assert_true(desc.enumerable, "property is not enumerable");

                 assert_true(desc.configurable, "property is not configurable");

                 // "The exception field getter is a Function object whose

                 // behavior when invoked is as follows:"

                 assert_equals(typeof desc.get, "function", "typeof getter");

                 // "The value of the Function object’s “length” property is the

                 // Number value 0."

                 // This test is before the TypeError tests so that it's easiest

                 // to see that Firefox 11a1 only fails one assert in this test.

                 assert_equals(desc.get.length, 0, "getter length");

                 // "Let O be the result of calling ToObject on the this value.

                 // "If O is not a platform object representing an exception for

                 // the exception on which the exception field was declared,

                 // then throw a TypeError."

                 // TODO: Test on a platform object representing an exception.

                 assert_throws(new TypeError(), function()

                 {

                     window[this.name].prototype[member.name];

                 }.bind(this), "getting property on prototype object must throw TypeError");

                 assert_throws(new TypeError(), function()

                 {

                     desc.get.call({});

                 }.bind(this), "calling getter on wrong object type must throw TypeError");

             }.bind(this), this.name + " exception: field " + member.name + " on exception interface prototype object");

         }

     }

 };

 //@}

 IdlException.prototype.test_object = function(desc)

 //@{

 {

     var obj, exception = null;

     try

     {

         obj = eval(desc);

     }

     catch(e)

     {

         exception = e;

     }

     test(function()

     {

         assert_equals(exception, null, "Unexpected exception when evaluating object");

         assert_equals(typeof obj, "object", "wrong typeof object");

         // We can't easily test that its prototype is correct if there's no

         // interface object, or the object is from a different global

         // environment (not instanceof Object).  TODO: test in this case that

         // its prototype at least looks correct, even if we can't test that

         // it's actually correct.

         if (!this.has_extended_attribute("NoInterfaceObject")

         && (typeof obj != "object" || obj instanceof Object))

         {

             assert_own_property(window, this.name,

                                 "window does not have own property " + format_value(this.name));

             assert_own_property(window[this.name], "prototype",

                                 'exception "' + this.name + '" does not have own property "prototype"');

             // "The value of the internal [[Prototype]] property of the

             // exception object must be the exception interface prototype

             // object from the global environment the exception object is

             // associated with."

             assert_equals(Object.getPrototypeOf(obj),

                           window[this.name].prototype,

                           desc + "'s prototype is not " + this.name + ".prototype");

         }

         // "The class string of the exception object must be the identifier of

         // the exception."

         assert_class_string(obj, this.name, "class string of " + desc);

         // Stringifier is not defined for DOMExceptions, because message isn't

         // defined.

     }.bind(this), this.name + " must be represented by " + desc);

     for (var i = 0; i < this.members.length; i++)

     {

         var member = this.members[i];

         test(function()

         {

             assert_equals(exception, null, "Unexpected exception when evaluating object");

             assert_equals(typeof obj, "object", "wrong typeof object");

             assert_inherits(obj, member.name);

             if (member.type == "const")

             {

                 assert_equals(obj[member.name], constValue(member.value));

             }

             if (member.type == "field")

             {

                 this.array.assert_type_is(obj[member.name], member.idlType);

             }

         }.bind(this), this.name + " exception: " + desc + ' must inherit property "' + member.name + '" with the proper type');

     }

 };

 //@}

 /// IdlInterface ///

 function IdlInterface(obj) { IdlExceptionOrInterface.call(this, obj); }

 IdlInterface.prototype = Object.create(IdlExceptionOrInterface.prototype);

 IdlInterface.prototype.is_callback = function()

 //@{

 {

     return this.has_extended_attribute("Callback");

 };

 //@}

 IdlInterface.prototype.has_constants = function()

 //@{

 {

     return this.members.some(function(member) {

         return member.type === "const";

     });

 };

 //@}

 IdlInterface.prototype.test_self = function()

 //@{

 {

     test(function()

     {

         // This function tests WebIDL as of 2012-11-28.

         // "For every interface that:

         // * is a callback interface that has constants declared on it, or

         // * is a non-callback interface that is not declared with the

         //   [NoInterfaceObject] extended attribute,

         // a corresponding property MUST exist on the ECMAScript global object.

         // The name of the property is the identifier of the interface, and its

         // value is an object called the interface object.

         // The property has the attributes { [[Writable]]: true,

         // [[Enumerable]]: false, [[Configurable]]: true }."

         if (this.is_callback() && !this.has_constants()) {

             return;

         }

         // TODO: Should we test here that the property is actually writable

         // etc., or trust getOwnPropertyDescriptor?

         assert_own_property(window, this.name,

                             "window does not have own property " + format_value(this.name));

         var desc = Object.getOwnPropertyDescriptor(window, this.name);

         assert_false("get" in desc, "window's property " + format_value(this.name) + " has getter");

         assert_false("set" in desc, "window's property " + format_value(this.name) + " has setter");

         assert_true(desc.writable, "window's property " + format_value(this.name) + " is not writable");

         assert_false(desc.enumerable, "window's property " + format_value(this.name) + " is enumerable");

         assert_true(desc.configurable, "window's property " + format_value(this.name) + " is not configurable");

         if (this.is_callback()) {

             // "The internal [[Prototype]] property of an interface object for

             // a callback interface MUST be the Object.prototype object."

             assert_equals(Object.getPrototypeOf(window[this.name]), Object.prototype,

                           "prototype of window's property " + format_value(this.name) + " is not Object.prototype");

             return;

         }

         // "The interface object for a given non-callback interface is a

         // function object."

         // "If an object is defined to be a function object, then it has

         // characteristics as follows:"

         // "* Its [[Prototype]] internal property is the Function prototype

         //    object."

         assert_equals(Object.getPrototypeOf(window[this.name]), Function.prototype,

                       "prototype of window's property " + format_value(this.name) + " is not Function.prototype");

         // "* Its [[Get]] internal property is set as described in ECMA-262

         //    section 15.3.5.4."

         // Not much to test for this.

         // "* Its [[Construct]] internal property is set as described in

         //    ECMA-262 section 13.2.2."

         // Tested below if no constructor is defined.  TODO: test constructors

         // if defined.

         // "* Its [[HasInstance]] internal property is set as described in

         //    ECMA-262 section 15.3.5.3, unless otherwise specified."

         // TODO

         // "* Its [[NativeBrand]] internal property is “Function”."

         // String() returns something implementation-dependent, because it calls

         // Function#toString.

         assert_class_string(window[this.name], "Function", "class string of " + this.name);

         if (!this.has_extended_attribute("Constructor")) {

             // "The internal [[Call]] method of the interface object behaves as

             // follows . . .

             //

             // "If I was not declared with a [Constructor] extended attribute,

             // then throw a TypeError."

             assert_throws(new TypeError(), function() {

                 window[this.name]();

             }.bind(this), "interface object didn't throw TypeError when called as a function");

             assert_throws(new TypeError(), function() {

                 new window[this.name]();

             }.bind(this), "interface object didn't throw TypeError when called as a constructor");

         }

     }.bind(this), this.name + " interface: existence and properties of interface object");

     if (!this.is_callback()) {

         test(function() {

             // This function tests WebIDL as of 2013-08-25.

             // http://dev.w3.org/2006/webapi/WebIDL/#es-interface-call

             assert_own_property(window, this.name,

                                 "window does not have own property " + format_value(this.name));

             // "Interface objects for non-callback interfaces MUST have a

             // property named “length” with attributes { [[Writable]]: false,

             // [[Enumerable]]: false, [[Configurable]]: false } whose value is

             // a Number."

             assert_own_property(window[this.name], "length");

             var desc = Object.getOwnPropertyDescriptor(window[this.name], "length");

             assert_false("get" in desc, this.name + ".length has getter");

             assert_false("set" in desc, this.name + ".length has setter");

             assert_false(desc.writable, this.name + ".length is writable");

             assert_false(desc.enumerable, this.name + ".length is enumerable");

             assert_false(desc.configurable, this.name + ".length is configurable");

             var constructors = this.extAttrs

                 .filter(function(attr) { return attr.name == "Constructor"; });

             var expected_length;

             if (!constructors.length) {

                 // "If the [Constructor] extended attribute, does not appear on

                 // the interface definition, then the value is 0."

                 expected_length = 0;

             } else {

                 // "Otherwise, the value is determined as follows: . . .

                 // "Return the length of the shortest argument list of the

                 // entries in S."

                 expected_length = constructors.map(function(attr) {

                     return attr.arguments ? attr.arguments.filter(function(arg) {

                         return !arg.optional;

                     }).length : 0;

                 })

                 .reduce(function(m, n) { return Math.min(m, n); });

             }

             assert_equals(window[this.name].length, expected_length, "wrong value for " + this.name + ".length");

         }.bind(this), this.name + " interface object length");

     }

     // TODO: Test named constructors if I find any interfaces that have them.

     test(function()

     {

         assert_own_property(window, this.name,

                             "window does not have own property " + format_value(this.name));

         if (this.has_extended_attribute("Callback")) {

             assert_false("prototype" in window[this.name],

                          this.name + ' should not have a "prototype" property');

             return;

         }

         // "The interface object must also have a property named “prototype”

         // with attributes { [[Writable]]: false, [[Enumerable]]: false,

         // [[Configurable]]: false } whose value is an object called the

         // interface prototype object. This object has properties that

         // correspond to the attributes and operations defined on the

         // interface, and is described in more detail in section 4.5.3 below."

         assert_own_property(window[this.name], "prototype",

                             'interface "' + this.name + '" does not have own property "prototype"');

         var desc = Object.getOwnPropertyDescriptor(window[this.name], "prototype");

         assert_false("get" in desc, this.name + ".prototype has getter");

         assert_false("set" in desc, this.name + ".prototype has setter");

         assert_false(desc.writable, this.name + ".prototype is writable");

         assert_false(desc.enumerable, this.name + ".prototype is enumerable");

         assert_false(desc.configurable, this.name + ".prototype is configurable");

         // Next, test that the [[Prototype]] of the interface prototype object

         // is correct. (This is made somewhat difficult by the existence of

         // [NoInterfaceObject].)

         // TODO: Aryeh thinks there's at least other place in this file where

         //       we try to figure out if an interface prototype object is

         //       correct. Consolidate that code.

         // "The interface prototype object for a given interface A must have an

         // internal [[Prototype]] property whose value is as follows:

         // "If A is not declared to inherit from another interface, then the

         // value of the internal [[Prototype]] property of A is the Array

         // prototype object ([ECMA-262], section 15.4.4) if the interface was

         // declared with ArrayClass, or the Object prototype object otherwise

         // ([ECMA-262], section 15.2.4).

         // "Otherwise, A does inherit from another interface. The value of the

         // internal [[Prototype]] property of A is the interface prototype

         // object for the inherited interface."

         var inherit_interface, inherit_interface_has_interface_object;

         if (this.base) {

             inherit_interface = this.base;

             inherit_interface_has_interface_object =

                 !this.array

                      .members[inherit_interface]

                      .has_extended_attribute("NoInterfaceObject");

         } else if (this.has_extended_attribute('ArrayClass')) {

             inherit_interface = 'Array';

             inherit_interface_has_interface_object = true;

         } else {

             inherit_interface = 'Object';

             inherit_interface_has_interface_object = true;

         }

         if (inherit_interface_has_interface_object) {

             assert_own_property(window, inherit_interface,

                                 'should inherit from ' + inherit_interface + ', but window has no such property');

             assert_own_property(window[inherit_interface], 'prototype',

                                 'should inherit from ' + inherit_interface + ', but that object has no "prototype" property');

             assert_equals(Object.getPrototypeOf(window[this.name].prototype),

                           window[inherit_interface].prototype,

                           'prototype of ' + this.name + '.prototype is not ' + inherit_interface + '.prototype');

         } else {

             // We can't test that we get the correct object, because this is the

             // only way to get our hands on it. We only test that its class

             // string, at least, is correct.

             assert_class_string(Object.getPrototypeOf(window[this.name].prototype),

                                 inherit_interface + 'Prototype',

                                 'Class name for prototype of ' + this.name +

                                 '.prototype is not "' + inherit_interface + 'Prototype"');

         }

         // "The class string of an interface prototype object is the

         // concatenation of the interface’s identifier and the string

         // “Prototype”."

         assert_class_string(window[this.name].prototype, this.name + "Prototype",

                             "class string of " + this.name + ".prototype");

         // String() should end up calling {}.toString if nothing defines a

         // stringifier.

         if (!this.has_stringifier()) {

             assert_equals(String(window[this.name].prototype), "[object " + this.name + "Prototype]",

                     "String(" + this.name + ".prototype)");

         }

     }.bind(this), this.name + " interface: existence and properties of interface prototype object");

     test(function()

     {

         assert_own_property(window, this.name,

                             "window does not have own property " + format_value(this.name));

         if (this.has_extended_attribute("Callback")) {

             assert_false("prototype" in window[this.name],

                          this.name + ' should not have a "prototype" property');

             return;

         }

         assert_own_property(window[this.name], "prototype",

                             'interface "' + this.name + '" does not have own property "prototype"');

         // "If the [NoInterfaceObject] extended attribute was not specified on

         // the interface, then the interface prototype object must also have a

         // property named “constructor” with attributes { [[Writable]]: true,

         // [[Enumerable]]: false, [[Configurable]]: true } whose value is a

         // reference to the interface object for the interface."

         assert_own_property(window[this.name].prototype, "constructor",

                             this.name + '.prototype does not have own property "constructor"');

         var desc = Object.getOwnPropertyDescriptor(window[this.name].prototype, "constructor");

         assert_false("get" in desc, this.name + ".prototype.constructor has getter");

         assert_false("set" in desc, this.name + ".prototype.constructor has setter");

         assert_true(desc.writable, this.name + ".prototype.constructor is not writable");

         assert_false(desc.enumerable, this.name + ".prototype.constructor is enumerable");

         assert_true(desc.configurable, this.name + ".prototype.constructor in not configurable");

         assert_equals(window[this.name].prototype.constructor, window[this.name],

                       this.name + '.prototype.constructor is not the same object as ' + this.name);

     }.bind(this), this.name + ' interface: existence and properties of interface prototype object\'s "constructor" property');

 };

 //@}

 IdlInterface.prototype.test_members = function()

 //@{

 {

     for (var i = 0; i < this.members.length; i++)

     {

         var member = this.members[i];

         if (member.untested)

         {

             continue;

         }

         if (member.type == "const")

         {

             test(function()

             {

                 assert_own_property(window, this.name,

                                     "window does not have own property " + format_value(this.name));

                 // "For each constant defined on an interface A, there must be

                 // a corresponding property on the interface object, if it

                 // exists."

                 assert_own_property(window[this.name], member.name);

                 // "The value of the property is that which is obtained by

                 // converting the constant’s IDL value to an ECMAScript

                 // value."

                 assert_equals(window[this.name][member.name], constValue(member.value),

                               "property has wrong value");

                 // "The property has attributes { [[Writable]]: false,

                 // [[Enumerable]]: true, [[Configurable]]: false }."

                 var desc = Object.getOwnPropertyDescriptor(window[this.name], member.name);

                 assert_false("get" in desc, "property has getter");

                 assert_false("set" in desc, "property has setter");

                 assert_false(desc.writable, "property is writable");

                 assert_true(desc.enumerable, "property is not enumerable");

                 assert_false(desc.configurable, "property is configurable");

             }.bind(this), this.name + " interface: constant " + member.name + " on interface object");

             // "In addition, a property with the same characteristics must

             // exist on the interface prototype object."

             test(function()

             {

                 assert_own_property(window, this.name,

                                     "window does not have own property " + format_value(this.name));

                 if (this.has_extended_attribute("Callback")) {

                     assert_false("prototype" in window[this.name],

                                  this.name + ' should not have a "prototype" property');

                     return;

                 }

                 assert_own_property(window[this.name], "prototype",

                                     'interface "' + this.name + '" does not have own property "prototype"');

                 assert_own_property(window[this.name].prototype, member.name);

                 assert_equals(window[this.name].prototype[member.name], constValue(member.value),

                               "property has wrong value");

                 var desc = Object.getOwnPropertyDescriptor(window[this.name], member.name);

                 assert_false("get" in desc, "property has getter");

                 assert_false("set" in desc, "property has setter");

                 assert_false(desc.writable, "property is writable");

                 assert_true(desc.enumerable, "property is not enumerable");

                 assert_false(desc.configurable, "property is configurable");

             }.bind(this), this.name + " interface: constant " + member.name + " on interface prototype object");

         }

         else if (member.type == "attribute")

         {

             if (member.has_extended_attribute("Unforgeable"))

             {

                 // We do the checks in test_interface_of instead

                 continue;

             }

             test(function()

             {

                 assert_own_property(window, this.name,

                                     "window does not have own property " + format_value(this.name));

                 assert_own_property(window[this.name], "prototype",

                                     'interface "' + this.name + '" does not have own property "prototype"');

                 if (member["static"]) {

                     assert_own_property(window[this.name], member.name,

                         "The interface object must have a property " +

                         format_value(member.name));

                 }

                 else

                 {

                     assert_true(member.name in window[this.name].prototype,

                         "The prototype object must have a property " +

                         format_value(member.name));

                     // TODO: Needs to test for LenientThis.

                     assert_throws(new TypeError(), function() {

                         window[this.name].prototype[member.name];

                     }.bind(this), "getting property on prototype object must throw TypeError");

                     do_interface_attribute_asserts(window[this.name].prototype, member);

                 }

             }.bind(this), this.name + " interface: attribute " + member.name);

         }

         else if (member.type == "operation")

         {

             // TODO: Need to correctly handle multiple operations with the same

             // identifier.

             if (!member.name)

             {

                 // Unnamed getter or such

                 continue;

             }

             test(function()

             {

                 assert_own_property(window, this.name,

                                     "window does not have own property " + format_value(this.name));

                 if (this.has_extended_attribute("Callback")) {

                     assert_false("prototype" in window[this.name],

                                  this.name + ' should not have a "prototype" property');

                     return;

                 }

                 assert_own_property(window[this.name], "prototype",

                                     'interface "' + this.name + '" does not have own property "prototype"');

                 // "For each unique identifier of an operation defined on the

                 // interface, there must be a corresponding property on the

                 // interface prototype object (if it is a regular operation) or

                 // the interface object (if it is a static operation), unless

                 // the effective overload set for that identifier and operation

                 // and with an argument count of 0 (for the ECMAScript language

                 // binding) has no entries."

                 //

                 var prototypeOrInterfaceObject;

                 if (member["static"]) {

                     assert_own_property(window[this.name], member.name,

                             "interface prototype object missing static operation");

                     prototypeOrInterfaceObject = window[this.name];

                 }

                 else

                 {

                     assert_own_property(window[this.name].prototype, member.name,

                             "interface prototype object missing non-static operation");

                     prototypeOrInterfaceObject = window[this.name].prototype;

                 }

                 var desc = Object.getOwnPropertyDescriptor(prototypeOrInterfaceObject, member.name);

                 // "The property has attributes { [[Writable]]: true,

                 // [[Enumerable]]: true, [[Configurable]]: true }."

                 assert_false("get" in desc, "property has getter");

                 assert_false("set" in desc, "property has setter");

                 assert_true(desc.writable, "property is not writable");

                 assert_true(desc.enumerable, "property is not enumerable");

                 assert_true(desc.configurable, "property is not configurable");

                 // "The value of the property is a Function object whose

                 // behavior is as follows . . ."

                 assert_equals(typeof prototypeOrInterfaceObject[member.name], "function",

                               "property must be a function");

                 // "The value of the Function object’s “length” property is

                 // a Number determined as follows:

                 // ". . .

                 // "Return the length of the shortest argument list of the

                 // entries in S."

                 //

                 // TODO: Doesn't handle overloading or variadic arguments.

                 assert_equals(prototypeOrInterfaceObject[member.name].length,

                     member.arguments.filter(function(arg) {

                         return !arg.optional;

                     }).length,

                     "property has wrong .length");

                 // Make some suitable arguments

                 var args = member.arguments.map(function(arg) {

                     return create_suitable_object(arg.idlType);

                 });

                 // "Let O be a value determined as follows:

                 // ". . .

                 // "Otherwise, throw a TypeError."

                 // This should be hit if the operation is not static, there is

                 // no [ImplicitThis] attribute, and the this value is null.

                 //

                 // TODO: We currently ignore the [ImplicitThis] case.

                 if (!member["static"]) {

                     assert_throws(new TypeError(), function() {

                         window[this.name].prototype[member.name].apply(null, args);

                     }, "calling operation with this = null didn't throw TypeError");

                 }

                 // ". . . If O is not null and is also not a platform object

                 // that implements interface I, throw a TypeError."

                 //

                 // TODO: Test a platform object that implements some other

                 // interface.  (Have to be sure to get inheritance right.)

                 assert_throws(new TypeError(), function() {

                     window[this.name].prototype[member.name].apply({}, args);

                 }, "calling operation with this = {} didn't throw TypeError");

             }.bind(this), this.name + " interface: operation " + member.name +

             "(" + member.arguments.map(function(m) { return m.idlType.idlType; }) +

             ")");

         }

         // TODO: check more member types, like stringifier

     }

 };

 //@}

 IdlInterface.prototype.test_object = function(desc)

 //@{

 {

     var obj, exception = null;

     try

     {

         obj = eval(desc);

     }

     catch(e)

     {

         exception = e;

     }

     // TODO: WebIDLParser doesn't currently support named legacycallers, so I'm

     // not sure what those would look like in the AST

     var expected_typeof = this.members.some(function(member)

     {

         return member.legacycaller

             || ("idlType" in member && member.idlType.legacycaller)

             || ("idlType" in member && typeof member.idlType == "object"

             && "idlType" in member.idlType && member.idlType.idlType == "legacycaller");

     }) ? "function" : "object";

     this.test_primary_interface_of(desc, obj, exception, expected_typeof);

     var current_interface = this;

     while (current_interface)

     {

         if (!(current_interface.name in this.array.members))

         {

             throw "Interface " + current_interface.name + " not found (inherited by " + this.name + ")";

         }

         if (current_interface.prevent_multiple_testing && current_interface.already_tested)

         {

             return;

         }

         current_interface.test_interface_of(desc, obj, exception, expected_typeof);

         current_interface = this.array.members[current_interface.base];

     }

 };

 //@}

 IdlInterface.prototype.test_primary_interface_of = function(desc, obj, exception, expected_typeof)

 //@{

 {

     // We can't easily test that its prototype is correct if there's no

     // interface object, or the object is from a different global environment

     // (not instanceof Object).  TODO: test in this case that its prototype at

     // least looks correct, even if we can't test that it's actually correct.

     if (!this.has_extended_attribute("NoInterfaceObject")

     && (typeof obj != expected_typeof || obj instanceof Object))

     {

         test(function()

         {

             assert_equals(exception, null, "Unexpected exception when evaluating object");

             assert_equals(typeof obj, expected_typeof, "wrong typeof object");

             assert_own_property(window, this.name,

                                 "window does not have own property " + format_value(this.name));

             assert_own_property(window[this.name], "prototype",

                                 'interface "' + this.name + '" does not have own property "prototype"');

             // "The value of the internal [[Prototype]] property of the

             // platform object is the interface prototype object of the primary

             // interface from the platform object’s associated global

             // environment."

             assert_equals(Object.getPrototypeOf(obj),

                           window[this.name].prototype,

                           desc + "'s prototype is not " + this.name + ".prototype");

         }.bind(this), this.name + " must be primary interface of " + desc);

     }

     // "The class string of a platform object that implements one or more

     // interfaces must be the identifier of the primary interface of the

     // platform object."

     test(function()

     {

         assert_equals(exception, null, "Unexpected exception when evaluating object");

         assert_equals(typeof obj, expected_typeof, "wrong typeof object");

         assert_class_string(obj, this.name, "class string of " + desc);

         if (!this.has_stringifier())

         {

             assert_equals(String(obj), "[object " + this.name + "]", "String(" + desc + ")");

         }

     }.bind(this), "Stringification of " + desc);

 };

 //@}

 IdlInterface.prototype.test_interface_of = function(desc, obj, exception, expected_typeof)

 //@{

 {

     // TODO: Indexed and named properties, more checks on interface members

     this.already_tested = true;

     for (var i = 0; i < this.members.length; i++)

     {

         var member = this.members[i];

         if (member.has_extended_attribute("Unforgeable"))

         {

             test(function()

             {

                 assert_equals(exception, null, "Unexpected exception when evaluating object");

                 assert_equals(typeof obj, expected_typeof, "wrong typeof object");

                 do_interface_attribute_asserts(obj, member);

             }.bind(this), this.name + " interface: " + desc + ' must have own property "' + member.name + '"');

         }

         else if ((member.type == "const"

         || member.type == "attribute"

         || member.type == "operation")

         && member.name)

         {

             test(function()

             {

                 assert_equals(exception, null, "Unexpected exception when evaluating object");

                 assert_equals(typeof obj, expected_typeof, "wrong typeof object");

                 if (!member["static"]) {

                     assert_inherits(obj, member.name);

                     if (member.type == "const")

                     {

                         assert_equals(obj[member.name], constValue(member.value));

                     }

                     if (member.type == "attribute")

                     {

                         // Attributes are accessor properties, so they might

                         // legitimately throw an exception rather than returning

                         // anything.

                         var property, thrown = false;

                         try

                         {

                             property = obj[member.name];

                         }

                         catch (e)

                         {

                             thrown = true;

                         }

                         if (!thrown)

                         {

                             this.array.assert_type_is(property, member.idlType);

                         }

                     }

                     if (member.type == "operation")

                     {

                         assert_equals(typeof obj[member.name], "function");

                     }

                 }

             }.bind(this), this.name + " interface: " + desc + ' must inherit property "' + member.name + '" with the proper type (' + i + ')');

         }

         // TODO: This is wrong if there are multiple operations with the same

         // identifier.

         // TODO: Test passing arguments of the wrong type.

         if (member.type == "operation" && member.name && member.arguments.length)

         {

             test(function()

             {

                 assert_equals(exception, null, "Unexpected exception when evaluating object");

                 assert_equals(typeof obj, expected_typeof, "wrong typeof object");

                 if (!member["static"]) {

                     assert_inherits(obj, member.name);

                 }

                 else

                 {

                     assert_false(member.name in obj);

                 }

                 var args = [];

                 for (var i = 0; i < member.arguments.length; i++)

                 {

                     if (member.arguments[i].optional)

                     {

                         break;

                     }

                     assert_throws(new TypeError(), function()

                     {

                         obj[member.name].apply(obj, args);

                     }.bind(this), "Called with " + i + " arguments");

                     args.push(create_suitable_object(member.arguments[i].idlType));

                 }

             }.bind(this), this.name + " interface: calling " + member.name +

             "(" + member.arguments.map(function(m) { return m.idlType.idlType; }) +

             ") on " + desc + " with too few arguments must throw TypeError");

         }

     }

 };

 //@}

 IdlInterface.prototype.has_stringifier = function()

 //@{

 {

     if (this.members.some(function(member) { return member.stringifier; })) {

         return true;

     }

     if (this.base &&

         this.array.members[this.base].has_stringifier()) {

         return true;

     }

     return false;

 };

 //@}

 function do_interface_attribute_asserts(obj, member)

 //@{

 {

     // "For each attribute defined on the interface, there must exist a

     // corresponding property. If the attribute was declared with the

     // [Unforgeable] extended attribute, then the property exists on every

     // object that implements the interface.  Otherwise, it exists on the

     // interface’s interface prototype object."

     //

     // This is called by test_self() with the prototype as obj, and by

     // test_interface_of() with the object as obj.

     assert_own_property(obj, member.name);

     // "The property has attributes { [[Get]]: G, [[Set]]: S, [[Enumerable]]:

     // true, [[Configurable]]: configurable }, where:

     // "configurable is false if the attribute was declared with the

     // [Unforgeable] extended attribute and true otherwise;

     // "G is the attribute getter, defined below; and

     // "S is the attribute setter, also defined below."

     var desc = Object.getOwnPropertyDescriptor(obj, member.name);

     assert_false("value" in desc, 'property descriptor has value but is supposed to be accessor');

     assert_false("writable" in desc, 'property descriptor has "writable" field but is supposed to be accessor');

     assert_true(desc.enumerable, "property is not enumerable");

     if (member.has_extended_attribute("Unforgeable"))

     {

         assert_false(desc.configurable, "[Unforgeable] property must not be configurable");

     }

     else

     {

         assert_true(desc.configurable, "property must be configurable");

     }

     // "The attribute getter is a Function object whose behavior when invoked

     // is as follows:

     // "...

     // "The value of the Function object’s “length” property is the Number

     // value 0."

     assert_equals(typeof desc.get, "function", "getter must be Function");

     assert_equals(desc.get.length, 0, "getter length must be 0");

     // TODO: Account for LenientThis

     assert_throws(new TypeError(), function()

     {

         desc.get.call({});

     }.bind(this), "calling getter on wrong object type must throw TypeError");

     // TODO: Test calling setter on the interface prototype (should throw

     // TypeError in most cases).

     //

     // "The attribute setter is undefined if the attribute is declared readonly

     // and has neither a [PutForwards] nor a [Replaceable] extended attribute

     // declared on it.  Otherwise, it is a Function object whose behavior when

     // invoked is as follows:

     // "...

     // "The value of the Function object’s “length” property is the Number

     // value 1."

     if (member.readonly

     && !member.has_extended_attribute("PutForwards")

     && !member.has_extended_attribute("Replaceable"))

     {

         assert_equals(desc.set, undefined, "setter must be undefined for readonly attributes");

     }

     else

     {

         assert_equals(typeof desc.set, "function", "setter must be function for PutForwards, Replaceable, or non-readonly attributes");

         assert_equals(desc.set.length, 1, "setter length must be 1");

     }

 }

 //@}

 /// IdlInterfaceMember ///

 function IdlInterfaceMember(obj)

 //@{

 {

     /**

      * obj is an object produced by the WebIDLParser.js "ifMember" production.

      * We just forward all properties to this object without modification,

      * except for special extAttrs handling.

      */

     for (var k in obj)

     {

         this[k] = obj[k];

     }

     if (!("extAttrs" in this))

     {

         this.extAttrs = [];

     }

 }

 //@}

 IdlInterfaceMember.prototype = Object.create(IdlObject.prototype);

 /// Internal helper functions ///

 function create_suitable_object(type)

 //@{

 {

     /**

      * type is an object produced by the WebIDLParser.js "type" production.  We

      * return a JavaScript value that matches the type, if we can figure out

      * how.

      */

     if (type.nullable)

     {

         return null;

     }

     switch (type.idlType)

     {

         case "any":

         case "boolean":

             return true;

         case "byte": case "octet": case "short": case "unsigned short":

         case "long": case "unsigned long": case "long long":

         case "unsigned long long": case "float": case "double":

         case "unrestricted float": case "unrestricted double":

             return 7;

         case "DOMString":

             return "foo";

         case "object":

             return {a: "b"};

         case "Node":

             return document.createTextNode("abc");

     }

     return null;

 }

 //@}

 /// IdlEnum ///

 // Used for IdlArray.prototype.assert_type_is

 function IdlEnum(obj)

 //@{

 {

     /**

      * obj is an object produced by the WebIDLParser.js "dictionary"

      * production.

      */

     /** Self-explanatory. */

     this.name = obj.name;

     /** An array of values produced by the "enum" production. */

     this.values = obj.values;

 }

 //@}

 IdlEnum.prototype = Object.create(IdlObject.prototype);

 /// IdlTypedef ///

 // Used for IdlArray.prototype.assert_type_is

 function IdlTypedef(obj)

 //@{

 {

     /**

      * obj is an object produced by the WebIDLParser.js "typedef"

      * production.

      */

     /** Self-explanatory. */

     this.name = obj.name;

     /** An array of values produced by the "typedef" production. */

     this.values = obj.values;

 }

 //@}

 IdlTypedef.prototype = Object.create(IdlObject.prototype);

 }());

 // vim: set expandtab shiftwidth=4 tabstop=4 foldmarker=@{,@} foldmethod=marker: