<?xml version="1.0"?>
<?xml-stylesheet type="text/css" href="chrome://global/skin"?>
<?xml-stylesheet type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"?>
<!--
https://bugzilla.mozilla.org/show_bug.cgi?id=715041
-->
    <window title="Mozilla Bug 715041"
xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
    <script type="application/javascript" src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/>

    <!-- test results are displayed in the html:body -->
    <body xmlns="http://www.w3.org/1999/xhtml">
    <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=715041"
target="_blank">Mozilla Bug 715041</a>
    </body>

    <!-- test code goes here -->
    <script type="application/javascript">
    <![CDATA[

  /** Mock Idle Service Test for Bug 715041 **/
  SpecialPowers.setBoolPref("dom.idle-observers-api.fuzz_time.disabled", true);

  //class mock javascript idle service
  var idleServiceObj = {
    observers: [],
    windowObservers: [],
    idleTimeInMS: 5000,   //in milli seconds

    // takes note of the idle observers added as the minimum idle observer
    // with the idle service
    timesAdded: [],

    QueryInterface: function(iid) {
      if (iid.equals(Components.interfaces.nsISupports) ||
          iid.equals(Components.interfaces.nsIFactory) ||
          iid.equals(Components.interfaces.nsIIdleService)) {
        return this;
      }
      throw Components.results.NS_ERROR_NO_INTERFACE;
    },

    createInstance: function(outer, iid) {
      return this.QueryInterface(iid);
    },

    get idleTime() {
      return this.idleTimeInMS; //in milli seconds
    },

    set idleTime(timeInMS) {
      this.idleTimeInMS = timeInMS;
    },

    getWindowFromObserver: function(observer) {
      try {
        var interfaceRequestor = observer.QueryInterface(Components.interfaces.nsIInterfaceRequestor);
        var window = interfaceRequestor.getInterface(Components.interfaces.nsIDOMWindow);
        return window;
      }
      catch (e) {}

      return null;
    },

    testIdleBackService: function(observer, topic) {
      dump("\nJS FAKE IDLE SERVICE\n");
      dump("JS NUM OBSERVERS: " + this.observers.length + "\n");

      if (this.observers.length > 1) {
        this.observers[1].observer.observe(observer, topic, '\0');
        dump("JS CALLED OBSERVE FUNCTION!!!\n\n");
      }
    },

    addIdleObserver: function(observer, time) {
      dump("\nJS FAKE IDLE SERVICE add idle observer before\n");
      dump("JS NUM OBSERVERS: " + this.observers.length + "\n");

      var window = this.getWindowFromObserver(observer);
      dump("window is: " + window + "\n");

      if (window) {
        this.observers.push({ observer: observer, time: time, });
        addedIdleObserver = true;
        numIdleObserversAdded++;
        this.timesAdded.push(time);

        dump ("\nMOCK IDLE SERVICE ADDING idle observer with time: " + time + "\n");
        dump("MOCK IDLE SERVICE: num idle observers added: " + numIdleObserversAdded + "\n\n");
      }
      else {
        dump("SHOULD NEVER GET HERE!");
        oldIdleService.addIdleObserver(observer, time);
        addedIdleObserver = false;
      }

      dump("\nJS FAKE IDLE SERVICE end of add idle observer\n");
      dump("JS NUM OBSERVERS: " + this.observers.length + "\n");
    },

    removeIdleObserver: function(observer, time) {
      dump("\nJS REMOVE IDLE OBSERVER () time to be removed: " + time + "\n");
      var window = this.getWindowFromObserver(observer);
      if (!window) {
        oldIdleService.removeIdleObserver(observer, time);
      }
      else {
        var observerIndex = -1;
        for (var i=0; i<this.observers.length; i++) {
          dump("JS removeIdleObserver() observer time: " + this.observers[i].time + "\n");
          if (this.observers[i].time === time) {
            observerIndex = i;
            break;
          }
        }

        if (observerIndex != -1 && this.observers.length > 0) {
          numIdleObserversRemoved++;
          this.observers.splice(observerIndex, 1);
          removedIdleObserver = true;
          dump("MOCK IDLE SERVICE REMOVING idle observer with time " + time + "\n");
          dump("MOCK IDLE SERVICE numIdleObserversRemoved: " + numIdleObserversRemoved + " numIdleObserversAdded: " + numIdleObserversAdded + "\n\n");
        }
        else {
          removedIdleObserver = false;
        }
      }
      dump("\nJS FAKE IDLE SERVICE end of remove idle observer\n");
      dump("JS NUM OBSERVERS: " + this.observers.length + "\n");
    },
  };

  /** Test for Bug 715041 **/
  dump("\n\n\nJS STARTING TESTING FOR BUG 715041\n");

  //bool variables
  var addedIdleObserver = removedIdleObserver = passed = cleanUp = false;

  //test case enabled
  var AddOutOfOrderActiveEnabled = AddOutOfOrderIdleEnabled =
      AddShiftLocalEnabled = AddNewLocalWhileAllIdleEnabled =
      TestActiveToActiveNotification = ShiftLocalTimerBackEnabled =
      AddRemoveIdleObserverWithInvalidTimeEnabled = true;

  //msgXCount
  var msg0Count = msg1Count = msg2Count = msg3Count = msg4Count = msg5Count =
      msg6Count = tcZero = currTestCaseNum = prevMsgNum =
      numIdleObserversRemoved = numIdleObserversAdded = 0;

  //test case number
  var tcZero = 0;
  var tcAddOutOfOrderActive = 1;
  var tcAddOutOfOrderIdle = 2;
  var tcAddShiftLocal = 3;
  var tcAddNewLocalWhileAllIdle = 4;
  var tcShiftLocalTimerBack = 5;
  var tcAddRemoveIdleObserverWithInvalidTime = 6;
  var tcTestActiveToActiveNotification = 7;

  function ResetMsgCounts() {
    msg0Count = msg1Count = msg2Count = msg3Count = msg4Count = msg5Count =
    msg6Count = prevMsgNum = 0;
  }

  function ResetVars() {
    msg0Count = msg1Count = msg2Count = msg3Count = msg4Count = msg5Count =
    msg6Count = prevMsgNum = 0;

    numIdleObserversAdded = numIdleObserversRemoved = 0;
    currTestCaseNum = -1;
    addedIdleObserver = removedIdleObserver = passed = cleanUp = false;
  }

  /*
   * - function printMsgCounts()
   */
  function printMsgCounts() {
    dump("\nmsg0Count: " + msg0Count +
         "\nmsg1Count: " + msg1Count +
         "\nmsg2Count: " + msg2Count +
         "\nmsg3Count: " + msg3Count +
         "\nmsg5Count: " + msg5Count +
         "\nmsg6Count: " + msg6Count +
         "\n"
         );
  }

  function performNextTest() {
    dump("\nfunction performNextTest()\ncurrTestCaseNum: " + currTestCaseNum +
         "\ncleanUp: " + cleanUp +
         "\npassed: " + passed +
         "\nnumIdleObserversRemoved: " + numIdleObserversRemoved +
         "\nnumIdleObservesAdded: " + numIdleObserversAdded + "\n");

    switch (currTestCaseNum) {
      case tcZero:
        ok(passed, "Test case 0 failed clean up!");
        caseZeroCleanUp();
        break;
      case tcAddShiftLocal:
        if (cleanUp && numIdleObserversRemoved === 1) {
          passed = true;
          ok(passed, "Failed test case AddShiftLocalCleanUp()");
          if (AddNewLocalWhileAllIdleEnabled) {
            AddNewLocalWhileAllIdle();
          }
          else {
            SimpleTest.finish();
          }
        }
        break;
      case tcAddNewLocalWhileAllIdle:
        ok(passed, "Failed test case: AddNewLocalWhileAllIdle()");
        AddNewLocalWhileAllIdleCleanUp();
        break;
      default:
        //do nothing.
        break;
    }
  }

  //Place Holder.
  var idleHandler0 = function() { dump("rmsg 0, should never be used!\n"); };

  //idleHandler1
  function idleHandler1() {
    msg1Count++;
    dump("msg 1 Count: " + msg1Count + "\n");

    switch (currTestCaseNum) {
    case tcAddOutOfOrderIdle:
      if (msg1Count === 1 && msg2Count === 1 && msg3Count === 1) {
        idleServiceObj.idleTime = 0;
        idleServiceObj.testIdleBackService(idleObserversArray[1], "active");
      }
      else if (msg1Count === 4 && msg2Count === 4 && msg3Count === 4) {
        passed = true;
        AddOutOfOrderIdleCleanUp();
      }
      break;
    case tcTestActiveToActiveNotification:
      if (msg1Count === 1 && !msg2Count && !msg3Count && !msg4Count && !msg5Count) {
        idleServiceObj.idleTime = 500;
        idleServiceObj.testIdleBackService(idleObserversArray[1], "active");
        return;
      }
      
      if (msg1Count === 2 && !msg2Count && !msg3Count && !msg4Count && !msg5Count) {        
        idleServiceObj.idleTime = 1000;
        idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
        return;
      }

      if (msg1Count === 3 && !msg2Count && !msg3Count && !msg4Count && !msg5Count) {
        return;
      }
      ok(false, "Failed test active to active notification.");
      SimpleTest.finish();
      break;  
    default:
      break;
    }
  }

  //idleHandler2
  function idleHandler2() {
    msg2Count++;
    dump("msg 2 Count: " + msg2Count + "\n");

    switch (currTestCaseNum) {
    case tcZero:
      switch (msg2Count) {
      case 2:
        passed = true;
        performNextTest();
        break;
      default:
        break;
      }
      break;
    case tcAddOutOfOrderIdle:
      if (msg3Count === 1 && msg2Count === 1 && !msg1Count) {
        idleServiceObj.idleTime = 4000;
        window.navigator.addIdleObserver(idleObserversArray[1]);
      }
      break;
    case tcAddShiftLocal:
      if (!msg1Count && msg2Count === 1 && !msg3Count && !msg4Count) {
        window.navigator.addIdleObserver(idleObserversArray[3]);
      }
      AddShiftLocalCleanUp();
      break;
    case tcAddNewLocalWhileAllIdle:
      if (msg1Count === 1 && msg2Count === 2) {
        idleServiceObj.idleTime = 3500;
        window.navigator.addIdleObserver(idleObserversArray[5]);
      }
      break;
    case (tcShiftLocalTimerBack):
      if (!msg1Count && msg2Count === 1 && !msg3Count && !msg4Count && !msg5Count) {
        window.navigator.addIdleObserver(idleObserversArray[5]);
        window.navigator.addIdleObserver(idleObserversArray[4]);
      }
      break;
    default:
      //do nothing.
      break;
    }
  }

  //idleHandler3
  function idleHandler3() {
    msg3Count++;
    dump("msg 3 Count: " + msg3Count + "\n");

    switch (currTestCaseNum) {
    case (tcAddOutOfOrderIdle):
      if (msg3Count === 1) {
        idleServiceObj.idleTime = 3500;
        window.navigator.addIdleObserver(idleObserversArray[2]);
      }
      if (msg1Count === 2 && msg2Count === 2 && msg3Count === 2) {
        idleServiceObj.idleTime = 1000;
        idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
      }
      else if (msg1Count === 3 && msg2Count === 3 && msg3Count === 3) {
        AddOutOfOrderIdle();
      }
      else if (msg1Count === 3 && msg2Count === 3 && msg3Count === 4) {
        passed = true;
        AddOutOfOrderIdleCleanUp();
      }
      break;
    default:
      break;
    }
  }

  //idleHandler4
  function idleHandler4() {
    msg4Count++;
    dump("msg 4 Count: " + msg4Count + "\n");

    switch (currTestCaseNum) {
    case tcAddOutOfOrderActive:
      if (msg1Count && msg2Count && msg3Count && msg4Count) {
        passed = true;
        ok(passed, "idleHandler4: failed AddOutOfOrderActive()");
        AddOutOfOrderActiveCleanUp();
        cleanUp = true;
      }
      break;
    case tcAddShiftLocal:
      if (msg1Count === 1 && msg3Count === 1 && msg4Count === 1) {
        idleServiceObj.idleTime = 3200;
        window.navigator.addIdleObserver(idleObserversArray[2]);
      }
      break;
    default:
      //do nothing.
      break;
    }
  }

  //idleHandler5
  function idleHandler5() {
    msg5Count++;
    dump("msg 5 Count: " + msg5Count + "\n");

    switch (currTestCaseNum) {
    case tcAddNewLocalWhileAllIdle:
      if (msg1Count === 1 && msg2Count === 2 && msg5Count === 1) {
        passed = true;
        performNextTest();
      }
      break;
    case tcShiftLocalTimerBack:
      if (!msg1Count && msg2Count === 1 && !msg3Count && msg4Count === 1 && msg5Count === 1) {
        passed = true;
        ShiftLocalTimerBackCleanUp();
      }
      break;
    case tcTestActiveToActiveNotification:
      passed = false;
      if (msg1Count === 3 && !msg2Count && !msg3Count && !msg4Count && msg5Count === 1) {
        passed = true;
      }
      ok(passed, "Failed TestActiveToActiveNotification.");
          TestActiveNotificationCleanUp();
      break;  
    default:
      //do nothing.
      break;
    }
  }

  //idleHandler6
  function idleHandler6() {
    dump("msg 6 Count: " + msg6Count + "\n");
  }

  var  idleObserversArray = [];
  idleObserversArray[0] = {time: 0, onidle: idleHandler0, onactive: idleHandler0};
  idleObserversArray[1] = {time: 1, onidle: idleHandler1, onactive: idleHandler1};
  idleObserversArray[2] = {time: 2, onidle: idleHandler2, onactive: idleHandler2};
  idleObserversArray[3] = {time: 3, onidle: idleHandler3, onactive: idleHandler3};
  idleObserversArray[4] = {time: 4, onidle: idleHandler4, onactive: idleHandler4};
  idleObserversArray[5] = {time: 5, onidle: idleHandler5, onactive: idleHandler5};
  idleObserversArray[6] = {time: 0, onidle: idleHandler6, onactive: idleHandler6};
  idleObserversArray[7] = {time: 2, onidle: null, onactive: null};

  idleServiceObj.observers.push( {observer: idleObserversArray[0], time: 0, } );

  /*
   * - case 0
   * - AddSingleIdleObserver
   * - takes care of adding duplicate local too
   * - user is currently idle since the
   *   requested idle time of 2s < current idle time of 5000ms set below.
   */
  function caseZero() {
    dump("\n\nTESTING CASE 0\n");
    dump("==============\n");

    ResetVars();
    currTestCaseNum = tcZero;
    idleServiceObj.idleTime = 5000;

    window.navigator.addIdleObserver(idleObserversArray[2]);
    idleServiceObj.testIdleBackService(idleObserversArray[2], "idle");
    window.navigator.addIdleObserver(idleObserversArray[2]);
  }

  function caseZeroCleanUp() {
    dump("\ncaseZeroCleanUp()\n");
    dump("==============\n");
    ResetVars();
    currTestCaseNum = tcZero;
    cleanUp = false;

    window.navigator.removeIdleObserver(idleObserversArray[2]);
    window.navigator.removeIdleObserver(idleObserversArray[2]);

    if (AddOutOfOrderActiveEnabled) {
      AddOutOfOrderActive();
    }
    else {
      dump("Finishing testing idle API.\n");
      SimpleTest.finish();
    }
  }

  /*
    AddOutOfOrderActive()
    - Tests if the idle observer with the min time is always registered correctly
      with the idle service.
  */
  function AddOutOfOrderActive() {
    dump("\n\nTESTING CASE AddOutOfOrderActive\n");
    dump("==============\n");

    ResetVars();
    currTestCaseNum = tcAddOutOfOrderActive;
    idleServiceObj.idleTime = 500;

    window.navigator.addIdleObserver(idleObserversArray[3]); //msg3
    window.navigator.addIdleObserver(idleObserversArray[4]); //msg4
    window.navigator.addIdleObserver(idleObserversArray[1]); //msg1
    window.navigator.addIdleObserver(idleObserversArray[2]); //msg2
    passed = false;

    idleServiceObj.idleTime = 1000;
    idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
  }

  /*
    - AddOutOfOrderActiveCleanUp()
  */
  function AddOutOfOrderActiveCleanUp() {
    dump("\nAddOutOfOrderActiveCleanUp()\n");
    dump("==============================\n");
    ResetVars();
    currTestCaseNum = tcAddOutOfOrderActive;
    cleanUp = false;
    idleServiceObj.idleTime = 4500;

    for (var i=1; i<5; i++) {
      window.navigator.removeIdleObserver(idleObserversArray[i]);
    }
    dump("JS AddOutOfOrderActiveCleanUp() DONE\n");
    if (AddOutOfOrderIdleEnabled) {
      AddOutOfOrderIdle();
    }
    else {
      dump("Finishing testing idle API.\n");
      SimpleTest.finish();
    }
  }

  /*
    - AddOutOfOrderIdle()
  */
  function AddOutOfOrderIdle() {
    dump("\nAddOutOfOrderIdle()\n");
    dump("======================================================================\n");

    dump("\nJS AddOutOfOrderIdle\n");
    dump("JS NUM OBSERVERS: " + idleServiceObj.observers.length + "\n");

    if (!msg1Count && !msg2Count && !msg3Count) {
      ResetVars();
    }
    currTestCaseNum = tcAddOutOfOrderIdle;
    cleanUp = false;

    if (!msg1Count && !msg2Count && !msg3Count) {
      idleServiceObj.idleTime = 3100;
    }
    window.navigator.addIdleObserver(idleObserversArray[3]);
    if (!msg1Count && !msg2Count && !msg3Count) {
      idleServiceObj.testIdleBackService(idleObserversArray[3], "idle");
    }
  }

  /*
   - AddOutOfOrderIdleCleanUp()
  */
  function AddOutOfOrderIdleCleanUp() {
    ok(passed, "Failed test case: AddOutOfOrderIdle()");
    dump("\nAddOutOfOrderIdleCleanUp()\n");
    dump("==========================\n");
    ResetVars();
    currTestCaseNum = tcAddOutOfOrderIdle;
    cleanUp = true;
    idleServiceObj.idleTime = 4100;

    for (var j=1; j<4; j++) {
      window.navigator.removeIdleObserver(idleObserversArray[j]);
    }
    window.navigator.removeIdleObserver(idleObserversArray[3]);

    if (idleServiceObj.observers.length === 1) {
      passed = true;
    }
    else {
      passed = false;
    }
    ok(passed, "Failed test case: AddOutOfOrderIdleCleanUp()");
    if (AddShiftLocalEnabled) {
      AddShiftLocal();
    }
    else {
      dump("Finished AddOutOfOrderIdleCleanUp() test.\n");
      SimpleTest.finish();
    }
  }

  /*
   * function AddShiftLocal()
   * - user is idle
   * - check that local idle timer is shifted correctly
   * - msg 1 fired when user is idle
   * - msg 3 fired when 3000
   * - msg 2 fired immediately when added at 3200 ms
   * - msg 4 fired by local timer.
   */
  function AddShiftLocal()
  {
    dump("\n\nTESTING CASE AddShiftLocal\n");
    dump("==============\n");

    ResetVars();
    currTestCaseNum = tcAddShiftLocal;
    idleServiceObj.idleTime = 500;

    window.navigator.addIdleObserver(idleObserversArray[1]);
    window.navigator.addIdleObserver(idleObserversArray[3]);
    window.navigator.addIdleObserver(idleObserversArray[4]);

    idleServiceObj.idleTime = 1000;
    idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
  }

  /*
   * function AddShiftLocalCleanUp()
   */
  function AddShiftLocalCleanUp()
  {
    dump("\n\nTESTING CASE AddShiftLocalCleanUp\n");
    dump("==============\n");

    ResetVars();
    currTestCaseNum = tcAddShiftLocal;

    for (var i=1; i<5; i++) {
      window.navigator.removeIdleObserver(idleObserversArray[i]);
    }
    dump("AddShiftLocalCleanUp() done clean up\n");
    if (AddNewLocalWhileAllIdleEnabled) {
      AddNewLocalWhileAllIdle();
    }
    else {
      dump("Finished testing AddShiftLocal()\n");
      SimpleTest.finish();
    }
  }

  /*
   * AddNewLocalWhileAllIdle()
   * - no local idle timer exists because all of the idle observers that were added had a requested
   *   idle time of < curr user idle time and so were fired immediately. No local timer was required.
   * - now add an idle observer whose requested idle time is > current use idle time and > min idle
   *   requested time in the list of idle observers.
   */
  function AddNewLocalWhileAllIdle()
  {
    dump("\n\nTESTING CASE AddNewLocalWhileAllIdle\n");
    dump("==============\n");

    ResetVars();
    currTestCaseNum = tcAddNewLocalWhileAllIdle;
    idleServiceObj.idleTime = 500;

    window.navigator.addIdleObserver(idleObserversArray[1]);
    window.navigator.addIdleObserver(idleObserversArray[2]);
    window.navigator.addIdleObserver(idleObserversArray[2]);

    idleServiceObj.idleTime = 1000;
    idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");
  }

  function AddNewLocalWhileAllIdleCleanUp()
  {
    dump("\n\nTESTING CASE AddNewLocalWhileAllIdleCleanUp\n");
    dump("==============\n");

    ResetVars();
    currTestCaseNum = tcAddNewLocalWhileAllIdle;

    window.navigator.removeIdleObserver(idleObserversArray[1]);
    window.navigator.removeIdleObserver(idleObserversArray[2]);
    window.navigator.removeIdleObserver(idleObserversArray[2]);
    window.navigator.removeIdleObserver(idleObserversArray[5]);

    if (ShiftLocalTimerBackEnabled) {
      ShiftLocalTimerBack();
    }
    else {
      dump("Finished testing TestActiveToActiveNotificationCleanUp()\n");
      SimpleTest.finish();
    }
  }

  /*
   * ShiftLocalTimerBack()
   * - add a new idle observer whose requested time is > current user idle time
   *   but < the current local timer that has been set.
   * - the local timer will need to be reset to fire the new msg added.
   * RESULT
   * - should print all of them in order
   */
  function ShiftLocalTimerBack()
  {
    dump("\n\nTESTING CASE ShiftLocalTimerBack()\n");
    dump("==============\n");

    ResetVars();
    currTestCaseNum = tcShiftLocalTimerBack;
    idleServiceObj.idleTime = 2100;

    window.navigator.addIdleObserver(idleObserversArray[2]);
    idleServiceObj.testIdleBackService(idleObserversArray[2], "idle");
  }

  function ShiftLocalTimerBackCleanUp()
  {
    dump("\n\nTESTING CASE ShiftLocalTimerBackCleanUp\n");
    dump("==============\n");

    ResetVars();
    currTestCaseNum = tcShiftLocalTimerBack;
    window.navigator.removeIdleObserver(idleObserversArray[2]);
    window.navigator.removeIdleObserver(idleObserversArray[4]);
    window.navigator.removeIdleObserver(idleObserversArray[5]);
    dump("ShiftLocalTimerBackCleanUp() done clean up\n");

    if (TestActiveToActiveNotificationEnabled) {
      TestActiveNotification();
    }
    else {
      dump("Finished testing AddNewLocalWhileAllIdle()\n");
      SimpleTest.finish();
    }   
  }

  function TestActiveNotification()
  {
    dump("\n\nTESTING CASE TestActiveNotification\n");
    dump("===============================================\n");

    ResetVars();
    currTestCaseNum = tcTestActiveToActiveNotification;

    idleServiceObj.idleTime = 500;
    window.navigator.addIdleObserver(idleObserversArray[1]);
    window.navigator.addIdleObserver(idleObserversArray[5]);
    idleServiceObj.idleTime = 1000;
    idleServiceObj.testIdleBackService(idleObserversArray[1], "idle");    
  }

  function TestActiveNotificationCleanUp()
  {
    dump("\n\nTESTING CASE TestActiveNotificationCleanUp\n");
    dump("===============================================\n");

    try {
      componentMgr.unregisterFactory(idleServiceCID, idleServiceObj);
    }
    catch(err) {
      dump("test_bug715041.xul: ShiftLocalTimerBackCleanUp() Failed to unregister factory, mock idle service!\n");
    }

    try {
      componentMgr.registerFactory(oldIdleServiceCID, "Re registering old idle service", idleServiceContractID, oldIdleServiceFactoryObj);
    }
    catch(err) {
      dump("test_bug715041.xul: ShiftLocalTimerBackCleanUp() Failed to register factory, original idle service!\n");
    }

    SimpleTest.finish();
  }

  /*
   * function AddRemoveIdleObserverWithInvalidTime()
   */
  function AddRemoveIdleObserverWithInvalidTime()
  {
    dump("\n\nTESTING CASE AddRemoveIdleObserverWithInvalidTime()\n");
    dump("==============\n");

    ResetVars();
    currTestCaseNum = tcAddRemoveIdleObserverWithInvalidTime;

    //while idle
    idleServiceObj.idleTime = 2100;
    var rv = window.navigator.addIdleObserver(idleObserversArray[6]);
    dump("rv: " + rv + "\n");
    rv = window.navigator.removeIdleObserver(idleObserversArray[6]);

    idleServiceObj.idleTime = 0;
    window.navigator.addIdleObserver(idleObserversArray[6]);
    window.navigator.removeIdleObserver(idleObserversArray[6]);

    SimpleTest.finish();
  }

  try {
    var idleServiceCID = Components.ID("287075a6-f968-4516-8043-406c46f503b4");
    var idleServiceContractID = "@mozilla.org/widget/idleservice;1";
    var oldIdleService = Components.classes[idleServiceContractID].getService(Components.interfaces.nsIIdleService);
  }
  catch(ex) {
    dump("test_bug715041.xul: 1) Failed to get old idle service.\n");
  }

  try {
    // Registering new moch JS idle service
    var componentMgr = Components.manager.QueryInterface(Components.interfaces.nsIComponentRegistrar);
  }
  catch(err) {
    dump("test_bug715041.xul: Failed to query component registrar interface.\n");
  }

  try {
    var oldIdleServiceFactoryObj = componentMgr.getClassObjectByContractID(idleServiceContractID, Components.interfaces.nsIFactory);
  }
  catch(err) {
    dump("test_bug715041.xul: Failed to get old idle service.\n");
  }

  try {
    var oldIdleServiceCID = componentMgr.contractIDToCID(idleServiceContractID);
  }
  catch(err) {
    dump("test_bug715041.xul: Failed to convert ID to CID for old idle service.\n");
  }

  try {
    componentMgr.unregisterFactory(oldIdleServiceCID, oldIdleServiceFactoryObj);
  }
  catch(err) {
    dump("test_bug715041.xul: Failed to unregister old idle service factory object!\n");
  }

  try {
    componentMgr.registerFactory(idleServiceCID, "Test Simple Idle/Back Notifications", idleServiceContractID, idleServiceObj);
  }
  catch(err) {
    dump("test_bug715041.xul: Failed to register mock idle service.\n");
  }

  SimpleTest.waitForExplicitFinish();
  SimpleTest.requestLongerTimeout(10);

  AddOutOfOrderActiveEnabled = true;
  AddOutOfOrderIdleEnabled = true;
  AddNewLocalWhileAllIdleEnabled = true;
  TestActiveToActiveNotificationEnabled = true;
  AddShiftLocalEnabled = true;
  AddIdleObserverWithInvalidTimeEnabled = false;
  
  caseZero();  
  
    ]]>
    </script>
    </window>

