The Tor Browser: toolkit/mozapps/update/tests/chrome/utils.js@129ffea94266 (annotated)

toolkit/mozapps/update/tests/chrome/utils.js@129ffea94266 (annotated)

toolkit/mozapps/update/tests/chrome/utils.js

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/
  */
 /**
  * Test Definition
  *
  * Most tests can use an array named TESTS that will perform most if not all of
  * the necessary checks. Each element in the array must be an object with the
  * following possible properties. Additional properties besides the ones listed
  * below can be added as needed.
  *
  * overrideCallback (optional)
  *   The function to call for the next test. This is typically called when the
  *   wizard page changes but can also be called for other events by the previous
  *   test. If this property isn't defined then the defailtCallback function will
  *   be called. If this property is defined then all other properties are
  *   optional.
  *
  * pageid (required unless overrideCallback is specified)
  *   The expected pageid for the wizard. This property is required unless the
  *   overrideCallback property is defined.
  *
  * extraStartFunction (optional)
  *   The function to call at the beginning of the defaultCallback function. If
  *   the function returns true the defaultCallback function will return early
  *   which allows waiting for a specific condition to be evaluated in the
  *   function specified in the extraStartFunction property before continuing
  *   with the test.
  *
  * extraCheckFunction (optional)
  *   The function to call to perform extra checks in the defaultCallback
  *   function.
  *
  * extraDelayedCheckFunction (optional)
  *   The function to call to perform extra checks in the delayedDefaultCallback
  *   function.
  *
  * buttonStates (optional)
  *   A javascript object representing the expected hidden and disabled attribute
  *   values for the buttons of the current wizard page. The values are checked
  *   in the delayedDefaultCallback function. For information about the structure
  *   of this object refer to the getExpectedButtonStates and checkButtonStates
  *   functions.
  *
  * buttonClick (optional)
  *   The current wizard page button to click at the end of the
  *   delayedDefaultCallback function. If the buttonClick property is defined
  *   then the extraDelayedFinishFunction property can't be specified due to race
  *   conditions in some of the tests and if both of them are specified the test
  *   will intentionally throw.
  *
  * extraDelayedFinishFunction (optional)
  *   The function to call at the end of the delayedDefaultCallback function.
  *   If the extraDelayedFinishFunction property is defined then the buttonClick
  *   property can't be specified due to race conditions in some of the tests and
  *   if both of them are specified the test will intentionally throw.
  *
  * ranTest (should not be specified)
  *   When delayedDefaultCallback is called a property named ranTest is added to
  *   the current test so it is possible to verify that each test in the TESTS
  *   array has ran.
  *
  * prefHasUserValue (optional)
  *   For comparing the expected value defined by this property with the return
  *   value of prefHasUserValue using gPrefToCheck for the preference name in the
  *   checkPrefHasUserValue function.
  *
  * expectedRadioGroupSelectedIndex (optional)
  *   For comparing the expected selectedIndex attribute value of the wizard's
  *   license page radiogroup selectedIndex attribute in the
  *   checkRadioGroupSelectedIndex function.
  *
  * expectedRemoteContentState (optional)
  *   For comparing the expected remotecontent state attribute value of the
  *   wizard's billboard and license pages in the checkRemoteContentState and
  *   waitForRemoteContentLoaded functions.
  *
  *
  * Test Add-ons
  *
  * All tests include the test add-ons specified in the TEST_ADDONS array and
  * the only thing that can be configured is whether the noupdate test add-on is
  * disabled (see below). The add-on names are in the format of typename_X where
  * X is a number to make the add-on ID unique and typename is one of the values
  * specified below:
  *
  * appdisabled
  *   disabled by the application due to being incompatible with the current
  *   toolkit version.
  *
  * compatible
  *   compatible with the current toolkit version and the update's toolkit
  *   version.
  *
  * noupdate
  *   the add-on is compatible with the current toolkit version and does not have
  *   an update to make it compatible with the update's toolkit version. Tests
  *   that need to have all add-ons compatible for the application update can
  *   disable this add-on by setting the gDisableNoUpdateAddon variable to true.
  *
  * updatecompatibility
  *   the add-on is compatible with the current toolkit version and has a
  *   compatibility update to make it compatible with the update's toolkit
  *   version.
  *
  * updateversion
  *   the add-on is compatible with the current toolkit version and has a version
  *   update to make it compatible with the update's toolkit version.
  *
  * userdisabled
  *   disabled by the user and compatible with the current toolkit version but
  *   not the update's toolkit version. This add-on will be disabled after its
  *   install completes.
  */
 Components.utils.import("resource://gre/modules/AddonManager.jsm");
 // The tests have to use the pageid instead of the pageIndex due to the
 // app update wizard's access method being random.
 const PAGEID_DUMMY            = "dummy";                 // Done
 const PAGEID_CHECKING         = "checking";              // Done
 const PAGEID_PLUGIN_UPDATES   = "pluginupdatesfound";
 const PAGEID_NO_UPDATES_FOUND = "noupdatesfound";        // Done
 const PAGEID_MANUAL_UPDATE    = "manualUpdate"; // Tested on license load failure
 const PAGEID_UNSUPPORTED      = "unsupported";           // Done
 const PAGEID_INCOMPAT_CHECK   = "incompatibleCheck";     // Done
 const PAGEID_FOUND_BASIC      = "updatesfoundbasic";     // Done
 const PAGEID_FOUND_BILLBOARD  = "updatesfoundbillboard"; // Done
 const PAGEID_LICENSE          = "license";               // Done
 const PAGEID_INCOMPAT_LIST    = "incompatibleList";      // Done
 const PAGEID_DOWNLOADING      = "downloading";           // Done
 const PAGEID_ERRORS           = "errors";                // Done
 const PAGEID_ERROR_EXTRA      = "errorextra";            // Done
 const PAGEID_ERROR_PATCHING   = "errorpatching";         // Done
 const PAGEID_FINISHED         = "finished";              // Done
 const PAGEID_FINISHED_BKGRD   = "finishedBackground";    // Done
 const PAGEID_INSTALLED        = "installed";             // Done
 const UPDATE_WINDOW_NAME = "Update:Wizard";
 const URL_HOST = "http://example.com";
 const URL_PATH_UPDATE_XML = "/chrome/toolkit/mozapps/update/tests/chrome/update.sjs";
 const REL_PATH_DATA = "chrome/toolkit/mozapps/update/tests/data";
 const URL_HTTP_UPDATE_XML = URL_HOST + URL_PATH_UPDATE_XML;
 const URL_HTTPS_UPDATE_XML = "https://example.com" + URL_PATH_UPDATE_XML;
 const URI_UPDATE_PROMPT_DIALOG  = "chrome://mozapps/content/update/updates.xul";
 const ADDON_ID_SUFFIX = "@appupdatetest.mozilla.org";
 const ADDON_PREP_DIR = "appupdateprep";
 // Preference for storing add-ons that are disabled by the tests to prevent them
 // from interefering with the tests.
 const PREF_DISABLEDADDONS = "app.update.test.disabledAddons";
 const PREF_EM_HOTFIX_ID = "extensions.hotfix.id";
 const TEST_ADDONS = [ "appdisabled_1", "appdisabled_2",
                       "compatible_1", "compatible_2",
                       "noupdate_1", "noupdate_2",
                       "updatecompatibility_1", "updatecompatibility_2",
                       "updateversion_1", "updateversion_2",
                       "userdisabled_1", "userdisabled_2", "hotfix" ];
 var gURLData = URL_HOST + "/" + REL_PATH_DATA + "/";
 var gTestTimeout = 240000; // 4 minutes
 var gTimeoutTimer;
 // The number of SimpleTest.executeSoon calls to perform when waiting on an
 // update window to close before giving up.
 const CLOSE_WINDOW_TIMEOUT_MAXCOUNT = 10;
 // Counter for the SimpleTest.executeSoon when waiting on an update window to
 // close before giving up.
 var gCloseWindowTimeoutCounter = 0;
 // The following vars are for restoring previous preference values (if present)
 // when the test finishes.
 var gAppUpdateEnabled;            // app.update.enabled
 var gAppUpdateMetroEnabled;       // app.update.metro.enabled
 var gAppUpdateServiceEnabled;     // app.update.service.enabled
 var gAppUpdateStagingEnabled;     // app.update.staging.enabled
 var gAppUpdateURLDefault;         // app.update.url (default prefbranch)
 var gAppUpdateURL;                // app.update.url.override
 var gExtUpdateURL;                // extensions.update.url
 var gTestCounter = -1;
 var gWin;
 var gDocElem;
 var gPrefToCheck;
 var gDisableNoUpdateAddon = false;
 // Set to true to log additional information for debugging. To log additional
 // information for an individual test set DEBUG_AUS_TEST to true in the test's
 // onload function.
 var DEBUG_AUS_TEST = true;
 #include ../shared.js
 /**
  * The current test in TESTS array.
  */
 this.__defineGetter__("gTest", function() {
   return TESTS[gTestCounter];
 });
 /**
  * The current test's callback. This will either return the callback defined in
  * the test's overrideCallback property or defaultCallback if the
  * overrideCallback property is undefined.
  */
 this.__defineGetter__("gCallback", function() {
   return gTest.overrideCallback ? gTest.overrideCallback
                                 : defaultCallback;
 });
 /**
  * The remotecontent element for the current page if one exists or null if a
  * remotecontent element doesn't exist.
  */
 this.__defineGetter__("gRemoteContent", function() {
   switch (gTest.pageid) {
     case PAGEID_FOUND_BILLBOARD:
       return gWin.document.getElementById("updateMoreInfoContent");
     case PAGEID_LICENSE:
       return gWin.document.getElementById("licenseContent");
   }
   return null;
 });
 /**
  * The state for the remotecontent element if one exists or null if a
  * remotecontent element doesn't exist.
  */
 this.__defineGetter__("gRemoteContentState", function() {
   if (gRemoteContent) {
     return gRemoteContent.getAttribute("state");
   }
   return null;
 });
 /**
  * The radiogroup for the license page.
  */
 this.__defineGetter__("gAcceptDeclineLicense", function() {
   return gWin.document.getElementById("acceptDeclineLicense");
 });
 /**
  * The listbox for the incompatibleList page.
  */
 this.__defineGetter__("gIncompatibleListbox", function() {
   return gWin.document.getElementById("incompatibleListbox");
 });
 /**
  * Default test run function that can be used by most tests. This function uses
  * protective measures to prevent the test from failing provided by
  * |runTestDefaultWaitForWindowClosed| helper functions to prevent failure due
  * to a previous test failure.
  */
 function runTestDefault() {
   debugDump("entering");
   if (!("@mozilla.org/zipwriter;1" in AUS_Cc)) {
     ok(false, "nsIZipWriter is required to run these tests");
     return;
   }
   SimpleTest.waitForExplicitFinish();
   runTestDefaultWaitForWindowClosed();
 }
 /**
  * If an update window is found SimpleTest.executeSoon can callback before the
  * update window is fully closed especially with debug builds. If an update
  * window is found this function will call itself using SimpleTest.executeSoon
  * up to the amount declared in CLOSE_WINDOW_TIMEOUT_MAXCOUNT until the update
  * window has closed before continuing the test.
  */
 function runTestDefaultWaitForWindowClosed() {
   gCloseWindowTimeoutCounter++;
   if (gCloseWindowTimeoutCounter > CLOSE_WINDOW_TIMEOUT_MAXCOUNT) {
     try {
       finishTest();
     }
     catch (e) {
       finishTestDefault();
     }
     return;
   }
   // The update window should not be open at this time. If it is the call to
   // |closeUpdateWindow| will close it and cause the test to fail.
   if (closeUpdateWindow()) {
     SimpleTest.executeSoon(runTestDefaultWaitForWindowClosed);
   }
   else {
     Services.ww.registerNotification(gWindowObserver);
     gCloseWindowTimeoutCounter = 0;
     setupFiles();
     setupPrefs();
     removeUpdateDirsAndFiles();
     reloadUpdateManagerData();
     setupAddons(runTest);
   }
 }
 /**
  * Default test finish function that can be used by most tests. This function
  * uses protective measures to prevent the next test from failing provided by
  * |finishTestDefaultWaitForWindowClosed| helper functions to prevent failure
  * due to an update window being left open.
  */
 function finishTestDefault() {
   debugDump("entering");
   if (gTimeoutTimer) {
     gTimeoutTimer.cancel();
     gTimeoutTimer = null;
   }
   if (gChannel) {
     debugDump("channel = " + gChannel);
     gChannel = null;
     gPrefRoot.removeObserver(PREF_APP_UPDATE_CHANNEL, observer);
   }
   verifyTestsRan();
   resetPrefs();
   resetFiles();
   removeUpdateDirsAndFiles();
   reloadUpdateManagerData();
   Services.ww.unregisterNotification(gWindowObserver);
   if (gDocElem) {
     gDocElem.removeEventListener("pageshow", onPageShowDefault, false);
   }
   finishTestDefaultWaitForWindowClosed();
 }
 /**
  * nsITimerCallback for the timeout timer to cleanly finish a test if the Update
  * Window doesn't close for a test. This allows the next test to run properly if
  * a previous test fails.
  *
  * @param  aTimer
  *         The nsITimer that fired.
  */
 function finishTestTimeout(aTimer) {
   ok(false, "Test timed out. Maximum time allowed is " + (gTestTimeout / 1000) +
      " seconds");
   try {
     finishTest();
   }
   catch (e) {
     finishTestDefault();
   }
 }
 /**
  * If an update window is found SimpleTest.executeSoon can callback before the
  * update window is fully closed especially with debug builds. If an update
  * window is found this function will call itself using SimpleTest.executeSoon
  * up to the amount declared in CLOSE_WINDOW_TIMEOUT_MAXCOUNT until the update
  * window has closed before finishing the test.
  */
 function finishTestDefaultWaitForWindowClosed() {
   gCloseWindowTimeoutCounter++;
   if (gCloseWindowTimeoutCounter > CLOSE_WINDOW_TIMEOUT_MAXCOUNT) {
     SimpleTest.finish();
     return;
   }
   // The update window should not be open at this time. If it is the call to
   // |closeUpdateWindow| will close it and cause the test to fail.
   if (closeUpdateWindow()) {
     SimpleTest.executeSoon(finishTestDefaultWaitForWindowClosed);
   }
   else {
     SimpleTest.finish();
   }
 }
 /**
  * Default callback for the wizard's documentElement pageshow listener. This
  * will return early for event's where the originalTarget's nodeName is not
  * wizardpage.
  */
 function onPageShowDefault(aEvent) {
   if (!gTimeoutTimer) {
     debugDump("gTimeoutTimer is null... returning early");
     return;
   }
   // Return early if the event's original target isn't for a wizardpage element.
   // This check is necessary due to the remotecontent element firing pageshow.
   if (aEvent.originalTarget.nodeName != "wizardpage") {
     debugDump("only handles events with an originalTarget nodeName of " +
               "|wizardpage|. aEvent.originalTarget.nodeName = " +
               aEvent.originalTarget.nodeName + "... returning early");
     return;
   }
   gTestCounter++;
   gCallback(aEvent);
 }
 /**
  * Default callback that can be used by most tests.
  */
 function defaultCallback(aEvent) {
   if (!gTimeoutTimer) {
     debugDump("gTimeoutTimer is null... returning early");
     return;
   }
   debugDump("entering - TESTS[" + gTestCounter + "], pageid: " + gTest.pageid +
             ", aEvent.originalTarget.nodeName: " +
             aEvent.originalTarget.nodeName);
   if (gTest && gTest.extraStartFunction) {
     debugDump("calling extraStartFunction " + gTest.extraStartFunction.name);
     if (gTest.extraStartFunction(aEvent)) {
       debugDump("extraStartFunction early return");
       return;
     }
   }
   is(gDocElem.currentPage.pageid, gTest.pageid,
      "Checking currentPage.pageid equals " + gTest.pageid + " in pageshow");
   // Perform extra checks if specified by the test
   if (gTest.extraCheckFunction) {
     debugDump("calling extraCheckFunction " + gTest.extraCheckFunction.name);
     gTest.extraCheckFunction();
   }
   // The wizard page buttons' disabled and hidden attributes are set after the
   // pageshow event so use executeSoon to allow them to be set so their disabled
   // and hidden attribute values can be checked.
   SimpleTest.executeSoon(delayedDefaultCallback);
 }
 /**
  * Delayed default callback called using executeSoon in defaultCallback which
  * allows the wizard page buttons' disabled and hidden attributes to be set
  * before checking their values.
  */
 function delayedDefaultCallback() {
   if (!gTimeoutTimer) {
     debugDump("gTimeoutTimer is null... returning early");
     return;
   }
   if (!gTest) {
     debugDump("gTest is null... returning early");
     return;
   }
   debugDump("entering - TESTS[" + gTestCounter + "], pageid: " + gTest.pageid);
   // Verify the pageid hasn't changed after executeSoon was called.
   is(gDocElem.currentPage.pageid, gTest.pageid,
      "Checking currentPage.pageid equals " + gTest.pageid + " after " +
      "executeSoon");
   checkButtonStates();
   // Perform delayed extra checks if specified by the test
   if (gTest.extraDelayedCheckFunction) {
     debugDump("calling extraDelayedCheckFunction " +
               gTest.extraDelayedCheckFunction.name);
     gTest.extraDelayedCheckFunction();
   }
   // Used to verify that this test has been performed
   gTest.ranTest = true;
   if (gTest.buttonClick) {
     debugDump("clicking " + gTest.buttonClick + " button");
     if(gTest.extraDelayedFinishFunction) {
       throw("Tests cannot have a buttonClick and an extraDelayedFinishFunction property");
     }
     gDocElem.getButton(gTest.buttonClick).click();
   }
   else if (gTest.extraDelayedFinishFunction) {
     debugDump("calling extraDelayedFinishFunction " +
               gTest.extraDelayedFinishFunction.name);
     gTest.extraDelayedFinishFunction();
   }
 }
 /**
  * Checks the wizard page buttons' disabled and hidden attributes values are
  * correct. If an expected button id is not specified then the expected disabled
  * and hidden attribute value is true.
  */
 function checkButtonStates() {
   debugDump("entering - TESTS[" + gTestCounter + "], pageid: " + gTest.pageid);
   const buttonNames = ["extra1", "extra2", "back", "next", "finish", "cancel"];
   let buttonStates = getExpectedButtonStates();
   buttonNames.forEach(function(aButtonName) {
     let button = gDocElem.getButton(aButtonName);
     let hasHidden = aButtonName in buttonStates &&
                     "hidden" in buttonStates[aButtonName];
     let hidden = hasHidden ? buttonStates[aButtonName].hidden : true;
     let hasDisabled = aButtonName in buttonStates &&
                       "disabled" in buttonStates[aButtonName];
     let disabled = hasDisabled ? buttonStates[aButtonName].disabled : true;
     is(button.hidden, hidden, "Checking " + aButtonName + " button " +
        "hidden attribute value equals " + (hidden ? "true" : "false"));
     is(button.disabled, disabled, "Checking " + aButtonName + " button " +
        "disabled attribute value equals " + (disabled ? "true" : "false"));
   });
 }
 /**
  * Returns the expected disabled and hidden attribute values for the buttons of
  * the current wizard page.
  */
 function getExpectedButtonStates() {
   // Allow individual tests to override the expected button states.
   if (gTest.buttonStates) {
     return gTest.buttonStates;
   }
   switch (gTest.pageid) {
     case PAGEID_CHECKING:
     case PAGEID_INCOMPAT_CHECK:
       return { cancel: { disabled: false, hidden: false } };
     case PAGEID_FOUND_BASIC:
     case PAGEID_FOUND_BILLBOARD:
       if (gTest.neverButton) {
         return { extra1: { disabled: false, hidden: false },
                  extra2: { disabled: false, hidden: false },
                  next  : { disabled: false, hidden: false } }
       }
       return { extra1: { disabled: false, hidden: false },
                next  : { disabled: false, hidden: false } };
     case PAGEID_LICENSE:
       if (gRemoteContentState != "loaded" ||
           gAcceptDeclineLicense.selectedIndex != 0) {
         return { extra1: { disabled: false, hidden: false },
                  next  : { disabled: true, hidden: false } };
       }
       return { extra1: { disabled: false, hidden: false },
                next  : { disabled: false, hidden: false } };
     case PAGEID_INCOMPAT_LIST:
       return { extra1: { disabled: false, hidden: false },
                next  : { disabled: false, hidden: false } };
     case PAGEID_DOWNLOADING:
       return { extra1: { disabled: false, hidden: false } };
     case PAGEID_NO_UPDATES_FOUND:
     case PAGEID_MANUAL_UPDATE:
     case PAGEID_UNSUPPORTED:
     case PAGEID_ERRORS:
     case PAGEID_ERROR_EXTRA:
     case PAGEID_INSTALLED:
       return { finish: { disabled: false, hidden: false } };
     case PAGEID_ERROR_PATCHING:
       return { next  : { disabled: false, hidden: false } };
     case PAGEID_FINISHED:
     case PAGEID_FINISHED_BKGRD:
       return { extra1: { disabled: false, hidden: false },
                finish: { disabled: false, hidden: false } };
   }
   return null;
 }
 /**
  * Adds a load event listener to the current remotecontent element.
  */
 function addRemoteContentLoadListener() {
   debugDump("entering - TESTS[" + gTestCounter + "], pageid: " + gTest.pageid);
   gRemoteContent.addEventListener("load", remoteContentLoadListener, false);
 }
 /**
  * The nsIDOMEventListener for a remotecontent load event.
  */
 function remoteContentLoadListener(aEvent) {
   // Return early if the event's original target's nodeName isn't remotecontent.
   if (aEvent.originalTarget.nodeName != "remotecontent") {
     debugDump("only handles events with an originalTarget nodeName of " +
               "|remotecontent|. aEvent.originalTarget.nodeName = " +
               aEvent.originalTarget.nodeName);
     return;
   }
   gTestCounter++;
   gCallback(aEvent);
 }
 /**
  * Waits until a remotecontent element to finish loading which is determined
  * by the current test's expectedRemoteContentState property and then removes
  * the event listener.
  *
  * Note: tests that use this function should not test the state of the
  *      remotecontent since this will check the expected state.
  *
  * @return false if the remotecontent has loaded and its state is the state
  *         specified in the current test's expectedRemoteContentState
  *         property... otherwise true.
  */
 function waitForRemoteContentLoaded(aEvent) {
   // Return early until the remotecontent has loaded with the state that is
   // expected or isn't the event's originalTarget.
   if (gRemoteContentState != gTest.expectedRemoteContentState ||
       aEvent.originalTarget != gRemoteContent) {
     debugDump("returning early\n" +
               "gRemoteContentState: " + gRemoteContentState + "\n" +
               "expectedRemoteContentState: " +
               gTest.expectedRemoteContentState + "\n" +
               "aEvent.originalTarget.nodeName: " +
               aEvent.originalTarget.nodeName);
     return true;
   }
   gRemoteContent.removeEventListener("load", remoteContentLoadListener, false);
   return false;
 }
 /**
  * Compares the value of the remotecontent state attribute with the value
  * specified in the test's expectedRemoteContentState property.
  */
 function checkRemoteContentState() {
   is(gRemoteContentState, gTest.expectedRemoteContentState, "Checking remote " +
      "content state equals " + gTest.expectedRemoteContentState + " - pageid " +
      gTest.pageid);
 }
 /**
  * Adds a select event listener to the license radiogroup element and clicks
  * the radio element specified in the current test's radioClick property.
  */
 function addRadioGroupSelectListenerAndClick() {
   debugDump("entering - TESTS[" + gTestCounter + "], pageid: " + gTest.pageid);
   gAcceptDeclineLicense.addEventListener("select", radioGroupSelectListener,
                                          false);
   gWin.document.getElementById(gTest.radioClick).click();
 }
 /**
  * The nsIDOMEventListener for the license radiogroup select event.
  */
 function radioGroupSelectListener(aEvent) {
   // Return early if the event's original target's nodeName isn't radiogroup.
   if (aEvent.originalTarget.nodeName != "radiogroup") {
     debugDump("only handles events with an originalTarget nodeName of " +
               "|radiogroup|. aEvent.originalTarget.nodeName = " +
               aEvent.originalTarget.nodeName);
     return;
   }
   gAcceptDeclineLicense.removeEventListener("select", radioGroupSelectListener,
                                             false);
   gTestCounter++;
   gCallback(aEvent);
 }
 /**
  * Compares the value of the License radiogroup's selectedIndex attribute with
  * the value specified in the test's expectedRadioGroupSelectedIndex property.
  */
 function checkRadioGroupSelectedIndex() {
   is(gAcceptDeclineLicense.selectedIndex, gTest.expectedRadioGroupSelectedIndex,
      "Checking license radiogroup selectedIndex equals " +
      gTest.expectedRadioGroupSelectedIndex);
 }
 /**
  * Checks that only incompatible add-ons (e.g. noupdate_X add-ons) that don't
  * have an update are listed in the add-ons incompatible list.
  */
 function checkIncompatbleList() {
   for (let i = 0; i < gIncompatibleListbox.itemCount; i++) {
     let label = gIncompatibleListbox.getItemAtIndex(i).label;
     // Use indexOf since locales can change the text displayed
     ok(label.indexOf("noupdate") != -1, "Checking that only incompatible " +
        "add-ons that don't have an update are listed in the incompatible list");
   }
 }
 /**
  * Compares the return value of prefHasUserValue for the preference specified in
  * gPrefToCheck with the value passed in the aPrefHasValue parameter or the
  * value specified in the current test's prefHasUserValue property if
  * aPrefHasValue is undefined.
  *
  * @param  aPrefHasValue (optional)
  *         The expected value returned from prefHasUserValue for the preference
  *         specified in gPrefToCheck. If aPrefHasValue is undefined the value
  *         of the current test's prefHasUserValue property will be used.
  */
 function checkPrefHasUserValue(aPrefHasValue) {
   let prefHasUserValue = aPrefHasValue === undefined ? gTest.prefHasUserValue
                                                      : aPrefHasValue;
   is(Services.prefs.prefHasUserValue(gPrefToCheck), prefHasUserValue,
      "Checking prefHasUserValue for preference " + gPrefToCheck + " equals " +
      (prefHasUserValue ? "true" : "false"));
 }
 /**
  * Checks whether the link is hidden (general background update check error or
  * a certificate attribute check error with an update) or not (certificate
  * attribute check error without an update) on the errorextra page and that the
  * app.update.cert.errors and app.update.backgroundErrors preferences do not
  & have a user value.
  *
  * @param  aShouldBeHidden (optional)
  *         The expected value for the label's hidden attribute for the link. If
  *         aShouldBeHidden is undefined the value of the current test's
  *         shouldBeHidden property will be used.
  */
 function checkErrorExtraPage(aShouldBeHidden) {
   let shouldBeHidden = aShouldBeHidden === undefined ? gTest.shouldBeHidden
                                                      : aShouldBeHidden;
   is(gWin.document.getElementById("errorExtraLinkLabel").hidden, shouldBeHidden,
      "Checking errorExtraLinkLabel hidden attribute equals " +
      (shouldBeHidden ? "true" : "false"));
   is(gWin.document.getElementById(gTest.displayedTextElem).hidden, false,
      "Checking " + gTest.displayedTextElem + " should not be hidden");
   ok(!Services.prefs.prefHasUserValue(PREF_APP_UPDATE_CERT_ERRORS),
      "Preference " + PREF_APP_UPDATE_CERT_ERRORS + " should not have a " +
      "user value");
   ok(!Services.prefs.prefHasUserValue(PREF_APP_UPDATE_BACKGROUNDERRORS),
      "Preference " + PREF_APP_UPDATE_BACKGROUNDERRORS + " should not have a " +
      "user value");
 }
 /**
  * Gets the update version info for the update url parameters to send to
  * update.sjs.
  *
  * @param  aAppVersion (optional)
  *         The application version for the update snippet. If not specified the
  *         current application version will be used.
  * @param  aPlatformVersion (optional)
  *         The platform version for the update snippet. If not specified the
  *         current platform version will be used.
  * @return The url parameters for the application and platform version to send
  *         to update.sjs.
  */
 function getVersionParams(aAppVersion, aPlatformVersion) {
   let appInfo = Services.appinfo;
   return "&appVersion=" + (aAppVersion ? aAppVersion : appInfo.version) +
          "&platformVersion=" + (aPlatformVersion ? aPlatformVersion
                                                  : appInfo.platformVersion);
 }
 /**
  * Gets an application version that is greater than the current application
  * version. The version is created by taking the first sequence from the current
  * application version and adding 1 to it.
  *
  * @return A version string greater than the current application version string.
  */
 function getNewerAppVersion() {
   let appVersion = Services.appinfo.version.split(".")[0];
   appVersion++;
   return appVersion;
 }
 /**
  * Gets a platform version that is greater than the current platform version.
  * The version is created by taking the first sequence from the current platform
  * version and adding 1 to it.
  *
  * @return A version string greater than the current platform version string.
  */
 function getNewerPlatformVersion() {
   let platformVersion = Services.appinfo.platformVersion.split(".")[0];
   platformVersion++;
   return platformVersion;
 }
 /**
  * Verifies that all tests ran.
  */
 function verifyTestsRan() {
   debugDump("entering");
   // Return early if there are no tests defined.
   if (!TESTS) {
     return;
   }
   gTestCounter = -1;
   for (let i = 0; i < TESTS.length; ++i) {
     gTestCounter++;
     let test = TESTS[i];
     let msg = "Checking if TESTS[" + i + "] test was performed... " +
               "callback function name = " + gCallback.name + ", " +
               "pageid = " + test.pageid;
     ok(test.ranTest, msg);
   }
 }
 /**
  * Creates a backup of files the tests need to modify so they can be restored to
  * the original file when the test has finished and then modifies the files.
  */
 function setupFiles() {
   // Backup the updater-settings.ini file if it exists by moving it.
   let baseAppDir = getAppBaseDir();
   let updateSettingsIni = baseAppDir.clone();
   updateSettingsIni.append(FILE_UPDATE_SETTINGS_INI);
   if (updateSettingsIni.exists()) {
     updateSettingsIni.moveTo(baseAppDir, FILE_UPDATE_SETTINGS_INI_BAK);
   }
   updateSettingsIni = baseAppDir.clone();
   updateSettingsIni.append(FILE_UPDATE_SETTINGS_INI);
   writeFile(updateSettingsIni, UPDATE_SETTINGS_CONTENTS);
 }
 /**
  * Sets the most common preferences used by tests to values used by the majority
  * of the tests and when necessary saves the preference's original values if
  * present so they can be set back to the original values when the test has
  * finished.
  */
 function setupPrefs() {
   if (DEBUG_AUS_TEST) {
     Services.prefs.setBoolPref(PREF_APP_UPDATE_LOG, true);
   }
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_URL_OVERRIDE)) {
     gAppUpdateURL = Services.prefs.getCharPref(PREF_APP_UPDATE_URL_OVERRIDE);
   }
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_ENABLED)) {
     gAppUpdateEnabled = Services.prefs.getBoolPref(PREF_APP_UPDATE_ENABLED);
   }
   Services.prefs.setBoolPref(PREF_APP_UPDATE_ENABLED, true);
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_METRO_ENABLED)) {
     gAppUpdateMetroEnabled = Services.prefs.getBoolPref(PREF_APP_UPDATE_METRO_ENABLED);
   }
   Services.prefs.setBoolPref(PREF_APP_UPDATE_METRO_ENABLED, true);
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_SERVICE_ENABLED)) {
     gAppUpdateServiceEnabled = Services.prefs.getBoolPref(PREF_APP_UPDATE_SERVICE_ENABLED);
   }
   Services.prefs.setBoolPref(PREF_APP_UPDATE_SERVICE_ENABLED, false);
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_STAGING_ENABLED)) {
     gAppUpdateStagingEnabled = Services.prefs.getBoolPref(PREF_APP_UPDATE_STAGING_ENABLED);
   }
   Services.prefs.setBoolPref(PREF_APP_UPDATE_STAGING_ENABLED, false);
   if (Services.prefs.prefHasUserValue(PREF_EXTENSIONS_UPDATE_URL)) {
     gExtUpdateURL = Services.prefs.getCharPref(PREF_EXTENSIONS_UPDATE_URL);
   }
   let extUpdateUrl = URL_HTTP_UPDATE_XML + "?addonID=%ITEM_ID%" +
                      "&platformVersion=" + getNewerPlatformVersion();
   Services.prefs.setCharPref(PREF_EXTENSIONS_UPDATE_URL, extUpdateUrl);
   Services.prefs.setIntPref(PREF_APP_UPDATE_IDLETIME, 0);
   Services.prefs.setIntPref(PREF_APP_UPDATE_PROMPTWAITTIME, 0);
   Services.prefs.setBoolPref(PREF_EXTENSIONS_STRICT_COMPAT, true);
   Services.prefs.setCharPref(PREF_EM_HOTFIX_ID, "hotfix" + ADDON_ID_SUFFIX);
 }
 /**
  * Restores files that were backed up for the tests and general file cleanup.
  */
 function resetFiles() {
   // Restore the backed up updater-settings.ini if it exists.
   let baseAppDir = getAppBaseDir();
   let updateSettingsIni = baseAppDir.clone();
   updateSettingsIni.append(FILE_UPDATE_SETTINGS_INI_BAK);
   if (updateSettingsIni.exists()) {
     updateSettingsIni.moveTo(baseAppDir, FILE_UPDATE_SETTINGS_INI);
   }
   // Not being able to remove the "updated" directory will not adversely affect
   // subsequent tests so wrap it in a try block and don't test whether its
   // removal was successful.
   let updatedDir = getUpdatedDir();
   if (updatedDir.exists()) {
     try {
       removeDirRecursive(updatedDir);
     }
     catch (e) {
       dump("Unable to remove directory\n" +
            "path: " + updatedDir.path + "\n" +
            "Exception: " + e + "\n");
     }
   }
 }
 /**
  * Resets the most common preferences used by tests to their original values.
  */
 function resetPrefs() {
   if (gAppUpdateURL !== undefined) {
     Services.prefs.setCharPref(PREF_APP_UPDATE_URL_OVERRIDE, gAppUpdateURL);
   }
   else if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_URL_OVERRIDE)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_URL_OVERRIDE);
   }
   if (gAppUpdateURLDefault) {
     gDefaultPrefBranch.setCharPref(PREF_APP_UPDATE_URL, gAppUpdateURLDefault);
   }
   if (gAppUpdateEnabled !== undefined) {
     Services.prefs.setBoolPref(PREF_APP_UPDATE_ENABLED, gAppUpdateEnabled);
   }
   else if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_ENABLED)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_ENABLED);
   }
   if (gAppUpdateMetroEnabled !== undefined) {
     Services.prefs.setBoolPref(PREF_APP_UPDATE_METRO_ENABLED, gAppUpdateMetroEnabled);
   }
   else if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_METRO_ENABLED)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_METRO_ENABLED);
   }
   if (gAppUpdateServiceEnabled !== undefined) {
     Services.prefs.setBoolPref(PREF_APP_UPDATE_SERVICE_ENABLED, gAppUpdateServiceEnabled);
   }
   else if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_SERVICE_ENABLED)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_SERVICE_ENABLED);
   }
   if (gAppUpdateStagingEnabled !== undefined) {
     Services.prefs.setBoolPref(PREF_APP_UPDATE_STAGING_ENABLED, gAppUpdateStagingEnabled);
   }
   else if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_STAGING_ENABLED)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_STAGING_ENABLED);
   }
   if (gExtUpdateURL !== undefined) {
     Services.prefs.setCharPref(PREF_EXTENSIONS_UPDATE_URL, gExtUpdateURL);
   }
   else if (Services.prefs.prefHasUserValue(PREF_EXTENSIONS_UPDATE_URL)) {
     Services.prefs.clearUserPref(PREF_EXTENSIONS_UPDATE_URL);
   }
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_IDLETIME)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_IDLETIME);
   }
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_PROMPTWAITTIME)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_PROMPTWAITTIME);
   }
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_URL_DETAILS)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_URL_DETAILS);
   }
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_SHOW_INSTALLED_UI)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_SHOW_INSTALLED_UI);
   }
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_NOTIFIEDUNSUPPORTED)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_NOTIFIEDUNSUPPORTED);
   }
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_LOG)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_LOG);
   }
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_CERT_ERRORS)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_CERT_ERRORS);
   }
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_CERT_MAXERRORS)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_CERT_MAXERRORS);
   }
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_BACKGROUNDERRORS)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_BACKGROUNDERRORS);
   }
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_BACKGROUNDMAXERRORS)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_BACKGROUNDMAXERRORS);
   }
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_CERT_INVALID_ATTR_NAME)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_CERT_INVALID_ATTR_NAME);
   }
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_CERT_REQUIREBUILTIN)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_CERT_REQUIREBUILTIN);
   }
   if (Services.prefs.prefHasUserValue(PREF_APP_UPDATE_CERT_CHECKATTRS)) {
     Services.prefs.clearUserPref(PREF_APP_UPDATE_CERT_CHECKATTRS);
   }
   try {
     CERT_ATTRS.forEach(function(aCertAttrName) {
       Services.prefs.clearUserPref(PREF_APP_UPDATE_CERTS_BRANCH + "1." +
                                    aCertAttrName);
     });
   }
   catch (e) {
   }
   try {
     Services.prefs.deleteBranch(PREF_APP_UPDATE_NEVER_BRANCH);
   }
   catch(e) {
   }
   if (Services.prefs.prefHasUserValue(PREF_EXTENSIONS_STRICT_COMPAT)) {
 		Services.prefs.clearUserPref(PREF_EXTENSIONS_STRICT_COMPAT);
   }
   if (Services.prefs.prefHasUserValue(PREF_EM_HOTFIX_ID)) {
     Services.prefs.clearUserPref(PREF_EM_HOTFIX_ID);
   }
 }
 function setupTimer(aTestTimeout) {
   gTestTimeout = aTestTimeout;
   if (gTimeoutTimer) {
     gTimeoutTimer.cancel();
     gTimeoutTimer = null;
   }
   gTimeoutTimer = AUS_Cc["@mozilla.org/timer;1"].
                   createInstance(AUS_Ci.nsITimer);
   gTimeoutTimer.initWithCallback(finishTestTimeout, gTestTimeout,
                                  AUS_Ci.nsITimer.TYPE_ONE_SHOT);
 }
 /**
  * Disables pre-existing add-ons so they don't interfere with the tests,
  * installs the test add-ons, sets the noupdate test add-ons' userDisabled value
  * for the test, and calls the callback specified in the aCallback parameter. If
  * the app.update.test.disabledAddons has a user value then setting the noupdate
  * test add-ons' userDisabled value for the test is the only thing that is done.
  *
  * @param  aCallback
  *         A callback to call after all operations have completed.
  */
 function setupAddons(aCallback) {
   debugDump("entering");
   // Sets the appropriate userDisabled value for the noupdate test add-ons based
   // on the value of gDisableNoUpdateAddon and calls the callback specified in
   // setupAddons aCallback parameter.
   function setNoUpdateAddonsDisabledState() {
     AddonManager.getAllAddons(function(aAddons) {
       aAddons.forEach(function(aAddon) {
         if (aAddon.name.indexOf("noupdate") != 0)
           return;
         if (gDisableNoUpdateAddon) {
           if (!aAddon.userDisabled) {
             aAddon.userDisabled = true;
           }
         }
         else {
           if (aAddon.userDisabled) {
             aAddon.userDisabled = false;
           }
         }
       });
       // Start the timout timer before the update window is displayed so it can
       // clean up tests that don't successfully display the update window.
       setupTimer(gTestTimeout);
       aCallback();
     });
   }
   // If the app.update.test.disabledAddons preference exists the pre-existing
   // add-ons have already been disabled so they don't interfere with the tests,
   // the test add-ons have already been installed, and the only thing that needs
   // to be done is setting the appropriate userDisabled value for the noupdate
   // test add-ons.
   if (Services.prefs.prefHasUserValue(PREF_DISABLEDADDONS)) {
     setNoUpdateAddonsDisabledState();
     return;
   }
   // Disable all pre-existing enabled addons so they don't interfere with the
   // tests.
   AddonManager.getAllAddons(function(aAddons) {
     let disabledAddons = [];
     aAddons.forEach(function(aAddon) {
       // If an addon's type equals plugin it is skipped since
       // checking plugins compatibility information isn't supported at this
       // time (also see bug 566787). Also, SCOPE_APPLICATION add-ons are
       // excluded by app update so there is no reason to disable them.
       if (aAddon.type != "plugin" && !aAddon.appDisabled &&
           !aAddon.userDisabled &&
           aAddon.scope != AddonManager.SCOPE_APPLICATION) {
         disabledAddons.push(aAddon);
         aAddon.userDisabled = true;
       }
     });
     // If there are no pre-existing add-ons the preference value will be an
     // empty string.
     Services.prefs.setCharPref(PREF_DISABLEDADDONS, disabledAddons.join(" "));
     // Install the test add-ons.
     let xpiFiles = getTestAddonXPIFiles();
     let xpiCount = xpiFiles.length;
     let installs = [];
     xpiFiles.forEach(function(aFile) {
       AddonManager.getInstallForFile(aFile, function(aInstall) {
         if (!aInstall) {
           throw "No AddonInstall created for " + aFile.path;
         }
         installs.push(aInstall);
         if (--xpiCount == 0) {
           let installCount = installs.length;
           function installCompleted(aInstall) {
             aInstall.removeListener(listener);
             if (getAddonTestType(aInstall.addon.name) == "userdisabled") {
               aInstall.addon.userDisabled = true;
             }
             if (--installCount == 0) {
               setNoUpdateAddonsDisabledState();
             }
           }
           let listener = {
             onDownloadFailed: installCompleted,
             onDownloadCancelled: installCompleted,
             onInstallFailed: installCompleted,
             onInstallCancelled: installCompleted,
             onInstallEnded: installCompleted
           };
           installs.forEach(function(aInstall) {
             aInstall.addListener(listener);
             aInstall.install();
           });
         }
       });
     });
   });
 }
 /**
  * Uninstalls the test add-ons, enables add-ons that were disabled when the
  * test started, and calls the callback specified in the aCallback parameter.
  *
  * @param  aCallback
  *         A callback to call after all operations have completed.
  */
 function resetAddons(aCallback) {
   debugDump("entering");
   // If test_9999_cleanup.xul is ran by itself then the test add-ons will not
   // have been installed and any pre-existing add-ons will not have been
   // disabled so return early.
   if (!Services.prefs.prefHasUserValue(PREF_DISABLEDADDONS)) {
     debugDump("preference " + PREF_DISABLEDADDONS + " doesn't exist... " +
               "returning early");
     aCallback();
     return;
   }
   // Uninstall the test add-ons.
   let count = TEST_ADDONS.length;
   function uninstallCompleted(aAddon) {
     if (--count == 0) {
       AddonManager.removeAddonListener(listener);
       // Enable the pre-existing add-ons that were disabled so they wouldn't
       // interfere with the tests.
       let disabledAddons = Services.prefs.getCharPref(PREF_DISABLEDADDONS).split(" ");
       Services.prefs.clearUserPref(PREF_DISABLEDADDONS);
       AddonManager.getAllAddons(function(aAddons) {
         aAddons.forEach(function(aAddon) {
           if (disabledAddons.indexOf(aAddon.id)) {
             aAddon.userDisabled = false;
           }
         });
         aCallback();
       });
     }
   }
   let listener = {
     onUninstalled: uninstallCompleted
   };
   AddonManager.addAddonListener(listener);
   TEST_ADDONS.forEach(function(aName) {
     AddonManager.getAddonByID(aName + ADDON_ID_SUFFIX, function(aAddon) {
       aAddon.uninstall();
     });
   });
 }
 /**
  * Helper function to get the string before the '_' character in an add-on's
  * name or id which is used to determine the add-on test type used by the tests.
  *
  * @param  aName
  *         The test add-on's name or id.
  * @return The string before the '_' character in the string passed in the aName
  *         parameter.
  */
 function getAddonTestType(aName) {
   return aName.split("_")[0];
 }
 /**
  * Helper function to create add-on xpi files for the default test add-ons.
  *
  * @return An array with each member being an nsILocalFile for an add-on XPI
  *         file.
  */
 function getTestAddonXPIFiles() {
   let addonPrepDir = Services.dirsvc.get(NS_APP_USER_PROFILE_50_DIR,
                                          AUS_Ci.nsILocalFile);
   addonPrepDir.append(ADDON_PREP_DIR);
   let bootstrap = addonPrepDir.clone();
   bootstrap.append("bootstrap.js");
   // If a previous test has already created bootstrap.js don't create it again.
   if (!bootstrap.exists()) {
     let bootstrapContents = "function install(data, reason){ }\n" +
                             "function startup(data, reason){ }\n" +
                             "function shutdown(data, reason){ }\n" +
                             "function uninstall(data, reason){ }\n";
     writeFile(bootstrap, bootstrapContents);
   }
   let installRDF = addonPrepDir.clone();
   installRDF.append("install.rdf");
   let xpiFiles = [];
   TEST_ADDONS.forEach(function(aName) {
     let xpiFile = addonPrepDir.clone();
     xpiFile.append(aName + ".xpi");
     if (installRDF.exists())
       installRDF.remove(false);
     writeFile(installRDF, getInstallRDFString(aName));
     gZipW.open(xpiFile, PR_RDWR | PR_CREATE_FILE | PR_TRUNCATE);
     gZipW.addEntryFile(installRDF.leafName,
                        AUS_Ci.nsIZipWriter.COMPRESSION_DEFAULT, installRDF,
                        false);
     gZipW.addEntryFile(bootstrap.leafName,
                        AUS_Ci.nsIZipWriter.COMPRESSION_DEFAULT, bootstrap,
                        false);
     gZipW.close();
     xpiFiles.push(xpiFile);
   });
   return xpiFiles;
 }
 /**
  * Helper function to gets the string representation of the contents of the
  * add-on's install.rdf file.
  *
  * @param  aName
  *         The string to use for the add-on's name which is also used to
  *         construct the local-part in RFC 5322 format of the add-on's ID.
  * @return A string representation of the contents of the add-on's install.rdf
  *         file.
  */
 function getInstallRDFString(aName) {
   let maxVersion = Services.appinfo.platformVersion;
   switch (getAddonTestType(aName)) {
     case "compatible":
       maxVersion = getNewerPlatformVersion();
       break;
     case "appdisabled":
       maxVersion = "0.1";
       break;
   }
   return "<?xml version=\"1.0\"?>\n" +
          "<RDF xmlns=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"\n" +
          "  xmlns:em=\"http://www.mozilla.org/2004/em-rdf#\">\n" +
          "  <Description about=\"urn:mozilla:install-manifest\">\n" +
          "    <em:id>" + aName + ADDON_ID_SUFFIX + "</em:id>\n" +
          "    <em:version>1.0</em:version>\n" +
          "    <em:bootstrap>true</em:bootstrap>\n" +
          "    <em:name>" + aName + "</em:name>\n" +
          "    <em:description>Test Description</em:description>\n" +
          "    <em:targetApplication>\n" +
          "      <Description>\n" +
          "        <em:id>toolkit@mozilla.org</em:id>\n" +
          "        <em:minVersion>undefined</em:minVersion>\n" +
          "        <em:maxVersion>" + maxVersion + "</em:maxVersion>\n" +
          "      </Description>\n" +
          "    </em:targetApplication>\n" +
          "  </Description>\n" +
          "</RDF>";
 }
 /**
  * Closes the update window if it is open and causes the test to fail if an
  * update window is found.
  *
  * @return true if an update window was found, otherwise false.
  */
 function closeUpdateWindow() {
   let updateWindow = getUpdateWindow();
   if (!updateWindow)
     return false;
   ok(false, "Found an existing Update Window from the current or a previous " +
             "test... attempting to close it.");
   updateWindow.close();
   return true;
 }
 /**
  * Gets the update window.
  *
  * @return The nsIDOMWindow for the Update Window if it is open and null
  *         if it isn't.
  */
 function getUpdateWindow() {
   return Services.wm.getMostRecentWindow(UPDATE_WINDOW_NAME);
 }
 /**
  * Helper for background check errors.
  */
 var errorsPrefObserver = {
   observedPref: null,
   maxErrorPref: null,
   /**
    * Sets up a preference observer and sets the associated maximum errors
    * preference used for background notification.
    *
    * @param  aObservePref
    *         The preference to observe.
    * @param  aMaxErrorPref
    *         The maximum errors preference.
    * @param  aMaxErrorCount
    *         The value to set the app.update.cert.maxErrors preference to.
    */
   init: function(aObservePref, aMaxErrorPref, aMaxErrorCount) {
     this.observedPref = aObservePref;
     this.maxErrorPref = aMaxErrorPref;
     let maxErrors = aMaxErrorCount ? aMaxErrorCount : 2;
     Services.prefs.setIntPref(aMaxErrorPref, maxErrors);
     Services.prefs.addObserver(aObservePref, this, false);
   },
   /**
    * Preference observer for the preference specified in |this.observedPref|.
    */
   observe: function XPI_observe(aSubject, aTopic, aData) {
     if (aData == this.observedPref) {
       let errCount = Services.prefs.getIntPref(this.observedPref);
       let errMax = Services.prefs.getIntPref(this.maxErrorPref);
       if (errCount >= errMax) {
         debugDump("removing pref observer");
         Services.prefs.removeObserver(this.observedPref, this);
       }
       else {
         debugDump("notifying AUS");
         SimpleTest.executeSoon(function() {
           gAUS.notify(null);
         });
       }
     }
   }
 };
 /**
  * nsIObserver for receiving window open and close notifications.
  */
 var gWindowObserver = {
   observe: function WO_observe(aSubject, aTopic, aData) {
     let win = aSubject.QueryInterface(AUS_Ci.nsIDOMEventTarget);
     if (aTopic == "domwindowclosed") {
       if (win.location != URI_UPDATE_PROMPT_DIALOG) {
         debugDump("domwindowclosed event for window not being tested - " +
                   "location: " + win.location + "... returning early");
         return;
       }
       // Allow tests the ability to provide their own function (it must be
       // named finishTest) for finishing the test.
       try {
         finishTest();
       }
       catch (e) {
         finishTestDefault();
       }
       return;
     }
     win.addEventListener("load", function WO_observe_onLoad() {
       win.removeEventListener("load", WO_observe_onLoad, false);
       // Ignore windows other than the update UI window.
       if (win.location != URI_UPDATE_PROMPT_DIALOG) {
         debugDump("load event for window not being tested - location: " +
                   win.location + "... returning early");
         return;
       }
       // The first wizard page should always be the dummy page.
       let pageid = win.document.documentElement.currentPage.pageid;
       if (pageid != PAGEID_DUMMY) {
         // This should never happen but if it does this will provide a clue
         // for diagnosing the cause.
         ok(false, "Unexpected load event - pageid got: " + pageid +
            ", expected: " + PAGEID_DUMMY + "... returning early");
         return;
       }
       gWin = win;
       gDocElem = gWin.document.documentElement;
       gDocElem.addEventListener("pageshow", onPageShowDefault, false);
     }, false);
   }
 };