The Tor Browser: accessible/tests/mochitest/events.js@6474c204b198 (annotated)

accessible/tests/mochitest/events.js@6474c204b198 (annotated)

accessible/tests/mochitest/events.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 ////////////////////////////////////////////////////////////////////////////////
 // Constants
 const EVENT_ALERT = nsIAccessibleEvent.EVENT_ALERT;
 const EVENT_DESCRIPTION_CHANGE = nsIAccessibleEvent.EVENT_DESCRIPTION_CHANGE;
 const EVENT_DOCUMENT_LOAD_COMPLETE = nsIAccessibleEvent.EVENT_DOCUMENT_LOAD_COMPLETE;
 const EVENT_DOCUMENT_RELOAD = nsIAccessibleEvent.EVENT_DOCUMENT_RELOAD;
 const EVENT_DOCUMENT_LOAD_STOPPED = nsIAccessibleEvent.EVENT_DOCUMENT_LOAD_STOPPED;
 const EVENT_HIDE = nsIAccessibleEvent.EVENT_HIDE;
 const EVENT_FOCUS = nsIAccessibleEvent.EVENT_FOCUS;
 const EVENT_NAME_CHANGE = nsIAccessibleEvent.EVENT_NAME_CHANGE;
 const EVENT_MENU_START = nsIAccessibleEvent.EVENT_MENU_START;
 const EVENT_MENU_END = nsIAccessibleEvent.EVENT_MENU_END;
 const EVENT_MENUPOPUP_START = nsIAccessibleEvent.EVENT_MENUPOPUP_START;
 const EVENT_MENUPOPUP_END = nsIAccessibleEvent.EVENT_MENUPOPUP_END;
 const EVENT_OBJECT_ATTRIBUTE_CHANGED = nsIAccessibleEvent.EVENT_OBJECT_ATTRIBUTE_CHANGED;
 const EVENT_REORDER = nsIAccessibleEvent.EVENT_REORDER;
 const EVENT_SCROLLING_START = nsIAccessibleEvent.EVENT_SCROLLING_START;
 const EVENT_SELECTION = nsIAccessibleEvent.EVENT_SELECTION;
 const EVENT_SELECTION_ADD = nsIAccessibleEvent.EVENT_SELECTION_ADD;
 const EVENT_SELECTION_REMOVE = nsIAccessibleEvent.EVENT_SELECTION_REMOVE;
 const EVENT_SELECTION_WITHIN = nsIAccessibleEvent.EVENT_SELECTION_WITHIN;
 const EVENT_SHOW = nsIAccessibleEvent.EVENT_SHOW;
 const EVENT_STATE_CHANGE = nsIAccessibleEvent.EVENT_STATE_CHANGE;
 const EVENT_TEXT_ATTRIBUTE_CHANGED = nsIAccessibleEvent.EVENT_TEXT_ATTRIBUTE_CHANGED;
 const EVENT_TEXT_CARET_MOVED = nsIAccessibleEvent.EVENT_TEXT_CARET_MOVED;
 const EVENT_TEXT_INSERTED = nsIAccessibleEvent.EVENT_TEXT_INSERTED;
 const EVENT_TEXT_REMOVED = nsIAccessibleEvent.EVENT_TEXT_REMOVED;
 const EVENT_TEXT_SELECTION_CHANGED = nsIAccessibleEvent.EVENT_TEXT_SELECTION_CHANGED;
 const EVENT_VALUE_CHANGE = nsIAccessibleEvent.EVENT_VALUE_CHANGE;
 const EVENT_VIRTUALCURSOR_CHANGED = nsIAccessibleEvent.EVENT_VIRTUALCURSOR_CHANGED;
 const kNotFromUserInput = 0;
 const kFromUserInput = 1;
 ////////////////////////////////////////////////////////////////////////////////
 // General
 Components.utils.import("resource://gre/modules/Services.jsm");
 /**
  * Set up this variable to dump events into DOM.
  */
 var gA11yEventDumpID = "";
 /**
  * Set up this variable to dump event processing into console.
  */
 var gA11yEventDumpToConsole = false;
 /**
  * Set up this variable to dump event processing into error console.
  */
 var gA11yEventDumpToAppConsole = false;
 /**
  * Semicolon separated set of logging features.
  */
 var gA11yEventDumpFeature = "";
 /**
  * Executes the function when requested event is handled.
  *
  * @param aEventType  [in] event type
  * @param aTarget     [in] event target
  * @param aFunc       [in] function to call when event is handled
  * @param aContext    [in, optional] object in which context the function is
  *                    called
  * @param aArg1       [in, optional] argument passed into the function
  * @param aArg2       [in, optional] argument passed into the function
  */
 function waitForEvent(aEventType, aTargetOrFunc, aFunc, aContext, aArg1, aArg2)
 {
   var handler = {
     handleEvent: function handleEvent(aEvent) {
       var target = aTargetOrFunc;
       if (typeof aTargetOrFunc == "function")
         target = aTargetOrFunc.call();
       if (target) {
         if (target instanceof nsIAccessible &&
             target != aEvent.accessible)
           return;
         if (target instanceof nsIDOMNode &&
             target != aEvent.DOMNode)
           return;
       }
       unregisterA11yEventListener(aEventType, this);
       window.setTimeout(
         function ()
         {
           aFunc.call(aContext, aArg1, aArg2);
         },
 
       );
     }
   };
   registerA11yEventListener(aEventType, handler);
 }
 /**
  * Generate mouse move over image map what creates image map accessible (async).
  * See waitForImageMap() function.
  */
 function waveOverImageMap(aImageMapID)
 {
   var imageMapNode = getNode(aImageMapID);
   synthesizeMouse(imageMapNode, 10, 10, { type: "mousemove" },
                   imageMapNode.ownerDocument.defaultView);
 }
 /**
  * Call the given function when the tree of the given image map is built.
  */
 function waitForImageMap(aImageMapID, aTestFunc)
 {
   waveOverImageMap(aImageMapID);
   var imageMapAcc = getAccessible(aImageMapID);
   if (imageMapAcc.firstChild)
     return aTestFunc();
   waitForEvent(EVENT_REORDER, imageMapAcc, aTestFunc);
 }
 /**
  * Register accessibility event listener.
  *
  * @param aEventType     the accessible event type (see nsIAccessibleEvent for
  *                       available constants).
  * @param aEventHandler  event listener object, when accessible event of the
  *                       given type is handled then 'handleEvent' method of
  *                       this object is invoked with nsIAccessibleEvent object
  *                       as the first argument.
  */
 function registerA11yEventListener(aEventType, aEventHandler)
 {
   listenA11yEvents(true);
   addA11yEventListener(aEventType, aEventHandler);
 }
 /**
  * Unregister accessibility event listener. Must be called for every registered
  * event listener (see registerA11yEventListener() function) when the listener
  * is not needed.
  */
 function unregisterA11yEventListener(aEventType, aEventHandler)
 {
   removeA11yEventListener(aEventType, aEventHandler);
   listenA11yEvents(false);
 }
 ////////////////////////////////////////////////////////////////////////////////
 // Event queue
 /**
  * Return value of invoke method of invoker object. Indicates invoker was unable
  * to prepare action.
  */
 const INVOKER_ACTION_FAILED = 1;
 /**
  * Return value of eventQueue.onFinish. Indicates eventQueue should not finish
  * tests.
  */
 const DO_NOT_FINISH_TEST = 1;
 /**
  * Creates event queue for the given event type. The queue consists of invoker
  * objects, each of them generates the event of the event type. When queue is
  * started then every invoker object is asked to generate event after timeout.
  * When event is caught then current invoker object is asked to check whether
  * event was handled correctly.
  *
  * Invoker interface is:
  *
  *   var invoker = {
  *     // Generates accessible event or event sequence. If returns
  *     // INVOKER_ACTION_FAILED constant then stop tests.
  *     invoke: function(){},
  *
  *     // [optional] Invoker's check of handled event for correctness.
  *     check: function(aEvent){},
  *
  *     // [optional] Invoker's check before the next invoker is proceeded.
  *     finalCheck: function(aEvent){},
  *
  *     // [optional] Is called when event of any registered type is handled.
  *     debugCheck: function(aEvent){},
  *
  *     // [ignored if 'eventSeq' is defined] DOM node event is generated for
  *     // (used in the case when invoker expects single event).
  *     DOMNode getter: function() {},
  *
  *     // [optional] if true then event sequences are ignored (no failure if
  *     // sequences are empty). Use you need to invoke an action, do some check
  *     // after timeout and proceed a next invoker.
  *     noEventsOnAction getter: function() {},
  *
  *     // Array of checker objects defining expected events on invoker's action.
  *     //
  *     // Checker object interface:
  *     //
  *     // var checker = {
  *     //   * DOM or a11y event type. *
  *     //   type getter: function() {},
  *     //
  *     //   * DOM node or accessible. *
  *     //   target getter: function() {},
  *     //
  *     //   * DOM event phase (false - bubbling). *
  *     //   phase getter: function() {},
  *     //
  *     //   * Callback, called to match handled event. *
  *     //   match : function(aEvent) {},
  *     //
  *     //   * Callback, called when event is handled
  *     //   check: function(aEvent) {},
  *     //
  *     //   * Checker ID *
  *     //   getID: function() {},
  *     //
  *     //   * Event that don't have predefined order relative other events. *
  *     //   async getter: function() {},
  *     //
  *     //   * Event that is not expected. *
  *     //   unexpected getter: function() {},
  *     //
  *     //   * No other event of the same type is not allowed. *
  *     //   unique getter: function() {}
  *     // };
  *     eventSeq getter() {},
  *
  *     // Array of checker objects defining unexpected events on invoker's
  *     // action.
  *     unexpectedEventSeq getter() {},
  *
  *     // The ID of invoker.
  *     getID: function(){} // returns invoker ID
  *   };
  *
  *   // Used to add a possible scenario of expected/unexpected events on
  *   // invoker's action.
  *  defineScenario(aInvokerObj, aEventSeq, aUnexpectedEventSeq)
  *
  *
  * @param  aEventType  [in, optional] the default event type (isn't used if
  *                      invoker defines eventSeq property).
  */
 function eventQueue(aEventType)
 {
   // public
   /**
    * Add invoker object into queue.
    */
   this.push = function eventQueue_push(aEventInvoker)
   {
     this.mInvokers.push(aEventInvoker);
   }
   /**
    * Start the queue processing.
    */
   this.invoke = function eventQueue_invoke()
   {
     listenA11yEvents(true);
     // XXX: Intermittent test_events_caretmove.html fails withouth timeout,
     // see bug 474952.
     this.processNextInvokerInTimeout(true);
   }
   /**
    * This function is called when all events in the queue were handled.
    * Override it if you need to be notified of this.
    */
   this.onFinish = function eventQueue_finish()
   {
   }
   // private
   /**
    * Process next invoker.
    */
   this.processNextInvoker = function eventQueue_processNextInvoker()
   {
     // Some scenario was matched, we wait on next invoker processing.
     if (this.mNextInvokerStatus == kInvokerCanceled) {
       this.setInvokerStatus(kInvokerNotScheduled,
                             "scenario was matched, wait for next invoker activation");
       return;
     }
     this.setInvokerStatus(kInvokerNotScheduled, "the next invoker is processed now");
     // Finish processing of the current invoker if any.
     var testFailed = false;
     var invoker = this.getInvoker();
     if (invoker) {
       if ("finalCheck" in invoker)
         invoker.finalCheck();
       if (this.mScenarios && this.mScenarios.length) {
         var matchIdx = -1;
         for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
           var eventSeq = this.mScenarios[scnIdx];
           if (!this.areExpectedEventsLeft(eventSeq)) {
             for (var idx = 0; idx < eventSeq.length; idx++) {
               var checker = eventSeq[idx];
               if (checker.unexpected && checker.wasCaught ||
                   !checker.unexpected && checker.wasCaught != 1) {
                 break;
               }
             }
             // Ok, we have matched scenario. Report it was completed ok. In
             // case of empty scenario guess it was matched but if later we
             // find out that non empty scenario was matched then it will be
             // a final match.
             if (idx == eventSeq.length) {
               if (matchIdx != -1 && eventSeq.length > 0 &&
                   this.mScenarios[matchIdx].length > 0) {
                 ok(false,
                    "We have a matched scenario at index " + matchIdx + " already.");
               }
               if (matchIdx == -1 || eventSeq.length > 0)
                 matchIdx = scnIdx;
               // Report everythign is ok.
               for (var idx = 0; idx < eventSeq.length; idx++) {
                 var checker = eventSeq[idx];
                 var typeStr = eventQueue.getEventTypeAsString(checker);
                 var msg = "Test with ID = '" + this.getEventID(checker) +
                   "' succeed. ";
                 if (checker.unexpected)
                   ok(true, msg + "There's no unexpected " + typeStr + " event.");
                 else
                   ok(true, msg + "Event " + typeStr + " was handled.");
               }
             }
           }
         }
         // We don't have completely matched scenario. Report each failure/success
         // for every scenario.
         if (matchIdx == -1) {
           testFailed = true;
           for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
             var eventSeq = this.mScenarios[scnIdx];
             for (var idx = 0; idx < eventSeq.length; idx++) {
               var checker = eventSeq[idx];
               var typeStr = eventQueue.getEventTypeAsString(checker);
               var msg = "Scenario #" + scnIdx + " of test with ID = '" +
                 this.getEventID(checker) + "' failed. ";
               if (checker.wasCaught > 1)
                 ok(false, msg + "Dupe " + typeStr + " event.");
               if (checker.unexpected) {
                 if (checker.wasCaught)
                   ok(false, msg + "There's unexpected " + typeStr + " event.");
               } else if (!checker.wasCaught) {
                 ok(false, msg + typeStr + " event was missed.");
               }
             }
           }
         }
       }
     }
     this.clearEventHandler();
     // Check if need to stop the test.
     if (testFailed || this.mIndex == this.mInvokers.length - 1) {
       listenA11yEvents(false);
       var res = this.onFinish();
       if (res != DO_NOT_FINISH_TEST)
         SimpleTest.finish();
       return;
     }
     // Start processing of next invoker.
     invoker = this.getNextInvoker();
     // Set up event listeners. Process a next invoker if no events were added.
     if (!this.setEventHandler(invoker)) {
       this.processNextInvoker();
       return;
     }
     if (gLogger.isEnabled()) {
       gLogger.logToConsole("Event queue: \n  invoke: " + invoker.getID());
       gLogger.logToDOM("EQ: invoke: " + invoker.getID(), true);
     }
     var infoText = "Invoke the '" + invoker.getID() + "' test { ";
     var scnCount = this.mScenarios ? this.mScenarios.length : 0;
     for (var scnIdx = 0; scnIdx < scnCount; scnIdx++) {
       infoText += "scenario #" + scnIdx + ": ";
       var eventSeq = this.mScenarios[scnIdx];
       for (var idx = 0; idx < eventSeq.length; idx++) {
         infoText += eventSeq[idx].unexpected ? "un" : "" +
           "expected '" + eventQueue.getEventTypeAsString(eventSeq[idx]) +
           "' event; ";
       }
     }
     infoText += " }";
     info(infoText);
     if (invoker.invoke() == INVOKER_ACTION_FAILED) {
       // Invoker failed to prepare action, fail and finish tests.
       this.processNextInvoker();
       return;
     }
     if (this.hasUnexpectedEventsScenario())
       this.processNextInvokerInTimeout(true);
   }
   this.processNextInvokerInTimeout =
     function eventQueue_processNextInvokerInTimeout(aUncondProcess)
   {
     this.setInvokerStatus(kInvokerPending, "Process next invoker in timeout");
     // No need to wait extra timeout when a) we know we don't need to do that
     // and b) there's no any single unexpected event.
     if (!aUncondProcess && this.areAllEventsExpected()) {
       // We need delay to avoid events coalesce from different invokers.
       var queue = this;
       SimpleTest.executeSoon(function() { queue.processNextInvoker(); });
       return;
     }
     // Check in timeout invoker didn't fire registered events.
     window.setTimeout(function(aQueue) { aQueue.processNextInvoker(); }, 300,
                       this);
   }
   /**
    * Handle events for the current invoker.
    */
   this.handleEvent = function eventQueue_handleEvent(aEvent)
   {
     var invoker = this.getInvoker();
     if (!invoker) // skip events before test was started
       return;
     if (!this.mScenarios) {
       // Bad invoker object, error will be reported before processing of next
       // invoker in the queue.
       this.processNextInvoker();
       return;
     }
     if ("debugCheck" in invoker)
       invoker.debugCheck(aEvent);
     for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
       var eventSeq = this.mScenarios[scnIdx];
       for (var idx = 0; idx < eventSeq.length; idx++) {
         var checker = eventSeq[idx];
         // Search through handled expected events to report error if one of them
         // is handled for a second time.
         if (!checker.unexpected && (checker.wasCaught > 0) &&
             eventQueue.isSameEvent(checker, aEvent)) {
           checker.wasCaught++;
           continue;
         }
         // Search through unexpected events, any match results in error report
         // after this invoker processing (in case of matched scenario only).
         if (checker.unexpected && eventQueue.compareEvents(checker, aEvent)) {
           checker.wasCaught++;
           continue;
         }
         // Report an error if we hanlded not expected event of unique type
         // (i.e. event types are matched, targets differs).
         if (!checker.unexpected && checker.unique &&
             eventQueue.compareEventTypes(checker, aEvent)) {
           var isExppected = false;
           for (var jdx = 0; jdx < eventSeq.length; jdx++) {
             isExpected = eventQueue.compareEvents(eventSeq[jdx], aEvent);
             if (isExpected)
               break;
           }
           if (!isExpected) {
             ok(false,
                "Unique type " +
                eventQueue.getEventTypeAsString(checker) + " event was handled.");
           }
         }
       }
     }
     var hasMatchedCheckers = false;
     for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
       var eventSeq = this.mScenarios[scnIdx];
       // Check if handled event matches expected sync event.
       var nextChecker = this.getNextExpectedEvent(eventSeq);
       if (nextChecker) {
         if (eventQueue.compareEvents(nextChecker, aEvent)) {
           this.processMatchedChecker(aEvent, nextChecker, scnIdx, eventSeq.idx);
           hasMatchedCheckers = true;
           continue;
         }
       }
       // Check if handled event matches any expected async events.
       for (idx = 0; idx < eventSeq.length; idx++) {
         if (!eventSeq[idx].unexpected && eventSeq[idx].async) {
           if (eventQueue.compareEvents(eventSeq[idx], aEvent)) {
             this.processMatchedChecker(aEvent, eventSeq[idx], scnIdx, idx);
             hasMatchedCheckers = true;
             break;
           }
         }
       }
     }
     if (hasMatchedCheckers) {
       var invoker = this.getInvoker();
       if ("check" in invoker)
         invoker.check(aEvent);
     }
     // If we don't have more events to wait then schedule next invoker.
     if (this.hasMatchedScenario()) {
       if (this.mNextInvokerStatus == kInvokerNotScheduled) {
         this.processNextInvokerInTimeout();
       } else if (this.mNextInvokerStatus == kInvokerCanceled) {
         this.setInvokerStatus(kInvokerPending,
                               "Full match. Void the cancelation of next invoker processing");
       }
       return;
     }
     // If we have scheduled a next invoker then cancel in case of match.
     if ((this.mNextInvokerStatus == kInvokerPending) && hasMatchedCheckers) {
       this.setInvokerStatus(kInvokerCanceled,
                             "Cancel the scheduled invoker in case of match");
     }
   }
   // Helpers
   this.processMatchedChecker =
     function eventQueue_function(aEvent, aMatchedChecker, aScenarioIdx, aEventIdx)
   {
     aMatchedChecker.wasCaught++;
     if ("check" in aMatchedChecker)
       aMatchedChecker.check(aEvent);
     eventQueue.logEvent(aEvent, aMatchedChecker, aScenarioIdx, aEventIdx,
                         this.areExpectedEventsLeft(),
                         this.mNextInvokerStatus);
   }
   this.getNextExpectedEvent =
     function eventQueue_getNextExpectedEvent(aEventSeq)
   {
     if (!("idx" in aEventSeq))
       aEventSeq.idx = 0;
     while (aEventSeq.idx < aEventSeq.length &&
            (aEventSeq[aEventSeq.idx].unexpected ||
             aEventSeq[aEventSeq.idx].async ||
             aEventSeq[aEventSeq.idx].wasCaught > 0)) {
       aEventSeq.idx++;
     }
     return aEventSeq.idx != aEventSeq.length ? aEventSeq[aEventSeq.idx] : null;
   }
   this.areExpectedEventsLeft =
     function eventQueue_areExpectedEventsLeft(aScenario)
   {
     function scenarioHasUnhandledExpectedEvent(aEventSeq)
     {
       // Check if we have unhandled async (can be anywhere in the sequance) or
       // sync expcected events yet.
       for (var idx = 0; idx < aEventSeq.length; idx++) {
         if (!aEventSeq[idx].unexpected && !aEventSeq[idx].wasCaught)
           return true;
       }
       return false;
     }
     if (aScenario)
       return scenarioHasUnhandledExpectedEvent(aScenario);
     for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
       var eventSeq = this.mScenarios[scnIdx];
       if (scenarioHasUnhandledExpectedEvent(eventSeq))
         return true;
     }
     return false;
   }
   this.areAllEventsExpected =
     function eventQueue_areAllEventsExpected()
   {
     for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
       var eventSeq = this.mScenarios[scnIdx];
       for (var idx = 0; idx < eventSeq.length; idx++) {
         if (eventSeq[idx].unexpected)
           return false;
       }
     }
     return true;
   }
   this.isUnexpectedEventScenario =
     function eventQueue_isUnexpectedEventsScenario(aScenario)
   {
     for (var idx = 0; idx < aScenario.length; idx++) {
       if (!aScenario[idx].unexpected)
         break;
     }
     return idx == aScenario.length;
   }
   this.hasUnexpectedEventsScenario =
     function eventQueue_hasUnexpectedEventsScenario()
   {
     if (this.getInvoker().noEventsOnAction)
       return true;
     for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
       if (this.isUnexpectedEventScenario(this.mScenarios[scnIdx]))
         return true;
     }
     return false;
   }
   this.hasMatchedScenario =
     function eventQueue_hasMatchedScenario()
   {
     for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
       var scn = this.mScenarios[scnIdx];
       if (!this.isUnexpectedEventScenario(scn) && !this.areExpectedEventsLeft(scn))
         return true;
     }
     return false;
   }
   this.getInvoker = function eventQueue_getInvoker()
   {
     return this.mInvokers[this.mIndex];
   }
   this.getNextInvoker = function eventQueue_getNextInvoker()
   {
     return this.mInvokers[++this.mIndex];
   }
   this.setEventHandler = function eventQueue_setEventHandler(aInvoker)
   {
     if (!("scenarios" in aInvoker) || aInvoker.scenarios.length == 0) {
       var eventSeq = aInvoker.eventSeq;
       var unexpectedEventSeq = aInvoker.unexpectedEventSeq;
       if (!eventSeq && !unexpectedEventSeq && this.mDefEventType)
         eventSeq = [ new invokerChecker(this.mDefEventType, aInvoker.DOMNode) ];
       if (eventSeq || unexpectedEventSeq)
         defineScenario(aInvoker, eventSeq, unexpectedEventSeq);
     }
     if (aInvoker.noEventsOnAction)
       return true;
     this.mScenarios = aInvoker.scenarios;
     if (!this.mScenarios || !this.mScenarios.length) {
       ok(false, "Broken invoker '" + aInvoker.getID() + "'");
       return false;
     }
     // Register event listeners.
     for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
       var eventSeq = this.mScenarios[scnIdx];
       if (gLogger.isEnabled()) {
         var msg = "scenario #" + scnIdx +
           ", registered events number: " + eventSeq.length;
         gLogger.logToConsole(msg);
         gLogger.logToDOM(msg, true);
       }
       // Do not warn about empty event sequances when more than one scenario
       // was registered.
       if (this.mScenarios.length == 1 && eventSeq.length == 0) {
         ok(false,
            "Broken scenario #" + scnIdx + " of invoker '" + aInvoker.getID() +
            "'. No registered events");
         return false;
       }
       for (var idx = 0; idx < eventSeq.length; idx++)
         eventSeq[idx].wasCaught = 0;
       for (var idx = 0; idx < eventSeq.length; idx++) {
         if (gLogger.isEnabled()) {
           var msg = "registered";
           if (eventSeq[idx].unexpected)
             msg += " unexpected";
           if (eventSeq[idx].async)
             msg += " async";
           msg += ": event type: " +
             eventQueue.getEventTypeAsString(eventSeq[idx]) +
             ", target: " + eventQueue.getEventTargetDescr(eventSeq[idx], true);
           gLogger.logToConsole(msg);
           gLogger.logToDOM(msg, true);
         }
         var eventType = eventSeq[idx].type;
         if (typeof eventType == "string") {
           // DOM event
           var target = eventSeq[idx].target;
           if (!target) {
             ok(false, "no target for DOM event!");
             return false;
           }
           var phase = eventQueue.getEventPhase(eventSeq[idx]);
           target.ownerDocument.addEventListener(eventType, this, phase);
         } else {
           // A11y event
           addA11yEventListener(eventType, this);
         }
       }
     }
     return true;
   }
   this.clearEventHandler = function eventQueue_clearEventHandler()
   {
     if (!this.mScenarios)
       return;
     for (var scnIdx = 0; scnIdx < this.mScenarios.length; scnIdx++) {
       var eventSeq = this.mScenarios[scnIdx];
       for (var idx = 0; idx < eventSeq.length; idx++) {
         var eventType = eventSeq[idx].type;
         if (typeof eventType == "string") {
           // DOM event
           var target = eventSeq[idx].target;
           var phase = eventQueue.getEventPhase(eventSeq[idx]);
           target.ownerDocument.removeEventListener(eventType, this, phase);
         } else {
           // A11y event
           removeA11yEventListener(eventType, this);
         }
       }
     }
     this.mScenarios = null;
   }
   this.getEventID = function eventQueue_getEventID(aChecker)
   {
     if ("getID" in aChecker)
       return aChecker.getID();
     var invoker = this.getInvoker();
     return invoker.getID();
   }
   this.setInvokerStatus = function eventQueue_setInvokerStatus(aStatus, aLogMsg)
   {
     this.mNextInvokerStatus = aStatus;
     // Uncomment it to debug invoker processing logic.
     //gLogger.log(eventQueue.invokerStatusToMsg(aStatus, aLogMsg));
   }
   this.mDefEventType = aEventType;
   this.mInvokers = new Array();
   this.mIndex = -1;
   this.mScenarios = null;
   this.mNextInvokerStatus = kInvokerNotScheduled;
 }
 ////////////////////////////////////////////////////////////////////////////////
 // eventQueue static members and constants
 const kInvokerNotScheduled = 0;
 const kInvokerPending = 1;
 const kInvokerCanceled = 2;
 eventQueue.getEventTypeAsString =
   function eventQueue_getEventTypeAsString(aEventOrChecker)
 {
   if (aEventOrChecker instanceof nsIDOMEvent)
     return aEventOrChecker.type;
   if (aEventOrChecker instanceof nsIAccessibleEvent)
     return eventTypeToString(aEventOrChecker.eventType);
   return (typeof aEventOrChecker.type == "string") ?
     aEventOrChecker.type : eventTypeToString(aEventOrChecker.type);
 }
 eventQueue.getEventTargetDescr =
   function eventQueue_getEventTargetDescr(aEventOrChecker, aDontForceTarget)
 {
   if (aEventOrChecker instanceof nsIDOMEvent)
     return prettyName(aEventOrChecker.originalTarget);
   if (aEventOrChecker instanceof nsIDOMEvent)
     return prettyName(aEventOrChecker.accessible);
   var descr = aEventOrChecker.targetDescr;
   if (descr)
     return descr;
   if (aDontForceTarget)
     return "no target description";
   var target = ("target" in aEventOrChecker) ? aEventOrChecker.target : null;
   return prettyName(target);
 }
 eventQueue.getEventPhase = function eventQueue_getEventPhase(aChecker)
 {
   return ("phase" in aChecker) ? aChecker.phase : true;
 }
 eventQueue.compareEventTypes =
   function eventQueue_compareEventTypes(aChecker, aEvent)
 {
   var eventType = (aEvent instanceof nsIDOMEvent) ?
     aEvent.type : aEvent.eventType;
   return aChecker.type == eventType;
 }
 eventQueue.compareEvents = function eventQueue_compareEvents(aChecker, aEvent)
 {
   if (!eventQueue.compareEventTypes(aChecker, aEvent))
     return false;
   // If checker provides "match" function then allow the checker to decide
   // whether event is matched.
   if ("match" in aChecker)
     return aChecker.match(aEvent);
   var target1 = aChecker.target;
   if (target1 instanceof nsIAccessible) {
     var target2 = (aEvent instanceof nsIDOMEvent) ?
       getAccessible(aEvent.target) : aEvent.accessible;
     return target1 == target2;
   }
   // If original target isn't suitable then extend interface to support target
   // (original target is used in test_elm_media.html).
   var target2 = (aEvent instanceof nsIDOMEvent) ?
     aEvent.originalTarget : aEvent.DOMNode;
   return target1 == target2;
 }
 eventQueue.isSameEvent = function eventQueue_isSameEvent(aChecker, aEvent)
 {
   // We don't have stored info about handled event other than its type and
   // target, thus we should filter text change and state change events since
   // they may occur on the same element because of complex changes.
   return this.compareEvents(aChecker, aEvent) &&
     !(aEvent instanceof nsIAccessibleTextChangeEvent) &&
     !(aEvent instanceof nsIAccessibleStateChangeEvent);
 }
 eventQueue.invokerStatusToMsg =
   function eventQueue_invokerStatusToMsg(aInvokerStatus, aMsg)
 {
   var msg = "invoker status: ";
   switch (aInvokerStatus) {
     case kInvokerNotScheduled:
       msg += "not scheduled";
       break;
     case kInvokerPending:
       msg += "pending";
       break;
     case kInvokerCanceled:
       msg += "canceled";
       break;
   }
   if (aMsg)
     msg += " (" + aMsg + ")";
   return msg;
 }
 eventQueue.logEvent = function eventQueue_logEvent(aOrigEvent, aMatchedChecker,
                                                    aScenarioIdx, aEventIdx,
                                                    aAreExpectedEventsLeft,
                                                    aInvokerStatus)
 {
   // Dump DOM event information. Skip a11y event since it is dumped by
   // gA11yEventObserver.
   if (aOrigEvent instanceof nsIDOMEvent) {
     var info = "Event type: " + eventQueue.getEventTypeAsString(aOrigEvent);
     info += ". Target: " + eventQueue.getEventTargetDescr(aOrigEvent);
     gLogger.logToDOM(info);
   }
   var infoMsg = "unhandled expected events: " + aAreExpectedEventsLeft +
     ", "  + eventQueue.invokerStatusToMsg(aInvokerStatus);
   var currType = eventQueue.getEventTypeAsString(aMatchedChecker);
   var currTargetDescr = eventQueue.getEventTargetDescr(aMatchedChecker);
   var consoleMsg = "*****\nScenario " + aScenarioIdx +
     ", event " + aEventIdx + " matched: " + currType + "\n" + infoMsg + "\n*****";
   gLogger.logToConsole(consoleMsg);
   var emphText = "matched ";
   var msg = "EQ event, type: " + currType + ", target: " + currTargetDescr +
     ", " + infoMsg;
   gLogger.logToDOM(msg, true, emphText);
 }
 ////////////////////////////////////////////////////////////////////////////////
 // Action sequence
 /**
  * Deal with action sequence. Used when you need to execute couple of actions
  * each after other one.
  */
 function sequence()
 {
   /**
    * Append new sequence item.
    *
    * @param  aProcessor  [in] object implementing interface
    *                      {
    *                        // execute item action
    *                        process: function() {},
    *                        // callback, is called when item was processed
    *                        onProcessed: function() {}
    *                      };
    * @param  aEventType  [in] event type of expected event on item action
    * @param  aTarget     [in] event target of expected event on item action
    * @param  aItemID     [in] identifier of item
    */
   this.append = function sequence_append(aProcessor, aEventType, aTarget,
                                          aItemID)
   {
     var item = new sequenceItem(aProcessor, aEventType, aTarget, aItemID);
     this.items.push(item);
   }
   /**
    * Process next sequence item.
    */
   this.processNext = function sequence_processNext()
   {
     this.idx++;
     if (this.idx >= this.items.length) {
       ok(false, "End of sequence: nothing to process!");
       SimpleTest.finish();
       return;
     }
     this.items[this.idx].startProcess();
   }
   this.items = new Array();
   this.idx = -1;
 }
 ////////////////////////////////////////////////////////////////////////////////
 // Event queue invokers
 /**
  * Defines a scenario of expected/unexpected events. Each invoker can have
  * one or more scenarios of events. Only one scenario must be completed.
  */
 function defineScenario(aInvoker, aEventSeq, aUnexpectedEventSeq)
 {
   if (!("scenarios" in aInvoker))
     aInvoker.scenarios = new Array();
   // Create unified event sequence concatenating expected and unexpected
   // events.
   if (!aEventSeq)
     aEventSeq = [];
   for (var idx = 0; idx < aEventSeq.length; idx++) {
     aEventSeq[idx].unexpected |= false;
     aEventSeq[idx].async |= false;
   }
   if (aUnexpectedEventSeq) {
     for (var idx = 0; idx < aUnexpectedEventSeq.length; idx++) {
       aUnexpectedEventSeq[idx].unexpected = true;
       aUnexpectedEventSeq[idx].async = false;
     }
     aEventSeq = aEventSeq.concat(aUnexpectedEventSeq);
   }
   aInvoker.scenarios.push(aEventSeq);
 }
 /**
  * Invokers defined below take a checker object (or array of checker objects).
  * An invoker listens for default event type registered in event queue object
  * until its checker is provided.
  *
  * Note, checker object or array of checker objects is optional.
  */
 /**
  * Click invoker.
  */
 function synthClick(aNodeOrID, aCheckerOrEventSeq, aArgs)
 {
   this.__proto__ = new synthAction(aNodeOrID, aCheckerOrEventSeq);
   this.invoke = function synthClick_invoke()
   {
     var targetNode = this.DOMNode;
     if (targetNode instanceof nsIDOMDocument) {
       targetNode =
         this.DOMNode.body ? this.DOMNode.body : this.DOMNode.documentElement;
     }
     // Scroll the node into view, otherwise synth click may fail.
     if (targetNode instanceof nsIDOMHTMLElement) {
       targetNode.scrollIntoView(true);
     } else if (targetNode instanceof nsIDOMXULElement) {
       var targetAcc = getAccessible(targetNode);
       targetAcc.scrollTo(SCROLL_TYPE_ANYWHERE);
     }
     var x = 1, y = 1;
     if (aArgs && ("where" in aArgs) && aArgs.where == "right") {
       if (targetNode instanceof nsIDOMHTMLElement)
         x = targetNode.offsetWidth - 1;
       else if (targetNode instanceof nsIDOMXULElement)
         x = targetNode.boxObject.width - 1;
     }
     synthesizeMouse(targetNode, x, y, aArgs ? aArgs : {});
   }
   this.finalCheck = function synthClick_finalCheck()
   {
     // Scroll top window back.
     window.top.scrollTo(0, 0);
   }
   this.getID = function synthClick_getID()
   {
     return prettyName(aNodeOrID) + " click";
   }
 }
 /**
  * Mouse move invoker.
  */
 function synthMouseMove(aID, aCheckerOrEventSeq)
 {
   this.__proto__ = new synthAction(aID, aCheckerOrEventSeq);
   this.invoke = function synthMouseMove_invoke()
   {
     synthesizeMouse(this.DOMNode, 1, 1, { type: "mousemove" });
     synthesizeMouse(this.DOMNode, 2, 2, { type: "mousemove" });
   }
   this.getID = function synthMouseMove_getID()
   {
     return prettyName(aID) + " mouse move";
   }
 }
 /**
  * General key press invoker.
  */
 function synthKey(aNodeOrID, aKey, aArgs, aCheckerOrEventSeq)
 {
   this.__proto__ = new synthAction(aNodeOrID, aCheckerOrEventSeq);
   this.invoke = function synthKey_invoke()
   {
     synthesizeKey(this.mKey, this.mArgs, this.mWindow);
   }
   this.getID = function synthKey_getID()
   {
     var key = this.mKey;
     switch (this.mKey) {
       case "VK_TAB":
         key = "tab";
         break;
       case "VK_DOWN":
         key = "down";
         break;
       case "VK_UP":
         key = "up";
         break;
       case "VK_LEFT":
         key = "left";
         break;
       case "VK_RIGHT":
         key = "right";
         break;
       case "VK_HOME":
         key = "home";
         break;
       case "VK_END":
         key = "end";
         break;
       case "VK_ESCAPE":
         key = "escape";
         break;
       case "VK_RETURN":
         key = "enter";
         break;
     }
     if (aArgs) {
       if (aArgs.shiftKey)
         key += " shift";
       if (aArgs.ctrlKey)
         key += " ctrl";
       if (aArgs.altKey)
         key += " alt";
     }
     return prettyName(aNodeOrID) + " '" + key + " ' key";
   }
   this.mKey = aKey;
   this.mArgs = aArgs ? aArgs : {};
   this.mWindow = aArgs ? aArgs.window : null;
 }
 /**
  * Tab key invoker.
  */
 function synthTab(aNodeOrID, aCheckerOrEventSeq, aWindow)
 {
   this.__proto__ = new synthKey(aNodeOrID, "VK_TAB",
                                 { shiftKey: false, window: aWindow },
                                 aCheckerOrEventSeq);
 }
 /**
  * Shift tab key invoker.
  */
 function synthShiftTab(aNodeOrID, aCheckerOrEventSeq)
 {
   this.__proto__ = new synthKey(aNodeOrID, "VK_TAB", { shiftKey: true },
                                 aCheckerOrEventSeq);
 }
 /**
  * Escape key invoker.
  */
 function synthEscapeKey(aNodeOrID, aCheckerOrEventSeq)
 {
   this.__proto__ = new synthKey(aNodeOrID, "VK_ESCAPE", null,
                                 aCheckerOrEventSeq);
 }
 /**
  * Down arrow key invoker.
  */
 function synthDownKey(aNodeOrID, aCheckerOrEventSeq, aArgs)
 {
   this.__proto__ = new synthKey(aNodeOrID, "VK_DOWN", aArgs,
                                 aCheckerOrEventSeq);
 }
 /**
  * Up arrow key invoker.
  */
 function synthUpKey(aNodeOrID, aCheckerOrEventSeq, aArgs)
 {
   this.__proto__ = new synthKey(aNodeOrID, "VK_UP", aArgs,
                                 aCheckerOrEventSeq);
 }
 /**
  * Left arrow key invoker.
  */
 function synthLeftKey(aNodeOrID, aCheckerOrEventSeq, aArgs)
 {
   this.__proto__ = new synthKey(aNodeOrID, "VK_LEFT", aArgs, aCheckerOrEventSeq);
 }
 /**
  * Right arrow key invoker.
  */
 function synthRightKey(aNodeOrID, aCheckerOrEventSeq, aArgs)
 {
   this.__proto__ = new synthKey(aNodeOrID, "VK_RIGHT", aArgs, aCheckerOrEventSeq);
 }
 /**
  * Home key invoker.
  */
 function synthHomeKey(aNodeOrID, aCheckerOrEventSeq)
 {
   this.__proto__ = new synthKey(aNodeOrID, "VK_HOME", null, aCheckerOrEventSeq);
 }
 /**
  * End key invoker.
  */
 function synthEndKey(aNodeOrID, aCheckerOrEventSeq)
 {
   this.__proto__ = new synthKey(aNodeOrID, "VK_END", null, aCheckerOrEventSeq);
 }
 /**
  * Enter key invoker
  */
 function synthEnterKey(aID, aCheckerOrEventSeq)
 {
   this.__proto__ = new synthKey(aID, "VK_RETURN", null, aCheckerOrEventSeq);
 }
 /**
  * Synth alt + down arrow to open combobox.
  */
 function synthOpenComboboxKey(aID, aCheckerOrEventSeq)
 {
   this.__proto__ = new synthDownKey(aID, aCheckerOrEventSeq, { altKey: true });
   this.getID = function synthOpenComboboxKey_getID()
   {
     return "open combobox (atl + down arrow) " + prettyName(aID);
   }
 }
 /**
  * Focus invoker.
  */
 function synthFocus(aNodeOrID, aCheckerOrEventSeq)
 {
   var checkerOfEventSeq =
     aCheckerOrEventSeq ? aCheckerOrEventSeq : new focusChecker(aNodeOrID);
   this.__proto__ = new synthAction(aNodeOrID, checkerOfEventSeq);
   this.invoke = function synthFocus_invoke()
   {
     if (this.DOMNode instanceof Components.interfaces.nsIDOMNSEditableElement &&
         this.DOMNode.editor ||
         this.DOMNode instanceof Components.interfaces.nsIDOMXULTextBoxElement) {
       this.DOMNode.selectionStart = this.DOMNode.selectionEnd = this.DOMNode.value.length;
     }
     this.DOMNode.focus();
   }
   this.getID = function synthFocus_getID()
   {
     return prettyName(aNodeOrID) + " focus";
   }
 }
 /**
  * Focus invoker. Focus the HTML body of content document of iframe.
  */
 function synthFocusOnFrame(aNodeOrID, aCheckerOrEventSeq)
 {
   var frameDoc = getNode(aNodeOrID).contentDocument;
   var checkerOrEventSeq =
     aCheckerOrEventSeq ? aCheckerOrEventSeq : new focusChecker(frameDoc);
   this.__proto__ = new synthAction(frameDoc, checkerOrEventSeq);
   this.invoke = function synthFocus_invoke()
   {
     this.DOMNode.body.focus();
   }
   this.getID = function synthFocus_getID()
   {
     return prettyName(aNodeOrID) + " frame document focus";
   }
 }
 /**
  * Change the current item when the widget doesn't have a focus.
  */
 function changeCurrentItem(aID, aItemID)
 {
   this.eventSeq = [ new nofocusChecker() ];
   this.invoke = function changeCurrentItem_invoke()
   {
     var controlNode = getNode(aID);
     var itemNode = getNode(aItemID);
     // HTML
     if (controlNode.localName == "input") {
       if (controlNode.checked)
         this.reportError();
       controlNode.checked = true;
       return;
     }
     if (controlNode.localName == "select") {
       if (controlNode.selectedIndex == itemNode.index)
         this.reportError();
       controlNode.selectedIndex = itemNode.index;
       return;
     }
     // XUL
     if (controlNode.localName == "tree") {
       if (controlNode.currentIndex == aItemID)
         this.reportError();
       controlNode.currentIndex = aItemID;
       return;
     }
     if (controlNode.localName == "menulist") {
       if (controlNode.selectedItem == itemNode)
         this.reportError();
       controlNode.selectedItem = itemNode;
       return;
     }
     if (controlNode.currentItem == itemNode)
       ok(false, "Error in test: proposed current item is already current" + prettyName(aID));
     controlNode.currentItem = itemNode;
   }
   this.getID = function changeCurrentItem_getID()
   {
     return "current item change for " + prettyName(aID);
   }
   this.reportError = function changeCurrentItem_reportError()
   {
     ok(false,
        "Error in test: proposed current item '" + aItemID + "' is already current");
   }
 }
 /**
  * Toggle top menu invoker.
  */
 function toggleTopMenu(aID, aCheckerOrEventSeq)
 {
   this.__proto__ = new synthKey(aID, "VK_ALT", null,
                                 aCheckerOrEventSeq);
   this.getID = function toggleTopMenu_getID()
   {
     return "toggle top menu on " + prettyName(aID);
   }
 }
 /**
  * Context menu invoker.
  */
 function synthContextMenu(aID, aCheckerOrEventSeq)
 {
   this.__proto__ = new synthClick(aID, aCheckerOrEventSeq,
                                   { button: 0, type: "contextmenu" });
   this.getID = function synthContextMenu_getID()
   {
     return "context menu on " + prettyName(aID);
   }
 }
 /**
  * Open combobox, autocomplete and etc popup, check expandable states.
  */
 function openCombobox(aComboboxID)
 {
   this.eventSeq = [
     new stateChangeChecker(STATE_EXPANDED, false, true, aComboboxID)
   ];
   this.invoke = function openCombobox_invoke()
   {
     getNode(aComboboxID).focus();
     synthesizeKey("VK_DOWN", { altKey: true });
   }
   this.getID = function openCombobox_getID()
   {
     return "open combobox " + prettyName(aComboboxID);
   }
 }
 /**
  * Close combobox, autocomplete and etc popup, check expandable states.
  */
 function closeCombobox(aComboboxID)
 {
   this.eventSeq = [
     new stateChangeChecker(STATE_EXPANDED, false, false, aComboboxID)
   ];
   this.invoke = function closeCombobox_invoke()
   {
     synthesizeKey("VK_ESCAPE", { });
   }
   this.getID = function closeCombobox_getID()
   {
     return "close combobox " + prettyName(aComboboxID);
   }
 }
 /**
  * Select all invoker.
  */
 function synthSelectAll(aNodeOrID, aCheckerOrEventSeq)
 {
   this.__proto__ = new synthAction(aNodeOrID, aCheckerOrEventSeq);
   this.invoke = function synthSelectAll_invoke()
   {
     if (this.DOMNode instanceof Components.interfaces.nsIDOMHTMLInputElement ||
         this.DOMNode instanceof Components.interfaces.nsIDOMXULTextBoxElement) {
       this.DOMNode.select();
     } else {
       window.getSelection().selectAllChildren(this.DOMNode);
     }
   }
   this.getID = function synthSelectAll_getID()
   {
     return aNodeOrID + " selectall";
   }
 }
 /**
  * Move the caret to the end of line.
  */
 function moveToLineEnd(aID, aCaretOffset)
 {
   if (MAC) {
     this.__proto__ = new synthKey(aID, "VK_RIGHT", { metaKey: true },
                                   new caretMoveChecker(aCaretOffset, aID));
   } else {
     this.__proto__ = new synthEndKey(aID,
                                      new caretMoveChecker(aCaretOffset, aID));
   }
   this.getID = function moveToLineEnd_getID()
   {
     return "move to line end in " + prettyName(aID);
   }
 }
 /**
  * Move the caret to the end of previous line if any.
  */
 function moveToPrevLineEnd(aID, aCaretOffset)
 {
   this.__proto__ = new synthAction(aID, new caretMoveChecker(aCaretOffset, aID));
   this.invoke = function moveToPrevLineEnd_invoke()
   {
     synthesizeKey("VK_UP", { });
     if (MAC)
       synthesizeKey("VK_RIGHT", { metaKey: true });
     else
       synthesizeKey("VK_END", { });
   }
   this.getID = function moveToPrevLineEnd_getID()
   {
     return "move to previous line end in " + prettyName(aID);
   }
 }
 /**
  * Move the caret to begining of the line.
  */
 function moveToLineStart(aID, aCaretOffset)
 {
   if (MAC) {
     this.__proto__ = new synthKey(aID, "VK_LEFT", { metaKey: true },
                                   new caretMoveChecker(aCaretOffset, aID));
   } else {
     this.__proto__ = new synthHomeKey(aID,
                                       new caretMoveChecker(aCaretOffset, aID));
   }
   this.getID = function moveToLineEnd_getID()
   {
     return "move to line start in " + prettyName(aID);
   }
 }
 /**
  * Move the caret to begining of the text.
  */
 function moveToTextStart(aID)
 {
   if (MAC) {
     this.__proto__ = new synthKey(aID, "VK_UP", { metaKey: true },
                                   new caretMoveChecker(0, aID));
   } else {
     this.__proto__ = new synthKey(aID, "VK_HOME", { ctrlKey: true },
                                   new caretMoveChecker(0, aID));
   }
   this.getID = function moveToTextStart_getID()
   {
     return "move to text start in " + prettyName(aID);
   }
 }
 /**
  * Move the caret in text accessible.
  */
 function moveCaretToDOMPoint(aID, aDOMPointNodeID, aDOMPointOffset,
                              aExpectedOffset, aFocusTargetID,
                              aCheckFunc)
 {
   this.target = getAccessible(aID, [nsIAccessibleText]);
   this.DOMPointNode = getNode(aDOMPointNodeID);
   this.focus = aFocusTargetID ? getAccessible(aFocusTargetID) : null;
   this.focusNode = this.focus ? this.focus.DOMNode : null;
   this.invoke = function moveCaretToDOMPoint_invoke()
   {
     if (this.focusNode)
       this.focusNode.focus();
     var selection = this.DOMPointNode.ownerDocument.defaultView.getSelection();
     var selRange = selection.getRangeAt(0);
     selRange.setStart(this.DOMPointNode, aDOMPointOffset);
     selRange.collapse(true);
     selection.removeRange(selRange);
     selection.addRange(selRange);
   }
   this.getID = function moveCaretToDOMPoint_getID()
   {
    return "Set caret on " + prettyName(aID) + " at point: " +
      prettyName(aDOMPointNodeID) + " node with offset " + aDOMPointOffset;
   }
   this.finalCheck = function moveCaretToDOMPoint_finalCheck()
   {
     if (aCheckFunc)
       aCheckFunc.call();
   }
   this.eventSeq = [
     new caretMoveChecker(aExpectedOffset, this.target)
   ];
   if (this.focus)
     this.eventSeq.push(new asyncInvokerChecker(EVENT_FOCUS, this.focus));
 }
 /**
  * Set caret offset in text accessible.
  */
 function setCaretOffset(aID, aOffset, aFocusTargetID)
 {
   this.target = getAccessible(aID, [nsIAccessibleText]);
   this.offset = aOffset == -1 ? this.target.characterCount: aOffset;
   this.focus = aFocusTargetID ? getAccessible(aFocusTargetID) : null;
   this.invoke = function setCaretOffset_invoke()
   {
     this.target.caretOffset = this.offset;
   }
   this.getID = function setCaretOffset_getID()
   {
    return "Set caretOffset on " + prettyName(aID) + " at " + this.offset;
   }
   this.eventSeq = [
     new caretMoveChecker(this.offset, this.target)
   ];
   if (this.focus)
     this.eventSeq.push(new asyncInvokerChecker(EVENT_FOCUS, this.focus));
 }
 ////////////////////////////////////////////////////////////////////////////////
 // Event queue checkers
 /**
  * Common invoker checker (see eventSeq of eventQueue).
  */
 function invokerChecker(aEventType, aTargetOrFunc, aTargetFuncArg, aIsAsync)
 {
   this.type = aEventType;
   this.async = aIsAsync;
   this.__defineGetter__("target", invokerChecker_targetGetter);
   this.__defineSetter__("target", invokerChecker_targetSetter);
   // implementation details
   function invokerChecker_targetGetter()
   {
     if (typeof this.mTarget == "function")
       return this.mTarget.call(null, this.mTargetFuncArg);
     if (typeof this.mTarget == "string")
       return getNode(this.mTarget);
     return this.mTarget;
   }
   function invokerChecker_targetSetter(aValue)
   {
     this.mTarget = aValue;
     return this.mTarget;
   }
   this.__defineGetter__("targetDescr", invokerChecker_targetDescrGetter);
   function invokerChecker_targetDescrGetter()
   {
     if (typeof this.mTarget == "function")
       return this.mTarget.name + ", arg: " + this.mTargetFuncArg;
     return prettyName(this.mTarget);
   }
   this.mTarget = aTargetOrFunc;
   this.mTargetFuncArg = aTargetFuncArg;
 }
 /**
  * Generic invoker checker for unexpected events.
  */
 function unexpectedInvokerChecker(aEventType, aTargetOrFunc, aTargetFuncArg)
 {
   this.__proto__ = new invokerChecker(aEventType, aTargetOrFunc,
                                       aTargetFuncArg, true);
   this.unexpected = true;
 }
 /**
  * Common invoker checker for async events.
  */
 function asyncInvokerChecker(aEventType, aTargetOrFunc, aTargetFuncArg)
 {
   this.__proto__ = new invokerChecker(aEventType, aTargetOrFunc,
                                       aTargetFuncArg, true);
 }
 function focusChecker(aTargetOrFunc, aTargetFuncArg)
 {
   this.__proto__ = new invokerChecker(EVENT_FOCUS, aTargetOrFunc,
                                       aTargetFuncArg, false);
   this.unique = true; // focus event must be unique for invoker action
   this.check = function focusChecker_check(aEvent)
   {
     testStates(aEvent.accessible, STATE_FOCUSED);
   }
 }
 function nofocusChecker(aID)
 {
   this.__proto__ = new focusChecker(aID);
   this.unexpected = true;
 }
 /**
  * Text inserted/removed events checker.
  * @param aFromUser  [in, optional] kNotFromUserInput or kFromUserInput
  */
 function textChangeChecker(aID, aStart, aEnd, aTextOrFunc, aIsInserted, aFromUser)
 {
   this.target = getNode(aID);
   this.type = aIsInserted ? EVENT_TEXT_INSERTED : EVENT_TEXT_REMOVED;
   this.startOffset = aStart;
   this.endOffset = aEnd;
   this.textOrFunc = aTextOrFunc;
   this.check = function textChangeChecker_check(aEvent)
   {
     aEvent.QueryInterface(nsIAccessibleTextChangeEvent);
     var modifiedText = (typeof this.textOrFunc == "function") ?
       this.textOrFunc() : this.textOrFunc;
     var modifiedTextLen =
       (this.endOffset == -1) ? modifiedText.length : aEnd - aStart;
     is(aEvent.start, this.startOffset,
        "Wrong start offset for " + prettyName(aID));
     is(aEvent.length, modifiedTextLen, "Wrong length for " + prettyName(aID));
     var changeInfo = (aIsInserted ? "inserted" : "removed");
     is(aEvent.isInserted, aIsInserted,
        "Text was " + changeInfo + " for " + prettyName(aID));
     is(aEvent.modifiedText, modifiedText,
        "Wrong " + changeInfo + " text for " + prettyName(aID));
     if (typeof aFromUser != "undefined")
       is(aEvent.isFromUserInput, aFromUser,
          "wrong value of isFromUserInput() for " + prettyName(aID));
   }
 }
 /**
  * Caret move events checker.
  */
 function caretMoveChecker(aCaretOffset, aTargetOrFunc, aTargetFuncArg)
 {
   this.__proto__ = new invokerChecker(EVENT_TEXT_CARET_MOVED,
                                       aTargetOrFunc, aTargetFuncArg);
   this.check = function caretMoveChecker_check(aEvent)
   {
     is(aEvent.QueryInterface(nsIAccessibleCaretMoveEvent).caretOffset,
        aCaretOffset,
        "Wrong caret offset for " + prettyName(aEvent.accessible));
   }
 }
 /**
  * Text selection change checker.
  */
 function textSelectionChecker(aID, aStartOffset, aEndOffset)
 {
   this.__proto__ = new invokerChecker(EVENT_TEXT_SELECTION_CHANGED, aID);
   this.check = function textSelectionChecker_check(aEvent)
   {
     if (aStartOffset == aEndOffset) {
       is(getAccessible(aID, [nsIAccessibleText]).caretOffset, aStartOffset,
          "Wrong collapsed selection!");
     } else {
       testTextGetSelection(aID, aStartOffset, aEndOffset, 0);
     }
   }
 }
 /**
  * State change checker.
  */
 function stateChangeChecker(aState, aIsExtraState, aIsEnabled,
                             aTargetOrFunc, aTargetFuncArg, aIsAsync,
                             aSkipCurrentStateCheck)
 {
   this.__proto__ = new invokerChecker(EVENT_STATE_CHANGE, aTargetOrFunc,
                                       aTargetFuncArg, aIsAsync);
   this.check = function stateChangeChecker_check(aEvent)
   {
     var event = null;
     try {
       var event = aEvent.QueryInterface(nsIAccessibleStateChangeEvent);
     } catch (e) {
       ok(false, "State change event was expected");
     }
     if (!event)
       return;
     is(event.isExtraState, aIsExtraState,
        "Wrong extra state bit of the statechange event.");
     isState(event.state, aState, aIsExtraState,
             "Wrong state of the statechange event.");
     is(event.isEnabled, aIsEnabled,
       "Wrong state of statechange event state");
     if (aSkipCurrentStateCheck) {
       todo(false, "State checking was skipped!");
       return;
     }
     var state = aIsEnabled ? (aIsExtraState ? 0 : aState) : 0;
     var extraState = aIsEnabled ? (aIsExtraState ? aState : 0) : 0;
     var unxpdState = aIsEnabled ? 0 : (aIsExtraState ? 0 : aState);
     var unxpdExtraState = aIsEnabled ? 0 : (aIsExtraState ? aState : 0);
     testStates(event.accessible, state, extraState, unxpdState, unxpdExtraState);
   }
   this.match = function stateChangeChecker_match(aEvent)
   {
     if (aEvent instanceof nsIAccessibleStateChangeEvent) {
       var scEvent = aEvent.QueryInterface(nsIAccessibleStateChangeEvent);
       return (aEvent.accessible == getAccessible(this.target)) &&
         (scEvent.state == aState);
     }
     return false;
   }
 }
 function asyncStateChangeChecker(aState, aIsExtraState, aIsEnabled,
                                  aTargetOrFunc, aTargetFuncArg)
 {
   this.__proto__ = new stateChangeChecker(aState, aIsExtraState, aIsEnabled,
                                           aTargetOrFunc, aTargetFuncArg, true);
 }
 /**
  * Expanded state change checker.
  */
 function expandedStateChecker(aIsEnabled, aTargetOrFunc, aTargetFuncArg)
 {
   this.__proto__ = new invokerChecker(EVENT_STATE_CHANGE, aTargetOrFunc,
                                       aTargetFuncArg);
   this.check = function expandedStateChecker_check(aEvent)
   {
     var event = null;
     try {
       var event = aEvent.QueryInterface(nsIAccessibleStateChangeEvent);
     } catch (e) {
       ok(false, "State change event was expected");
     }
     if (!event)
       return;
     is(event.state, STATE_EXPANDED, "Wrong state of the statechange event.");
     is(event.isExtraState, false,
        "Wrong extra state bit of the statechange event.");
     is(event.isEnabled, aIsEnabled,
       "Wrong state of statechange event state");
     testStates(event.accessible,
                (aIsEnabled ? STATE_EXPANDED : STATE_COLLAPSED));
   }
 }
 ////////////////////////////////////////////////////////////////////////////////
 // Event sequances (array of predefined checkers)
 /**
  * Event seq for single selection change.
  */
 function selChangeSeq(aUnselectedID, aSelectedID)
 {
   if (!aUnselectedID) {
     return [
       new stateChangeChecker(STATE_SELECTED, false, true, aSelectedID),
       new invokerChecker(EVENT_SELECTION, aSelectedID)
     ];
   }
   // Return two possible scenarios: depending on widget type when selection is
   // moved the the order of items that get selected and unselected may vary.
   return [
     [
       new stateChangeChecker(STATE_SELECTED, false, false, aUnselectedID),
       new stateChangeChecker(STATE_SELECTED, false, true, aSelectedID),
       new invokerChecker(EVENT_SELECTION, aSelectedID)
     ],
     [
       new stateChangeChecker(STATE_SELECTED, false, true, aSelectedID),
       new stateChangeChecker(STATE_SELECTED, false, false, aUnselectedID),
       new invokerChecker(EVENT_SELECTION, aSelectedID)
     ]
   ];
 }
 /**
  * Event seq for item removed form the selection.
  */
 function selRemoveSeq(aUnselectedID)
 {
   return [
     new stateChangeChecker(STATE_SELECTED, false, false, aUnselectedID),
     new invokerChecker(EVENT_SELECTION_REMOVE, aUnselectedID)
   ];
 }
 /**
  * Event seq for item added to the selection.
  */
 function selAddSeq(aSelectedID)
 {
   return [
     new stateChangeChecker(STATE_SELECTED, false, true, aSelectedID),
     new invokerChecker(EVENT_SELECTION_ADD, aSelectedID)
   ];
 }
 ////////////////////////////////////////////////////////////////////////////////
 // Private implementation details.
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 // General
 var gA11yEventListeners = {};
 var gA11yEventApplicantsCount = 0;
 var gA11yEventObserver =
 {
   observe: function observe(aSubject, aTopic, aData)
   {
     if (aTopic != "accessible-event")
       return;
     var event;
     try {
       event = aSubject.QueryInterface(nsIAccessibleEvent);
     } catch (ex) {
       // After a test is aborted (i.e. timed out by the harness), this exception is soon triggered.
       // Remove the leftover observer, otherwise it "leaks" to all the following tests.
       Services.obs.removeObserver(this, "accessible-event");
       // Forward the exception, with added explanation.
       throw "[accessible/events.js, gA11yEventObserver.observe] This is expected if a previous test has been aborted... Initial exception was: [ " + ex + " ]";
     }
     var listenersArray = gA11yEventListeners[event.eventType];
     var eventFromDumpArea = false;
     if (gLogger.isEnabled()) { // debug stuff
       eventFromDumpArea = true;
       var target = event.DOMNode;
       var dumpElm = gA11yEventDumpID ?
         document.getElementById(gA11yEventDumpID) : null;
       if (dumpElm) {
         var parent = target;
         while (parent && parent != dumpElm)
           parent = parent.parentNode;
       }
       if (!dumpElm || parent != dumpElm) {
         var type = eventTypeToString(event.eventType);
         var info = "Event type: " + type;
         if (event instanceof nsIAccessibleStateChangeEvent) {
           var stateStr = statesToString(event.isExtraState ? 0 : event.state,
                                         event.isExtraState ? event.state : 0);
           info += ", state: " + stateStr + ", is enabled: " + event.isEnabled;
         } else if (event instanceof nsIAccessibleTextChangeEvent) {
           info += ", start: " + event.start + ", length: " + event.length +
             ", " + (event.isInserted ? "inserted" : "removed") +
             " text: " + event.modifiedText;
         }
         info += ". Target: " + prettyName(event.accessible);
         if (listenersArray)
           info += ". Listeners count: " + listenersArray.length;
         if (gLogger.hasFeature("parentchain:" + type)) {
           info += "\nParent chain:\n";
           var acc = event.accessible;
           while (acc) {
             info += "  " + prettyName(acc) + "\n";
             acc = acc.parent;
           }
         }
         eventFromDumpArea = false;
         gLogger.log(info);
       }
     }
     // Do not notify listeners if event is result of event log changes.
     if (!listenersArray || eventFromDumpArea)
       return;
     for (var index = 0; index < listenersArray.length; index++)
       listenersArray[index].handleEvent(event);
   }
 };
 function listenA11yEvents(aStartToListen)
 {
   if (aStartToListen) {
     // Add observer when adding the first applicant only.
     if (!(gA11yEventApplicantsCount++))
       Services.obs.addObserver(gA11yEventObserver, "accessible-event", false);
   } else {
     // Remove observer when there are no more applicants only.
     // '< 0' case should not happen, but just in case: removeObserver() will throw.
     if (--gA11yEventApplicantsCount <= 0)
       Services.obs.removeObserver(gA11yEventObserver, "accessible-event");
   }
 }
 function addA11yEventListener(aEventType, aEventHandler)
 {
   if (!(aEventType in gA11yEventListeners))
     gA11yEventListeners[aEventType] = new Array();
   var listenersArray = gA11yEventListeners[aEventType];
   var index = listenersArray.indexOf(aEventHandler);
   if (index == -1)
     listenersArray.push(aEventHandler);
 }
 function removeA11yEventListener(aEventType, aEventHandler)
 {
   var listenersArray = gA11yEventListeners[aEventType];
   if (!listenersArray)
     return false;
   var index = listenersArray.indexOf(aEventHandler);
   if (index == -1)
     return false;
   listenersArray.splice(index, 1);
   if (!listenersArray.length) {
     gA11yEventListeners[aEventType] = null;
     delete gA11yEventListeners[aEventType];
   }
   return true;
 }
 /**
  * Used to dump debug information.
  */
 var gLogger =
 {
   /**
    * Return true if dump is enabled.
    */
   isEnabled: function debugOutput_isEnabled()
   {
     return gA11yEventDumpID || gA11yEventDumpToConsole ||
       gA11yEventDumpToAppConsole;
   },
   /**
    * Dump information into DOM and console if applicable.
    */
   log: function logger_log(aMsg)
   {
     this.logToConsole(aMsg);
     this.logToAppConsole(aMsg);
     this.logToDOM(aMsg);
   },
   /**
    * Log message to DOM.
    *
    * @param aMsg          [in] the primary message
    * @param aHasIndent    [in, optional] if specified the message has an indent
    * @param aPreEmphText  [in, optional] the text is colored and appended prior
    *                        primary message
    */
   logToDOM: function logger_logToDOM(aMsg, aHasIndent, aPreEmphText)
   {
     if (gA11yEventDumpID == "")
       return;
     var dumpElm = document.getElementById(gA11yEventDumpID);
     if (!dumpElm) {
       ok(false,
          "No dump element '" + gA11yEventDumpID + "' within the document!");
       return;
     }
     var containerTagName = document instanceof nsIDOMHTMLDocument ?
       "div" : "description";
     var container = document.createElement(containerTagName);
     if (aHasIndent)
       container.setAttribute("style", "padding-left: 10px;");
     if (aPreEmphText) {
       var inlineTagName = document instanceof nsIDOMHTMLDocument ?
         "span" : "description";
       var emphElm = document.createElement(inlineTagName);
       emphElm.setAttribute("style", "color: blue;");
       emphElm.textContent = aPreEmphText;
       container.appendChild(emphElm);
     }
     var textNode = document.createTextNode(aMsg);
     container.appendChild(textNode);
     dumpElm.appendChild(container);
   },
   /**
    * Log message to console.
    */
   logToConsole: function logger_logToConsole(aMsg)
   {
     if (gA11yEventDumpToConsole)
       dump("\n" + aMsg + "\n");
   },
   /**
    * Log message to error console.
    */
   logToAppConsole: function logger_logToAppConsole(aMsg)
   {
     if (gA11yEventDumpToAppConsole)
       Services.console.logStringMessage("events: " + aMsg);
   },
   /**
    * Return true if logging feature is enabled.
    */
   hasFeature: function logger_hasFeature(aFeature)
   {
     var startIdx = gA11yEventDumpFeature.indexOf(aFeature);
     if (startIdx == - 1)
       return false;
     var endIdx = startIdx + aFeature.length;
     return endIdx == gA11yEventDumpFeature.length ||
       gA11yEventDumpFeature[endIdx] == ";";
   }
 };
 ////////////////////////////////////////////////////////////////////////////////
 // Sequence
 /**
  * Base class of sequence item.
  */
 function sequenceItem(aProcessor, aEventType, aTarget, aItemID)
 {
   // private
   this.startProcess = function sequenceItem_startProcess()
   {
     this.queue.invoke();
   }
   var item = this;
   this.queue = new eventQueue();
   this.queue.onFinish = function()
   {
     aProcessor.onProcessed();
     return DO_NOT_FINISH_TEST;
   }
   var invoker = {
     invoke: function invoker_invoke() {
       return aProcessor.process();
     },
     getID: function invoker_getID()
     {
       return aItemID;
     },
     eventSeq: [ new invokerChecker(aEventType, aTarget) ]
   };
   this.queue.push(invoker);
 }
 ////////////////////////////////////////////////////////////////////////////////
 // Event queue invokers
 /**
  * Invoker base class for prepare an action.
  */
 function synthAction(aNodeOrID, aEventsObj)
 {
   this.DOMNode = getNode(aNodeOrID);
   if (aEventsObj) {
     var scenarios = null;
     if (aEventsObj instanceof Array) {
       if (aEventsObj[0] instanceof Array)
         scenarios = aEventsObj; // scenarios
       else
         scenarios = [ aEventsObj ]; // event sequance
     } else {
       scenarios = [ [ aEventsObj ] ]; // a single checker object
     }
     for (var i = 0; i < scenarios.length; i++)
       defineScenario(this, scenarios[i]);
   }
   this.getID = function synthAction_getID()
     { return prettyName(aNodeOrID) + " action"; }
 }